Add subsetting to SkScaledCodec

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"
@@ skipping 213 matching lines @@
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
     INIT_RESULT_ALPHA;
     // 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.
     if (1 == deltaSrc) {
-        // A non-zero offset is only used when sampling, meaning that deltaSrc will be
-        // greater than 1. The below loop relies on the fact that src remains unchanged.

[scroggo, 2015/10/02 18:27:03]

Does the below loop not need to be updated to take this into account?

[msarett, 2015/10/06 23:01:27]

Don't think so...

[scroggo, 2015/10/07 17:49:39]

Can you help me understand why that is? I thought we previously ran into a
problem where the loop did not match, causing problems...

See Emmalee's comment https://codereview.chromium.org/1260673002#msg92. It looks
like we had to revert patch set 32, and the fix included this assert.

Put another way, did we update dstWidth to take the offset into account? Because
if not, it seems like the memcpy will copy too much, and then the loop will read
too much.

-        SkASSERT(0 == offset);
         memcpy(dst, src, dstWidth);
         for (int x = 0; x < dstWidth; x++) {
             UPDATE_RESULT_ALPHA(ctable[src[x]] >> SK_A32_SHIFT);
         }
     } else {
         for (int x = 0; x < dstWidth; x++) {
             dst[x] = *src;
             UPDATE_RESULT_ALPHA(ctable[*src] >> SK_A32_SHIFT);
             src += deltaSrc;
         }
@@ skipping 263 matching lines @@
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 */
 
 SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
                                        const SkPMColor* ctable,
                                        const SkImageInfo& dstInfo, 
                                        SkCodec::ZeroInitialized zeroInit, 
-                                       const SkImageInfo& srcInfo) {
+                                       const SkImageInfo& srcInfo,
+                                       int subsetLeft, int subsetWidth) {
     if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
         return nullptr;
     }
     if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
             && nullptr == ctable) {
         return nullptr;
     }
     RowProc proc = nullptr;
 
     switch (sc) {
@@ skipping 147 matching lines @@
                 default:
                     break;
             }
         default:
             break;
     }
     if (nullptr == proc) {
         return nullptr;
     }
 
-    // Store deltaSrc in bytes if it is an even multiple, otherwise use bits
-    int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
+    // Store bpp in bytes if it is an even multiple, otherwise use bits
+    int bpp = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
 
     // get sampleX based on srcInfo and dstInfo dimensions
     int sampleX;
-    SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, &sampleX, nullptr);
-
-    return new SkSwizzler(proc, ctable, deltaSrc, dstInfo, sampleX);
+    SkScaledCodec::ComputeSampleSize(dstInfo.dimensions(), srcInfo.dimensions(), &sampleX, nullptr);
+    int x0 = get_start_coord(sampleX) + subsetLeft;
+    
+    return new SkSwizzler(proc, ctable, x0 * bpp, subsetWidth, bpp, sampleX * bpp);
 }
 
 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
-                       int deltaSrc, const SkImageInfo& info, int sampleX)
+                       int left, int width, int bpp, int deltaSrc)
     : fRowProc(proc)
     , fColorTable(ctable)
+    , fLeft(left)
+    , fWidth(width)
+    , fBPP(bpp)
     , fDeltaSrc(deltaSrc)
-    , fDstInfo(info)
-    , fSampleX(sampleX)
-    , fX0(get_start_coord(sampleX))
-{
-    // 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(nullptr != dst && nullptr != src);
-    return fRowProc(dst, src, fDstInfo.width(), fDeltaSrc, fSampleX * fDeltaSrc,
-            fX0 * fDeltaSrc, fColorTable);
+    return fRowProc(dst, src, fWidth, fBPP, fDeltaSrc, fLeft, fColorTable);
 }
 
 void SkSwizzler::Fill(void* fillDst, const SkImageInfo& fillInfo, size_t rowBytes,
         uint32_t colorOrIndex, SkCodec::ZeroInitialized zeroInit) {
     SkASSERT(fillDst != nullptr);
 
     // Calculate bytes to fill.  We use getSafeSize since the last row may not be padded.
     const size_t bytesToFill = fillInfo.getSafeSize(rowBytes);
 
     // Use the proper memset routine to fill the remaining bytes
@@ skipping 70 matching lines @@
             }
 
             memset(fillDst, (uint8_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }