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 "SkScaledCodec.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
 
 SkSwizzler::ResultAlpha SkSwizzler::GetResult(uint8_t zeroAlpha,
                                               uint8_t maxAlpha) {
     // In the transparent case, this returns 0x0000
     // In the opaque case, this returns 0xFFFF
     // If the row is neither transparent nor opaque, returns something else
     return (((uint16_t) maxAlpha) << 8) | zeroAlpha;
 }
 
+// samples the row. Does not do anything else but sampling
+static SkSwizzler::ResultAlpha sample565(void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src,
+        int width, int deltaSrc, int offset, const SkPMColor ctable[]){
+
+    src += offset;
+    uint16_t* SK_RESTRICT dst = (uint16_t*) dstRow;
+    for (int x = 0; x < width; x++) {
+        dst[x] = src[1] << 8 | src[0];
+        src += deltaSrc;
+    }
+    // 565 is always opaque
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
 // kBit
 // These routines exclusively choose between white and black
 
 #define GRAYSCALE_BLACK 0
 #define GRAYSCALE_WHITE 0xFF
 
+
 static SkSwizzler::ResultAlpha swizzle_bit_to_grayscale(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
+        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
+
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
 
-    // Determine how many full bytes are in the row
-    int bytesInRow = width >> 3;
-    int i;
-    for (i = 0; i < bytesInRow; i++) {
-        U8CPU currByte = src[i];
-        for (int j = 0; j < 8; j++) {
-            dst[j] = ((currByte >> (7 - j)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+    int x = 0;
+    // increment src by byte offset and bitIndex by bit offset
+    int byteOffset = offset >> 3;
+    src += byteOffset;
+    int bitIndex = offset - byteOffset * 8;
+
+    U8CPU currByte = src[0];
+    int sample = deltaSrc;
+
+    while (x < width) {
+        if (8 == bitIndex) {
+            src++;
+            currByte = *src;
+            bitIndex = 0;
         }
-        dst += 8;
-    }
-
-    // Finish the remaining bits
-    width &= 7;
-    if (width > 0) {
-        U8CPU currByte = src[i];
-        for (int j = 0; j < width; j++) {
-            dst[j] = ((currByte >> 7) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
-            currByte <<= 1;
+        if (deltaSrc == sample) {
+            dst[x] = ((currByte >> (7-bitIndex)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+            sample = 0;
+            x++;
         }
+        sample++;
+        bitIndex++;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 #undef GRAYSCALE_BLACK
 #undef GRAYSCALE_WHITE
 
 static SkSwizzler::ResultAlpha swizzle_bit_to_index(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
+        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
 
-    // Determine how many full bytes are in the row
-    int bytesInRow = width >> 3;
-    int i;
-    for (i = 0; i < bytesInRow; i++) {
-        U8CPU currByte = src[i];
-        for (int j = 0; j < 8; j++) {
-            dst[j] = (currByte >> (7 - j)) & 1;
+    int x = 0;

[scroggo, 2015/08/11 21:33:30]

nit: x is defined several lines before it's used. I think at least some of your
variables might end up being defined lines earlier, since they're used together
in the while loop, but maybe it should instead be a for loop, where x is
declared only in scope of the loop?

+    // increment src by byte offset and bitIndex by bit offset
+    int byteOffset = offset >> 3;
+    src += byteOffset;
+    int bitIndex = offset - byteOffset * 8;
+
+    U8CPU currByte = src[0];
+    int sample = deltaSrc;
+
+    while (x < width) {
+        if (8 == bitIndex) {
+            src++;
+            currByte = *src;
+            bitIndex = 0;
         }
-        dst += 8;
-    }
-
-    // Finish the remaining bits
-    width &= 7;
-    if (width > 0) {
-        U8CPU currByte = src[i];
-        for (int j = 0; j < width; j++) {
-            dst[j] = ((currByte >> 7) & 1);
-            currByte <<= 1;
+        if (deltaSrc == sample) {

[scroggo, 2015/08/11 21:33:30]

Ok, I think I understand this code: we basically loop over each bit, but we do
not actually need each bit, correct?

Could we do something more like the following?

while (x < width) {
  oldByteIndex = byteIndex
  byteIndex = x >> 3;
  if (oldByteIndex != byteIndex) {
    currByte = src[byteIndex];
  }
  dst[x] = // same calculation as today
  x += deltaSrc;
}

I've probably made some mistakes, but basically the idea is to iterate over the
samples we want, rather than iterating over each bit - where some iterations are
just updating values. Do you think my version would faster, slower, depends?

Also, Matt, could you look over these functions? You're more familiar with this
code than I.

[emmaleer, 2015/08/12 14:04:33]

I don't think that way would work, or maybe I'm not undstanding it.
the value assigned to dst[x] depends on bitIndex. So if we don't iterate over
every bit, bit Index won't be correct, then we won't get correct values for
dst[x] (i think).
How does your method deal with bitIndex?

Matt let me know what you think. If we still want to change this function I can
look into making a change similar to what you suggested Leon.

[scroggo, 2015/08/12 14:35:22]

Similar to the first calculation of bitIndex - using a mod operation (using &7).
I'm fine with the function as is, but I was just wondering if the other way
might be more efficient.

[msarett, 2015/08/12 14:37:41]

Emmalee and I revised this function in person to take the approach you are
suggesting :).

I think the result is a swizzling function that is better than the original
without sampling.

+            dst[x] = ((currByte >> (7-bitIndex)) & 1);
+            sample = 0;
+            x++;
         }
+        sample++;
+        bitIndex++;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
+
 static SkSwizzler::ResultAlpha swizzle_bit_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
+        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
 
-    // Determine how many full bytes are in the row
-    int bytesInRow = width >> 3;
-    int i;
-    for (i = 0; i < bytesInRow; i++) {
-        U8CPU currByte = src[i];
-        for (int j = 0; j < 8; j++) {
-            dst[j] = ((currByte >> (7 - j)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+    int x = 0;
+    // increment src by byte offset and bitIndex by bit offset
+    int byteOffset = offset >> 3;
+    src += byteOffset;
+    int bitIndex = offset - byteOffset * 8;
+
+    U8CPU currByte = src[0];
+    int sample = deltaSrc;
+
+    while (x < width) {
+        if (8 == bitIndex) {
+            src++;
+            currByte = *src;
+            bitIndex = 0;
         }
-        dst += 8;
-    }
-
-    // Finish the remaining bits
-    width &= 7;
-    if (width > 0) {
-        U8CPU currByte = src[i];
-        for (int j = 0; j < width; j++) {
-            dst[j] = ((currByte >> 7) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
-            currByte <<= 1;
+        if (deltaSrc == sample) {
+            dst[x] = ((currByte >> (7 - bitIndex)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+            sample = 0;
+            x++;
         }
+        sample++;
+        bitIndex++;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // kIndex1, kIndex2, kIndex4
 
 static SkSwizzler::ResultAlpha swizzle_small_index_to_index(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bitsPerPixel, const SkPMColor ctable[]) {
+        int bitsPerPixel, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
     INIT_RESULT_ALPHA;
     const uint32_t pixelsPerByte = 8 / bitsPerPixel;
     const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte);
     const uint8_t mask = (1 << bitsPerPixel) - 1;
     int x = 0;
     for (uint32_t byte = 0; byte < rowBytes; byte++) {
         uint8_t pixelData = src[byte];
         for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) {
             uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
             UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
             dst[x] = index;
             pixelData <<= bitsPerPixel;
             x++;
         }
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_small_index_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bitsPerPixel, const SkPMColor ctable[]) {
+        int bitsPerPixel, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
     INIT_RESULT_ALPHA;
     const uint32_t pixelsPerByte = 8 / bitsPerPixel;
     const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte);
     const uint8_t mask = (1 << bitsPerPixel) - 1;
     int x = 0;
     for (uint32_t byte = 0; byte < rowBytes; byte++) {
         uint8_t pixelData = src[byte];
         for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) {
             uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
             SkPMColor c = ctable[index];
             UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
             dst[x] = c;
             pixelData <<= bitsPerPixel;
             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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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;
 }
 
 static SkSwizzler::ResultAlpha swizzle_index_to_565(
       void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-      int bytesPerPixel, const SkPMColor ctable[]) {
+      int bytesPerPixel, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering? Requires knowing y, which I think is a bigger
     // change.
+    src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPixel32ToPixel16(ctable[*src]);
         src += bytesPerPixel;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 
 #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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
-    memcpy(dstRow, src, width);
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
+
+    src += offset;
+    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;
 }
 
 static SkSwizzler::ResultAlpha swizzle_gray_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, const SkPMColor ctable[]) {
+        int bytesPerPixel, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering?
+    src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPack888ToRGB16(src[0], src[0], src[0]);
         src += bytesPerPixel;
     }
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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;
 }
 
 // kRGBX
 static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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_rgbx_to_565(
        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-       int bytesPerPixel, const SkPMColor ctable[]) {
+       int bytesPerPixel, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering?
+    src += offset;
     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 += bytesPerPixel;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 
 // kRGBA
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
-        int bytesPerPixel, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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, const SkPMColor ctable[]) {
+        int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
     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 13 matching lines @@
         }
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 */
 
 SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
                                        const SkPMColor* ctable,
-                                       const SkImageInfo& info,
-                                       SkCodec::ZeroInitialized zeroInit) {
-    if (info.colorType() == kUnknown_SkColorType || kUnknown == sc) {
+                                       const SkImageInfo& dstInfo, 
+                                       SkCodec::ZeroInitialized zeroInit, 
+                                       int srcWidth) {
+    if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
         return NULL;
     }
     if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
             && NULL == ctable) {
         return NULL;
     }
     RowProc proc = NULL;
+
     switch (sc) {
         case kBit:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_bit_to_n32;
                     break;
                 case kIndex_8_SkColorType:
                     proc = &swizzle_bit_to_index;
                     break;
                 case kGray_8_SkColorType:
                     proc = &swizzle_bit_to_grayscale;
                     break;
                 default:
                     break;
             }
             break;
         case kIndex1:
         case kIndex2:
         case kIndex4:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_small_index_to_n32;
                     break;
                 case kIndex_8_SkColorType:
                     proc = &swizzle_small_index_to_index;
                     break;
                 default:
                     break;
             }
             break;
         case kIndex:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     // We assume the color premultiplied ctable (or not) as desired.
                     if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                         proc = &swizzle_index_to_n32_skipZ;
                         break;
                     } else {
                         proc = &swizzle_index_to_n32;
                         break;
                     }
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_index_to_565;
                     break;
                 case kIndex_8_SkColorType:
                     proc = &swizzle_index_to_index;
                     break;
                 default:
                     break;
             }
             break;
         case kGray:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_gray_to_n32;
                     break;
                 case kGray_8_SkColorType:
                     proc = &swizzle_gray_to_gray;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_gray_to_565;
                     break;
                 default:
                     break;
             }
             break;
         case kBGR:
         case kBGRX:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_bgrx_to_n32;
                     break;
                 default:
                     break;
             }
             break;
         case kBGRA:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
-                    switch (info.alphaType()) {
+                    switch (dstInfo.alphaType()) {
                         case kUnpremul_SkAlphaType:
                             proc = &swizzle_bgra_to_n32_unpremul;
                             break;
                         case kPremul_SkAlphaType:
                             proc = &swizzle_bgra_to_n32_premul;
                             break;
                         default:
                             break;
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kRGBX:
             // TODO: Support other swizzles.
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_rgbx_to_n32;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_rgbx_to_565;
                 default:
                     break;
             }
             break;
         case kRGBA:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
-                    if (info.alphaType() == kUnpremul_SkAlphaType) {
+                    if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
                         // Respect zeroInit?
                         proc = &swizzle_rgba_to_n32_unpremul;
                     } else {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &swizzle_rgba_to_n32_premul_skipZ;
                         } else {
                             proc = &swizzle_rgba_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kRGB:
-            switch (info.colorType()) {
+            switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_rgbx_to_n32;
                     break;
                 default:
                     break;
             }
             break;
+        case kRGB_565:
+            switch (dstInfo.colorType()) {
+                case kRGB_565_SkColorType:
+                    proc = &sample565;
+                    break;
+                default:
+                    break;
+            }
         default:
             break;
     }
     if (NULL == proc) {
         return NULL;
     }
 
     // Store deltaSrc in bytes if it is an even multiple, otherwise use bits
-    int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) :
-            BitsPerPixel(sc);
-    return SkNEW_ARGS(SkSwizzler, (proc, ctable, deltaSrc, info));
+    int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
+
+    int sampleX = SkScaledCodec::GetSampleSize(srcWidth, dstInfo.width());
+    
+    return SkNEW_ARGS(SkSwizzler, (proc, ctable, deltaSrc, dstInfo, sampleX));
 }
 
 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
-                       int deltaSrc, const SkImageInfo& info)
+                       int deltaSrc, const SkImageInfo& info, int sampleX)
     : fRowProc(proc)
     , fColorTable(ctable)
     , fDeltaSrc(deltaSrc)
     , fDstInfo(info)
-{}
+    , fSampleX(sampleX)
+    , fX0(sampleX == 1 ? 0 : sampleX >> 1)
+{
+    // check that fX0 is less than original width
+    SkASSERT(fX0 >= 0 && fX0 < fDstInfo.width() * fSampleX);
+}
 
 SkSwizzler::ResultAlpha SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(NULL != dst && NULL != src);
-    return fRowProc(dst, src, fDstInfo.width(), fDeltaSrc, fColorTable);
+    return fRowProc(dst, src, fDstInfo.width(), fSampleX * fDeltaSrc, fX0 * fDeltaSrc, 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 48 matching lines @@
             // bits of SK_ColorBLACK are identical to the 565 representation
             // for black.
             memset(dstStartRow, (uint16_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }