SkScaledCodec class

src/codec/SkSwizzler.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkSwizzler.h"
@@ skipping 54 matching lines @@
             x++;
         }
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 // kIndex
 
 static SkSwizzler::ResultAlpha swizzle_index_to_index(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
-    memcpy(dst, src, width);
+    if (1 == deltaSrc) {
+        memcpy(dst, src, width);
+    } else {
+        for (int x = 0; x < width; x++) {
+            dst[x] = src[0];
+            src += deltaSrc;
+        }
+    }
     // TODO (msarett): Should we skip the loop here and guess that the row is opaque/not opaque?
     //                 SkScaledBitmap sampler just guesses that it is opaque.  This is dangerous
     //                 and probably wrong since gif and bmp (rarely) may have alpha.
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
         UPDATE_RESULT_ALPHA(ctable[src[x]] >> SK_A32_SHIFT);
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_index_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
-        SkPMColor c = ctable[src[x]];
+        SkPMColor c = ctable[*src];
         UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
         dst[x] = c;
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
-        SkPMColor c = ctable[src[x]];
+        SkPMColor c = ctable[*src];
         UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
         if (c != 0) {
             dst[x] = c;
         }
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 #undef A32_MASK_IN_PLACE
 
 // kGray
 
 static SkSwizzler::ResultAlpha swizzle_gray_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < width; x++) {
-        dst[x] = SkPackARGB32NoCheck(0xFF, src[x], src[x], src[x]);
+        dst[x] = SkPackARGB32NoCheck(0xFF, *src, *src, *src);
+        src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 static SkSwizzler::ResultAlpha swizzle_gray_to_gray(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
-    memcpy(dstRow, src, width);
+        int deltaSrc, int y, const SkPMColor ctable[]) {
+
+    uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
+    if (1 == deltaSrc) {
+        memcpy(dstRow, src, width);
+    } else {
+        for (int x = 0; x < width; x++) {
+            dst[x] = src[0];
+            src += deltaSrc;
+        }
+    }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // kBGRX
 
 static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // kBGRA
 
 static SkSwizzler::ResultAlpha swizzle_bgra_to_n32_unpremul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
         uint8_t alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_bgra_to_n32_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
         uint8_t alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPreMultiplyARGB(alpha, src[2], src[1], src[0]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 // n32
 static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_unpremul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, int y, const SkPMColor ctable[]) {
+        int deltaSrc, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         if (0 != alpha) {
             dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         }
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 /**
     FIXME: This was my idea to cheat in order to continue taking advantage of skipping zeroes.
     This would be fine for drawing normally, but not for drawing with transfer modes. Being
     honest means we can draw correctly with transfer modes, with the cost of not being able
     to take advantage of Android's free unwritten pages. Something to keep in mind when we
     decide whether to switch to unpremul default.
@@ skipping 161 matching lines @@
 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
                        int deltaSrc, const SkImageInfo& info, void* dst,
                        size_t rowBytes)
     : fRowProc(proc)
     , fColorTable(ctable)
     , fDeltaSrc(deltaSrc)
     , fDstInfo(info)
     , fDstRow(dst)
     , fDstRowBytes(rowBytes)
     , fCurrY(0)
+    , fSampleX(1)
+    , fX0(0)
 {
     SkDEBUGCODE(fNextMode = kUninitialized_NextMode);
 }
 
+void SkSwizzler::setSampleX(int sampleX){
+    if (1 == sampleX) {
+        fX0 = 0;
+        fSampleX = 1;
+    } else {
+        fSampleX = sampleX;
+        // offset first x pixel for more even sampling
+        fX0 = fSampleX >> 1;
+    }
+    // check that fX0 is less than original width
+    SkASSERT(fX0 >= 0 && fX0 < fDstInfo.width() * fSampleX);
+}
+
 SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src) {
     SkASSERT(0 <= fCurrY && fCurrY < fDstInfo.height());
     SkASSERT(fDstRow != NULL);
     SkASSERT(kDesignateRow_NextMode != fNextMode);
     SkDEBUGCODE(fNextMode = kConsecutive_NextMode);
 
     // Decode a row
-    const ResultAlpha result = fRowProc(fDstRow, src, fDstInfo.width(),
-            fDeltaSrc, fCurrY, fColorTable);
+    const ResultAlpha result = fRowProc(fDstRow,  src + fX0 * fDeltaSrc, fDstInfo.width(),
+            fSampleX * fDeltaSrc, fCurrY, fColorTable);
 
     // Move to the next row and return the result
     fCurrY++;
     fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes);
     return result;
 }
 
 SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src,
         int y) {
     SkASSERT(0 <= y && y < fDstInfo.height());
     SkASSERT(kConsecutive_NextMode != fNextMode);
     SkDEBUGCODE(fNextMode = kDesignateRow_NextMode);
     
     // Choose the row
     void* row = SkTAddOffset<void>(fDstRow, y*fDstRowBytes);
 
     // Decode the row
-    return fRowProc(row, src, fDstInfo.width(), fDeltaSrc, fCurrY,
+    return fRowProc(row, src + fX0 * fDeltaSrc, fDstInfo.width(), fSampleX * fDeltaSrc, fCurrY,
             fColorTable);
 }
 
 void SkSwizzler::Fill(void* dstStartRow, const SkImageInfo& dstInfo, size_t dstRowBytes,
         uint32_t numRows, uint32_t colorOrIndex, const SkPMColor* colorTable) {
     SkASSERT(dstStartRow != NULL);
     SkASSERT(numRows <= (uint32_t) dstInfo.height());
 
     // Calculate bytes to fill.  We use getSafeSize since the last row may not be padded.
     const size_t bytesToFill = dstInfo.makeWH(dstInfo.width(), numRows).getSafeSize(dstRowBytes);
@@ skipping 40 matching lines @@
             // bits of SK_ColorBLACK are identical to the grayscale representation
             // for black. 
             memset(dstStartRow, (uint8_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }