Fill incomplete images in SkCodec parent 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"
@@ skipping 696 matching lines @@
     // 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);
 }
 
-void SkSwizzler::Fill(void* dstStartRow, const SkImageInfo& dstInfo, size_t dstRowBytes,
-        uint32_t numRows, uint32_t colorOrIndex, const SkPMColor* colorTable,
-        SkCodec::ZeroInitialized zeroInit) {
-    SkASSERT(dstStartRow != nullptr);
-    SkASSERT(numRows <= (uint32_t) dstInfo.height());
+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 = dstInfo.makeWH(dstInfo.width(), numRows).getSafeSize(dstRowBytes);
+    const size_t bytesToFill = fillInfo.getSafeSize(rowBytes);
 
     // Use the proper memset routine to fill the remaining bytes
-    switch(dstInfo.colorType()) {
-        case kN32_SkColorType:
-            // Assume input is an index if we have a color table
-            uint32_t color;
-            if (nullptr != colorTable) {
-                color = colorTable[(uint8_t) colorOrIndex];
-            // Otherwise, assume the input is a color
-            } else {
-                color = colorOrIndex;
-            }
-
+    switch(fillInfo.colorType()) {

[scroggo, 2015/10/01 14:48:32]

nit: space between "switch" and "("

[msarett, 2015/10/01 18:14:14]

Done.

+        case kN32_SkColorType: {
             // If memory is zero initialized, we may not need to fill
+            uint32_t color = colorOrIndex;
             if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {
                 return;
             }
 
             // We must fill row by row in the case of unaligned row bytes
-            if (SkIsAlign4((size_t) dstStartRow) && SkIsAlign4(dstRowBytes)) {
-                sk_memset32((uint32_t*) dstStartRow, color,
+            if (SkIsAlign4((size_t) fillDst) && SkIsAlign4(rowBytes)) {
+                sk_memset32((uint32_t*) fillDst, color,
                         (uint32_t) bytesToFill / sizeof(SkPMColor));
             } else {
-                // This is an unlikely, slow case
+                // We must fill row by row in the case of unaligned row bytes.  This is an
+                // unlikely, slow case.
                 SkCodecPrintf("Warning: Strange number of row bytes, fill will be slow.\n");
-                uint32_t* dstRow = (uint32_t*) dstStartRow;
-                for (uint32_t row = 0; row < numRows; row++) {
-                    for (int32_t col = 0; col < dstInfo.width(); col++) {
+                uint32_t* dstRow = (uint32_t*) fillDst;
+                for (uint32_t row = 0; row < fillInfo.height(); row++) {
+                    for (int32_t col = 0; col < fillInfo.width(); col++) {
                         dstRow[col] = color;
                     }
-                    dstRow = SkTAddOffset<uint32_t>(dstRow, dstRowBytes);
+                    dstRow = SkTAddOffset<uint32_t>(dstRow, rowBytes);
                 }
             }
             break;
-        case kRGB_565_SkColorType:
+        }
+        case kRGB_565_SkColorType: {
             // If the destination is k565, the caller passes in a 16-bit color.
             // We will not assert that the high bits of colorOrIndex must be zeroed.
             // This allows us to take advantage of the fact that the low 16 bits of an
             // SKPMColor may be a valid a 565 color.  For example, the low 16
             // bits of SK_ColorBLACK are identical to the 565 representation
             // for black.
-            // If we ever want to fill with colorOrIndex != 0, we will probably need
-            // to implement this with sk_memset16().
-            SkASSERT((uint16_t) colorOrIndex == (uint8_t) colorOrIndex);
-            // Fall through
+
+            // If memory is zero initialized, we may not need to fill
+            uint16_t color = (uint16_t) colorOrIndex;
+            if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {
+                return;
+            }
+
+            if (SkIsAlign2((size_t) fillDst) && SkIsAlign2(rowBytes)) {
+                sk_memset16((uint16_t*) fillDst, color, (uint32_t) bytesToFill / sizeof(uint16_t));
+            } else {
+                // We must fill row by row in the case of unaligned row bytes.  This is an
+                // unlikely, slow case.
+                SkCodecPrintf("Warning: Strange number of row bytes, fill will be slow.\n");
+                uint16_t* dstRow = (uint16_t*) fillDst;
+                for (uint32_t row = 0; row < fillInfo.height(); row++) {
+                    for (int32_t col = 0; col < fillInfo.width(); col++) {
+                        dstRow[col] = color;
+                    }
+                    dstRow = SkTAddOffset<uint16_t>(dstRow, rowBytes);
+                }
+            }
+            break;
+        }
         case kIndex_8_SkColorType:
             // On an index destination color type, always assume the input is an index.
             // Fall through
         case kGray_8_SkColorType:
             // If the destination is kGray, the caller passes in an 8-bit color.
             // We will not assert that the high bits of colorOrIndex must be zeroed.
             // This allows us to take advantage of the fact that the low 8 bits of an
             // SKPMColor may be a valid a grayscale color.  For example, the low 8
             // bits of SK_ColorBLACK are identical to the grayscale representation
             // for black.
 
             // If memory is zero initialized, we may not need to fill
             if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == (uint8_t) colorOrIndex) {
                 return;
             }
 
-            memset(dstStartRow, (uint8_t) colorOrIndex, bytesToFill);
+            memset(fillDst, (uint8_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }