Line data    Source code

       1             : /*
       2             :  * Copyright 2016 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #include "SkColorFilter.h"
       9             : #include "SkHalf.h"
      10             : #include "SkNx.h"
      11             : #include "SkPaint.h"
      12             : #include "SkPixmap.h"
      13             : #include "SkPM4f.h"
      14             : #include "SkPM4fPriv.h"
      15             : #include "SkSpanProcs.h"
      16             : 
      17             : ///////////////////////////////////////////////////////////////////////////////////////////////////
      18             : 
      19           0 : static void load_l32(const SkPixmap& src, int x, int y, SkPM4f span[], int count) {
      20           0 :     SkASSERT(count > 0);
      21           0 :     const uint32_t* addr = src.addr32(x, y);
      22           0 :     SkASSERT(src.addr32(x + count - 1, y));
      23             : 
      24           0 :     for (int i = 0; i < count; ++i) {
      25           0 :         swizzle_rb_if_bgra(Sk4f_fromL32(addr[i])).store(span[i].fVec);
      26             :     }
      27           0 : }
      28             : 
      29           0 : static void load_s32(const SkPixmap& src, int x, int y, SkPM4f span[], int count) {
      30           0 :     SkASSERT(count > 0);
      31           0 :     const uint32_t* addr = src.addr32(x, y);
      32           0 :     SkASSERT(src.addr32(x + count - 1, y));
      33             : 
      34           0 :     for (int i = 0; i < count; ++i) {
      35           0 :         swizzle_rb_if_bgra(Sk4f_fromS32(addr[i])).store(span[i].fVec);
      36             :     }
      37           0 : }
      38             : 
      39           0 : static void load_f16(const SkPixmap& src, int x, int y, SkPM4f span[], int count) {
      40           0 :     SkASSERT(count > 0);
      41           0 :     const uint64_t* addr = src.addr64(x, y);
      42           0 :     SkASSERT(src.addr64(x + count - 1, y));
      43             : 
      44           0 :     for (int i = 0; i < count; ++i) {
      45           0 :         SkHalfToFloat_finite_ftz(addr[i]).store(span[i].fVec);
      46             :     }
      47           0 : }
      48             : 
      49           0 : SkLoadSpanProc SkLoadSpanProc_Choose(const SkImageInfo& info) {
      50           0 :     switch (info.colorType()) {
      51             :         case kN32_SkColorType:
      52           0 :             return info.gammaCloseToSRGB() ? load_s32 : load_l32;
      53             :         case kRGBA_F16_SkColorType:
      54           0 :             return load_f16;
      55             :         default:
      56           0 :             return nullptr;
      57             :     }
      58             : }
      59             : 
      60             : ///////////////////////////////////////////////////////////////////////////////////////////////////
      61             : 
      62           0 : static void noop_filterspan(const SkPaint& paint, SkPM4f[], int) {
      63           0 :     SkASSERT(!paint.getColorFilter());
      64           0 :     SkASSERT(0xFF == paint.getAlpha());
      65           0 : }
      66             : 
      67           0 : static void alpha_filterspan(const SkPaint& paint, SkPM4f span[], int count) {
      68           0 :     SkASSERT(!paint.getColorFilter());
      69           0 :     SkASSERT(0xFF != paint.getAlpha());
      70           0 :     const Sk4f scale = Sk4f(paint.getAlpha() * (1.0f/255));
      71           0 :     for (int i = 0; i < count; ++i) {
      72           0 :         (Sk4f::Load(span[i].fVec) * scale).store(span[i].fVec);
      73             :     }
      74           0 : }
      75             : 
      76           0 : static void colorfilter_filterspan(const SkPaint& paint, SkPM4f span[], int count) {
      77           0 :     SkASSERT(paint.getColorFilter());
      78           0 :     SkASSERT(0xFF == paint.getAlpha());
      79           0 :     paint.getColorFilter()->filterSpan4f(span, count, span);
      80           0 : }
      81             : 
      82           0 : static void colorfilter_alpha_filterspan(const SkPaint& paint, SkPM4f span[], int count) {
      83           0 :     SkASSERT(paint.getColorFilter());
      84           0 :     SkASSERT(0xFF != paint.getAlpha());
      85           0 :     alpha_filterspan(paint, span, count);
      86           0 :     paint.getColorFilter()->filterSpan4f(span, count, span);
      87           0 : }
      88             : 
      89           0 : SkFilterSpanProc SkFilterSpanProc_Choose(const SkPaint& paint) {
      90           0 :     if (paint.getColorFilter()) {
      91           0 :         return 0xFF == paint.getAlpha() ? colorfilter_filterspan : colorfilter_alpha_filterspan;
      92             :     } else {
      93           0 :         return 0xFF == paint.getAlpha() ? noop_filterspan : alpha_filterspan;
      94             :     }
      95             : }