Fill incomplete images in SkCodec parent class

src/codec/SkSampler.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 "SkCodec.h"
+#include "SkCodecPriv.h"
+#include "SkSampler.h"
+#include "SkUtils.h"
+
+void SkSampler::Fill(void* dst, SkColorType colorType, int width, int numRows, size_t rowBytes,

[scroggo, 2015/10/07 18:46:39]

Was this code moved cleanly over from SkSwizzler.cpp? (Or are there differences
I should be looking at?)

[msarett, 2015/10/07 20:53:23]

The only difference is that we do not pass in an SkImageInfo in this iteration. 
I am about to change this back anyway :)

+        uint32_t colorOrIndex, SkCodec::ZeroInitialized zeroInit) {
+    SkASSERT(dst != nullptr);
+
+    // Calculate bytes to fill.  We use getSafeSize since the last row may not be padded.
+    SkImageInfo info = SkImageInfo::Make(width, numRows, colorType,
+            SkAlphaType::kUnknown_SkAlphaType);
+    const size_t bytesToFill = info.getSafeSize(rowBytes);
+
+    // Use the proper memset routine to fill the remaining bytes
+    switch (colorType) {
+        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) dst) && SkIsAlign4(rowBytes)) {
+                sk_memset32((uint32_t*) dst, color,
+                        (uint32_t) bytesToFill / sizeof(SkPMColor));
+            } 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");
+                uint32_t* dstRow = (uint32_t*) dst;
+                for (uint32_t row = 0; row < numRows; row++) {
+                    for (int32_t col = 0; col < width; col++) {
+                        dstRow[col] = color;
+                    }
+                    dstRow = SkTAddOffset<uint32_t>(dstRow, rowBytes);
+                }
+            }
+            break;
+        }
+        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 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) dst) && SkIsAlign2(rowBytes)) {
+                sk_memset16((uint16_t*) dst, 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*) dst;
+                for (uint32_t row = 0; row < numRows; row++) {
+                    for (int32_t col = 0; col < 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(dst, (uint8_t) colorOrIndex, bytesToFill);
+            break;
+        default:
+            SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
+            SkASSERT(false);
+            break;
+    }
+}