Add sampler options to SkScaledBitmapSampler

src/images/SkScaledBitmapSampler.cpp

 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkScaledBitmapSampler.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkTypes.h"
 
 // 8888
 
 static bool Sample_Gray_D8888(void* SK_RESTRICT dstRow,
                               const uint8_t* SK_RESTRICT src,
                               int width, int deltaSrc, int, const SkPMColor[]) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPackARGB32(0xFF, src[0], src[0], src[0]);
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_gray_to_8888_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_gray_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {
     // Dither, unpremul, and skipZeroes have no effect
     return Sample_Gray_D8888;
 }
 
 static bool Sample_RGBx_D8888(void* SK_RESTRICT dstRow,
                               const uint8_t* SK_RESTRICT src,
                               int width, int deltaSrc, int, const SkPMColor[]) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_RGBx_to_8888_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_RGBx_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {
     // Dither, unpremul, and skipZeroes have no effect
     return Sample_RGBx_D8888;
 }
 
 static bool Sample_RGBA_D8888(void* SK_RESTRICT dstRow,
                               const uint8_t* SK_RESTRICT src,
                               int width, int deltaSrc, int, const SkPMColor[]) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     unsigned alphaMask = 0xFF;
     for (int x = 0; x < width; x++) {
@@ skipping 30 matching lines @@
         unsigned alpha = src[3];
         if (0 != alpha) {
             dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         }
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 
-static SkScaledBitmapSampler::RowProc get_RGBA_to_8888_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_RGBA_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {
     // Dither has no effect.
-    if (decoder.getRequireUnpremultipliedColors()) {
+    if (!opts.fPremultiplyAlpha) {
         // We could check each component for a zero, at the expense of extra checks.
         // For now, just return unpremul.
         return Sample_RGBA_D8888_Unpremul;
     }
     // Supply the versions that premultiply the colors
-    if (decoder.getSkipWritingZeroes()) {
+    if (opts.fSkipZeros) {
         return Sample_RGBA_D8888_SkipZ;
     }
     return Sample_RGBA_D8888;
 }
 
 // 565
 
 static bool Sample_Gray_D565(void* SK_RESTRICT dstRow,
                              const uint8_t* SK_RESTRICT src,
                              int width, int deltaSrc, int, const SkPMColor[]) {
@@ skipping 10 matching lines @@
                            int width, int deltaSrc, int y, const SkPMColor[]) {
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     DITHER_565_SCAN(y);
     for (int x = 0; x < width; x++) {
         dst[x] = SkDitherRGBTo565(src[0], src[0], src[0], DITHER_VALUE(x));
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_gray_to_565_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_gray_to_565_proc(const SkScaledBitmapSampler::Options& opts) {
     // Unpremul and skip zeroes make no difference
-    if (decoder.getDitherImage()) {
+    if (opts.fDither) {
         return Sample_Gray_D565_D;
     }
     return Sample_Gray_D565;
 }
 
 static bool Sample_RGBx_D565(void* SK_RESTRICT dstRow,
                              const uint8_t* SK_RESTRICT src,
                              int width, int deltaSrc, int, const SkPMColor[]) {
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPack888ToRGB16(src[0], src[1], src[2]);
         src += deltaSrc;
     }
     return false;
 }
 
 static bool Sample_RGBx_D565_D(void* SK_RESTRICT dstRow,
                                const uint8_t* SK_RESTRICT src,
                                int width, int deltaSrc, int y,
                                const SkPMColor[]) {
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     DITHER_565_SCAN(y);
     for (int x = 0; x < width; x++) {
         dst[x] = SkDitherRGBTo565(src[0], src[1], src[2], DITHER_VALUE(x));
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_RGBx_to_565_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_RGBx_to_565_proc(const SkScaledBitmapSampler::Options& opts) {
     // Unpremul and skip zeroes make no difference
-    if (decoder.getDitherImage()) {
+    if (opts.fDither) {
         return Sample_RGBx_D565_D;
     }
     return Sample_RGBx_D565;
 }
 
 
 static bool Sample_D565_D565(void* SK_RESTRICT dstRow,
                              const uint8_t* SK_RESTRICT src,
                              int width, int deltaSrc, int, const SkPMColor[]) {
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     uint16_t* SK_RESTRICT castedSrc = (uint16_t*) src;
     for (int x = 0; x < width; x++) {
         dst[x] = castedSrc[0];
         castedSrc += deltaSrc >> 1;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_565_to_565_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_565_to_565_proc(const SkScaledBitmapSampler::Options& opts) {
     // Unpremul, dither, and skip zeroes have no effect
     return Sample_D565_D565;
 }
 
 // 4444
 
 static bool Sample_Gray_D4444(void* SK_RESTRICT dstRow,
                               const uint8_t* SK_RESTRICT src,
                               int width, int deltaSrc, int, const SkPMColor[]) {
     SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
@@ skipping 11 matching lines @@
     SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
     DITHER_4444_SCAN(y);
     for (int x = 0; x < width; x++) {
         dst[x] = SkDitherARGB32To4444(0xFF, src[0], src[0], src[0],
                                       DITHER_VALUE(x));
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_gray_to_4444_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_gray_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {
     // Skip zeroes and unpremul make no difference
-    if (decoder.getDitherImage()) {
+    if (opts.fDither) {
         return Sample_Gray_D4444_D;
     }
     return Sample_Gray_D4444;
 }
 
 static bool Sample_RGBx_D4444(void* SK_RESTRICT dstRow,
                               const uint8_t* SK_RESTRICT src,
                               int width, int deltaSrc, int, const SkPMColor[]) {
     SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
     for (int x = 0; x < width; x++) {
@@ skipping 10 matching lines @@
     DITHER_4444_SCAN(y);
 
     for (int x = 0; x < width; x++) {
         dst[x] = SkDitherARGB32To4444(0xFF, src[0], src[1], src[2],
                                       DITHER_VALUE(x));
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_RGBx_to_4444_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_RGBx_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {
     // Skip zeroes and unpremul make no difference
-    if (decoder.getDitherImage()) {
+    if (opts.fDither) {
         return Sample_RGBx_D4444_D;
     }
     return Sample_RGBx_D4444;
 }
 
 static bool Sample_RGBA_D4444(void* SK_RESTRICT dstRow,
                               const uint8_t* SK_RESTRICT src,
                               int width, int deltaSrc, int, const SkPMColor[]) {
     SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
     unsigned alphaMask = 0xFF;
@@ skipping 59 matching lines @@
         if (alpha != 0) {
             SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
             dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));
         }
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 
-static SkScaledBitmapSampler::RowProc get_RGBA_to_4444_proc(const SkImageDecoder& decoder) {
-    if (decoder.getRequireUnpremultipliedColors()) {
+static SkScaledBitmapSampler::RowProc
+get_RGBA_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {
+    if (!opts.fPremultiplyAlpha) {
         // Unpremultiplied is not supported for 4444
         return NULL;
     }
-    const bool dither = decoder.getDitherImage();
-    if (decoder.getSkipWritingZeroes()) {
-        if (dither) {
+    if (opts.fSkipZeros) {
+        if (opts.fDither) {
             return Sample_RGBA_D4444_D_SkipZ;
         }
         return Sample_RGBA_D4444_SkipZ;
     }
-    if (dither) {
+    if (opts.fDither) {
         return Sample_RGBA_D4444_D;
     }
     return Sample_RGBA_D4444;
 }
 
 // Index
 
 #define A32_MASK_IN_PLACE   (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT)
 
 static bool Sample_Index_D8888(void* SK_RESTRICT dstRow,
@@ skipping 22 matching lines @@
         SkPMColor c = ctable[*src];
         cc &= c;
         if (c != 0) {
             dst[x] = c;
         }
         src += deltaSrc;
     }
     return cc != A32_MASK_IN_PLACE;
 }
 
-static SkScaledBitmapSampler::RowProc get_index_to_8888_proc(const SkImageDecoder& decoder) {
-    if (decoder.getRequireUnpremultipliedColors()) {
+static SkScaledBitmapSampler::RowProc
+get_index_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {
+    if (!opts.fPremultiplyAlpha) {
         // Unpremultiplied is not supported for an index source.
         return NULL;
     }
     // Dither makes no difference
-    if (decoder.getSkipWritingZeroes()) {
+    if (opts.fSkipZeros) {
         return Sample_Index_D8888_SkipZ;
     }
     return Sample_Index_D8888;
 }
 
 static bool Sample_Index_D565(void* SK_RESTRICT dstRow,
                                const uint8_t* SK_RESTRICT src,
                        int width, int deltaSrc, int, const SkPMColor ctable[]) {
 
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
@@ skipping 13 matching lines @@
 
     for (int x = 0; x < width; x++) {
         SkPMColor c = ctable[*src];
         dst[x] = SkDitherRGBTo565(SkGetPackedR32(c), SkGetPackedG32(c),
                                   SkGetPackedB32(c), DITHER_VALUE(x));
         src += deltaSrc;
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_index_to_565_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_index_to_565_proc(const SkScaledBitmapSampler::Options& opts) {
     // Unpremultiplied and skip zeroes make no difference
-    if (decoder.getDitherImage()) {
+    if (opts.fDither) {
         return Sample_Index_D565_D;
     }
     return Sample_Index_D565;
 }
 
 static bool Sample_Index_D4444(void* SK_RESTRICT dstRow,
                                const uint8_t* SK_RESTRICT src, int width,
                                int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
@@ skipping 53 matching lines @@
         SkPMColor c = ctable[*src];
         cc &= c;
         if (c != 0) {
             dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));
         }
         src += deltaSrc;
     }
     return cc != A32_MASK_IN_PLACE;
 }
 
-static SkScaledBitmapSampler::RowProc get_index_to_4444_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_index_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {
     // Unpremul not allowed
-    if (decoder.getRequireUnpremultipliedColors()) {
+    if (!opts.fPremultiplyAlpha) {
         return NULL;
     }
-    const bool dither = decoder.getDitherImage();
-    if (decoder.getSkipWritingZeroes()) {
-        if (dither) {
+    if (opts.fSkipZeros) {
+        if (opts.fDither) {
             return Sample_Index_D4444_D_SkipZ;
         }
         return Sample_Index_D4444_SkipZ;
     }
-    if (dither) {
+    if (opts.fDither) {
         return Sample_Index_D4444_D;
     }
     return Sample_Index_D4444;
 }
 
 static bool Sample_Index_DI(void* SK_RESTRICT dstRow,
                             const uint8_t* SK_RESTRICT src,
                             int width, int deltaSrc, int, const SkPMColor[]) {
     if (1 == deltaSrc) {
         memcpy(dstRow, src, width);
     } else {
         uint8_t* SK_RESTRICT dst = (uint8_t*)dstRow;
         for (int x = 0; x < width; x++) {
             dst[x] = src[0];
             src += deltaSrc;
         }
     }
     return false;
 }
 
-static SkScaledBitmapSampler::RowProc get_index_to_index_proc(const SkImageDecoder& decoder) {
+static SkScaledBitmapSampler::RowProc
+get_index_to_index_proc(const SkScaledBitmapSampler::Options& opts) {
     // Unpremul not allowed
-    if (decoder.getRequireUnpremultipliedColors()) {
+    if (!opts.fPremultiplyAlpha) {
         return NULL;
     }
     // Ignore dither and skip zeroes
     return Sample_Index_DI;
 }
 
 // A8
 static bool Sample_Gray_DA8(void* SK_RESTRICT dstRow,
                             const uint8_t* SK_RESTRICT src,
                             int width, int deltaSrc, int,
                             const SkPMColor[]) {
     // Sampling Gray to A8 uses the same function as Index to Index8,
     // except we assume that there is alpha for speed, since an A8
     // bitmap with no alpha is not interesting.
     (void) Sample_Index_DI(dstRow, src, width, deltaSrc, /* y unused */ 0,
                            /* ctable unused */ NULL);
     return true;
 }
 
-static SkScaledBitmapSampler::RowProc get_gray_to_A8_proc(const SkImageDecoder& decoder) {
-    if (decoder.getRequireUnpremultipliedColors()) {
+static SkScaledBitmapSampler::RowProc
+get_gray_to_A8_proc(const SkScaledBitmapSampler::Options& opts) {
+    if (!opts.fPremultiplyAlpha) {
         return NULL;
     }
     // Ignore skip and dither.
     return Sample_Gray_DA8;
 }
 
-typedef SkScaledBitmapSampler::RowProc (*RowProcChooser)(const SkImageDecoder& decoder);
+typedef SkScaledBitmapSampler::RowProc (*RowProcChooser)(const SkScaledBitmapSampler::Options&);
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkScaledBitmapSampler.h"
 
 SkScaledBitmapSampler::SkScaledBitmapSampler(int width, int height,
                                              int sampleSize) {
     fCTable = NULL;
     fDstRow = NULL;
     fRowProc = NULL;
 
@@ skipping 27 matching lines @@
     SkASSERT(fY0 >= 0 && fY0 < height);
 
     fDX = dx;
     fDY = dy;
 
     SkASSERT(fDX > 0 && (fX0 + fDX * (fScaledWidth - 1)) < width);
     SkASSERT(fDY > 0 && (fY0 + fDY * (fScaledHeight - 1)) < height);
 }
 
 bool SkScaledBitmapSampler::begin(SkBitmap* dst, SrcConfig sc,
-                                  const SkImageDecoder& decoder,
+                                  const Options& opts,
                                   const SkPMColor ctable[]) {
     static const RowProcChooser gProcChoosers[] = {
         get_gray_to_8888_proc,
         get_RGBx_to_8888_proc,
         get_RGBA_to_8888_proc,
         get_index_to_8888_proc,
         NULL, // 565 to 8888
 
         get_gray_to_565_proc,
         get_RGBx_to_565_proc,
@@ skipping 74 matching lines @@
             index += 4 * gProcDstConfigSpan;
             break;
         default:
             return false;
     }
 
     RowProcChooser chooser = gProcChoosers[index];
     if (NULL == chooser) {
         fRowProc = NULL;
     } else {
-        fRowProc = chooser(decoder);
+        fRowProc = chooser(opts);
     }
     fDstRow = (char*)dst->getPixels();
     fDstRowBytes = dst->rowBytes();
     fCurrY = 0;
     return fRowProc != NULL;
 }
 
+bool SkScaledBitmapSampler::begin(SkBitmap* dst, SrcConfig sc,
+                                  const SkImageDecoder& decoder,
+                                  const SkPMColor ctable[]) {
+    return this->begin(dst, sc, Options(decoder), ctable);
+}
+
 bool SkScaledBitmapSampler::next(const uint8_t* SK_RESTRICT src) {
     SkASSERT(kInterlaced_SampleMode != fSampleMode);
     SkDEBUGCODE(fSampleMode = kConsecutive_SampleMode);
     SkASSERT((unsigned)fCurrY < (unsigned)fScaledHeight);
 
     bool hadAlpha = fRowProc(fDstRow, src + fX0 * fSrcPixelSize, fScaledWidth,
                              fDX * fSrcPixelSize, fCurrY, fCTable);
     fDstRow += fDstRowBytes;
     fCurrY += 1;
     return hadAlpha;
@@ skipping 114 matching lines @@
                     SkScaledBitmapSampler::RowProc actual = RowProcTester::getRowProc(sampler);
                     SkASSERT(expected == actual);
                     procCounter++;
                 }
             }
         }
     }
     SkASSERT(SK_ARRAY_COUNT(gTestProcs) == procCounter);
 }
 #endif // SK_DEBUG