Fill incomplete images in SkCodec parent class

Rather than implementing some sort of "fill" in every
SkCodec subclass for incomplete images, let's make the
parent class handle this situation.

This includes an API change to SkCodec.h

SkCodec::getScanlines() now returns the number of lines it
read successfully, rather than an SkCodec::Result enum.
getScanlines() most often fails on an incomplete input, in
which case it is useful to know how many lines were
successfully decoded - this provides more information than
kIncomplete vs kSuccess.  We do lose information when the
API is used improperly, as we are no longer able to return
kInvalidParameter or kScanlineNotStarted.

Known Issues:
Does not work for incomplete fFrameIsSubset gifs.
Does not work for incomplete icos.

BUG=skia:

Review URL: https://codereview.chromium.org/1332053002

1 files changed, 29 insertions, 37 deletions

diff --git a/tests/SwizzlerTest.cpp b/tests/SwizzlerTest.cpp
index 256a4b2bcd..95aaf38639 100644
--- a/tests/SwizzlerTest.cpp
+++ b/tests/SwizzlerTest.cpp
@@ -9,8 +9,10 @@
 #include "Test.h"
 
 // These are the values that we will look for to indicate that the fill was successful
-static const uint8_t kFillIndex = 0x1;
-static const uint32_t kFillColor = 0x22334455;
+static const uint8_t kFillIndex = 0x11;
+static const uint8_t kFillGray = 0x22;
+static const uint16_t kFill565 = 0x3344;
+static const uint32_t kFillColor = 0x55667788;
 
 static void check_fill(skiatest::Reporter* r,
                        const SkImageInfo& imageInfo,
@@ -18,8 +20,7 @@ static void check_fill(skiatest::Reporter* r,
                        uint32_t endRow,
                        size_t rowBytes,
                        uint32_t offset,
-                       uint32_t colorOrIndex,
-                       SkPMColor* colorTable) {
+                       uint32_t colorOrIndex) {
 
     // Calculate the total size of the image in bytes.  Use the smallest possible size.
     // The offset value tells us to adjust the pointer from the memory we allocate in order
@@ -34,16 +35,15 @@ static void check_fill(skiatest::Reporter* r,
     // Adjust the pointer in order to test on different memory alignments
     uint8_t* imageData = storage.get() + offset;
     uint8_t* imageStart = imageData + rowBytes * startRow;
-
-    // Fill image with the fill value starting at the indicated row
-    SkSwizzler::Fill(imageStart, imageInfo, rowBytes, endRow - startRow + 1, colorOrIndex,
-            colorTable, SkCodec::kNo_ZeroInitialized);
+    const SkImageInfo fillInfo = imageInfo.makeWH(imageInfo.width(), endRow - startRow + 1);
+    SkSampler::Fill(fillInfo, imageStart, rowBytes, colorOrIndex, SkCodec::kNo_ZeroInitialized);
 
     // Ensure that the pixels are filled properly
     // The bots should catch any memory corruption
     uint8_t* indexPtr = imageData + startRow * rowBytes;
     uint8_t* grayPtr = indexPtr;
     uint32_t* colorPtr = (uint32_t*) indexPtr;
+    uint16_t* color565Ptr = (uint16_t*) indexPtr;
     for (uint32_t y = startRow; y <= endRow; y++) {
         for (int32_t x = 0; x < imageInfo.width(); x++) {
             switch (imageInfo.colorType()) {
@@ -54,8 +54,10 @@ static void check_fill(skiatest::Reporter* r,
                     REPORTER_ASSERT(r, kFillColor == colorPtr[x]);
                     break;
                 case kGray_8_SkColorType:
-                    // We always fill kGray with black
-                    REPORTER_ASSERT(r, (uint8_t) kFillColor == grayPtr[x]);
+                    REPORTER_ASSERT(r, kFillGray == grayPtr[x]);
+                    break;
+                case kRGB_565_SkColorType:
+                    REPORTER_ASSERT(r, kFill565 == color565Ptr[x]);
                     break;
                 default:
                     REPORTER_ASSERT(r, false);
@@ -69,12 +71,6 @@ static void check_fill(skiatest::Reporter* r,
 
 // Test Fill() with different combinations of dimensions, alignment, and padding
 DEF_TEST(SwizzlerFill, r) {
-    // Set up a color table
-    SkPMColor colorTable[kFillIndex + 1];
-    colorTable[kFillIndex] = kFillColor;
-    // Apart from the fill index, we will leave the other colors in the color table uninitialized.
-    // If we incorrectly try to fill with this uninitialized memory, the bots will catch it.
-
     // Test on an invalid width and representative widths
     const uint32_t widths[] = { 0, 10, 50 };
 
@@ -83,48 +79,44 @@ DEF_TEST(SwizzlerFill, r) {
     const uint32_t heights[] = { 1, 5, 10 };
 
     // Test on interesting possibilities for row padding
-    const uint32_t paddings[] = { 0, 1, 2, 3, 4 };
+    const uint32_t paddings[] = { 0, 4 };
 
     // Iterate over test dimensions
     for (uint32_t width : widths) {
         for (uint32_t height : heights) {
 
             // Create image info objects
-            const SkImageInfo colorInfo = SkImageInfo::MakeN32(width, height,
-                kUnknown_SkAlphaType);
-            const SkImageInfo indexInfo = colorInfo.makeColorType(kIndex_8_SkColorType);
+            const SkImageInfo colorInfo = SkImageInfo::MakeN32(width, height, kUnknown_SkAlphaType);
             const SkImageInfo grayInfo = colorInfo.makeColorType(kGray_8_SkColorType);
+            const SkImageInfo indexInfo = colorInfo.makeColorType(kIndex_8_SkColorType);
+            const SkImageInfo color565Info = colorInfo.makeColorType(kRGB_565_SkColorType);
 
             for (uint32_t padding : paddings) {
 
                 // Calculate row bytes
-                size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width +
-                        padding;
-                size_t indexRowBytes = width + padding;
-                size_t grayRowBytes = indexRowBytes;
+                const size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width
+                        + padding;
+                const size_t indexRowBytes = width + padding;
+                const size_t grayRowBytes = indexRowBytes;
+                const size_t color565RowBytes =
+                        SkColorTypeBytesPerPixel(kRGB_565_SkColorType) * width + padding;
 
                 // If there is padding, we can invent an offset to change the memory alignment
-                for (uint32_t offset = 0; offset <= padding; offset++) {
+                for (uint32_t offset = 0; offset <= padding; offset += 4) {
 
                     // Test all possible start rows with all possible end rows
                     for (uint32_t startRow = 0; startRow < height; startRow++) {
                         for (uint32_t endRow = startRow; endRow < height; endRow++) {
 
-                            // Fill with an index that we use to look up a color
+                            // Test fill with each color type
                             check_fill(r, colorInfo, startRow, endRow, colorRowBytes, offset,
-                                    kFillIndex, colorTable);
-
-                            // Fill with a color
-                            check_fill(r, colorInfo, startRow, endRow, colorRowBytes, offset,
-                                    kFillColor, nullptr);
-
-                            // Fill with an index
+                                    kFillColor);
                             check_fill(r, indexInfo, startRow, endRow, indexRowBytes, offset,
-                                    kFillIndex, nullptr);
-
-                            // Fill a grayscale image
+                                    kFillIndex);
                             check_fill(r, grayInfo, startRow, endRow, grayRowBytes, offset,
-                                    kFillColor, nullptr);
+                                    kFillGray);
+                            check_fill(r, color565Info, startRow, endRow, color565RowBytes, offset,
+                                    kFill565);
                         }
                     }
                 }