Scanline decoding for bmp

src/codec/SkCodec_libgif.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_libgif.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 364 matching lines @@
                         // If there is a transparent index, we also use this as
                         // the fill index.
                         fillIndex = transIndex;
                     } else if (fillIndex >= colorCount) {
                         // If the fill index is invalid, we default to 0.  This
                         // behavior is unspecified but matches SkImageDecoder.
                         fillIndex = 0;
                     }
                 }
 
-                // Check if we can skip filling the background of the image.  We
-                // may be able to if the memory is zero initialized.
-                bool skipBackground =
-                        ((kN32_SkColorType == dstColorType && colorTable[fillIndex] == 0) ||
-                        (kIndex_8_SkColorType == dstColorType && fillIndex == 0)) &&
-                        kYes_ZeroInitialized == zeroInit;
-
-
                 // Fill in the color table for indices greater than color count.
                 // This allows for predictable, safe behavior.
                 for (uint32_t i = colorCount; i < maxColors; i++) {
                     colorTable[i] = colorTable[fillIndex];
                 } 
 
                 // Check if image is only a subset of the image frame
                 SkAutoTDelete<SkSwizzler> swizzler(nullptr);
                 if (innerWidth < width || innerHeight < height) {
 
                     // Modify the destination info
                     const SkImageInfo subsetDstInfo = dstInfo.makeWH(innerWidth, innerHeight);
 
                     // Fill the destination with the fill color
                     // FIXME: This may not be the behavior that we want for
                     //        animated gifs where we draw on top of the
                     //        previous frame.
-                    if (!skipBackground) {
-                        SkSwizzler::Fill(dst, dstInfo, dstRowBytes, height, fillIndex, colorTable);
-                    }
+                    SkSwizzler::Fill(dst, dstInfo, dstRowBytes, height, fillIndex, colorTable,
+                            zeroInit);
 
                     // Modify the dst pointer
                     const int32_t dstBytesPerPixel = SkColorTypeBytesPerPixel(dstColorType);
                     dst = SkTAddOffset<void*>(dst,
                                               dstRowBytes * imageTop +
                                               dstBytesPerPixel * imageLeft);
 
                     // Create the subset swizzler
                     swizzler.reset(SkSwizzler::CreateSwizzler(
                             SkSwizzler::kIndex, colorTable, subsetDstInfo,
                             zeroInit, this->getInfo()));
                 } else {
                     // Create the fully dimensional swizzler
                     swizzler.reset(SkSwizzler::CreateSwizzler(
                             SkSwizzler::kIndex, colorTable, dstInfo, 
                             zeroInit, this->getInfo()));
                 }
 
                 // Stores output from dgiflib and input to the swizzler
                 SkAutoTDeleteArray<uint8_t> buffer(new uint8_t[innerWidth]);
 
                 // Check the interlace flag and iterate over rows of the input
                 if (fGif->Image.Interlace) {
                     for (int32_t y = 0; y < innerHeight; y++) {
                         if (GIF_ERROR == DGifGetLine(fGif, buffer.get(), innerWidth)) {
                             // Recover from error by filling remainder of image
-                            if (!skipBackground) {
-                                memset(buffer.get(), fillIndex, innerWidth);
-                                for (; y < innerHeight; y++) {
-                                    void* dstRow = SkTAddOffset<void>(dst, dstRowBytes *
-                                            get_output_row_interlaced(y, innerHeight));
-                                    swizzler->swizzle(dstRow, buffer.get());
-                                }
+                            memset(buffer.get(), fillIndex, innerWidth);
+                            for (; y < innerHeight; y++) {
+                                void* dstRow = SkTAddOffset<void>(dst, dstRowBytes *
+                                        get_output_row_interlaced(y, innerHeight));
+                                swizzler->swizzle(dstRow, buffer.get());
                             }
                             return gif_error(SkStringPrintf(
                                     "Could not decode line %d of %d.\n",
                                     y, height - 1).c_str(), kIncompleteInput);
                         }
                         void* dstRow = SkTAddOffset<void>(dst,
                                 dstRowBytes * get_output_row_interlaced(y, innerHeight));
                         swizzler->swizzle(dstRow, buffer.get());
                     }
                 } else {
                     // Standard mode
                     void* dstRow = dst;
                     for (int32_t y = 0; y < innerHeight; y++) {
                         if (GIF_ERROR == DGifGetLine(fGif, buffer.get(), innerWidth)) {
-                            if (!skipBackground) {
-                                SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes,
-                                                 innerHeight - y, fillIndex, colorTable);
-                            }
+                            SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes, innerHeight - y,
+                                    fillIndex, colorTable, zeroInit);
                             return gif_error(SkStringPrintf(
                                     "Could not decode line %d of %d.\n",
                                     y, height - 1).c_str(), kIncompleteInput);
                         }
                         swizzler->swizzle(dstRow, buffer.get());
                         dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
                     }
                 }
 
                 // FIXME: Gif files may have multiple images stored in a single
@@ skipping 51 matching lines @@
             default:
                 // giflib returns an error code if the record type is not known.
                 // We should catch this error immediately.
                 SkASSERT(false);
                 break;
         }
     } while (TERMINATE_RECORD_TYPE != recordType);
 
     return gif_error("Could not find any images to decode in gif file.\n", kInvalidInput);
 }