Implement Fill() for incomplete decodes to RGBA_F16

src/codec/SkGifCodec.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 "SkColorTable.h"
@@ skipping 476 matching lines @@
         return result;
     }
 
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         return gif_error("Scaling not supported.\n", kInvalidScale);
     }
 
     // Initialize the swizzler
     if (fFrameIsSubset) {
         // Fill the background
-        SkSampler::Fill(dstInfo, dst, dstRowBytes, this->getFillValue(dstInfo.colorType()),
+        SkSampler::Fill(dstInfo, dst, dstRowBytes, this->getFillValue(dstInfo),
                 opts.fZeroInitialized);
     }
 
     // Iterate over rows of the input
     for (int y = fFrameRect.top(); y < fFrameRect.bottom(); y++) {
         if (!this->readRow()) {
             *rowsDecoded = y;
             return gif_error("Could not decode line.\n", kIncompleteInput);
         }
         void* dstRow = SkTAddOffset<void>(dst, dstRowBytes * this->outputScanline(y));
         fSwizzler->swizzle(dstRow, fSrcBuffer.get());
     }
     return kSuccess;
 }
 
 // FIXME: This is similar to the implementation for bmp and png.  Can we share more code or
 //        possibly make this non-virtual?
-uint32_t SkGifCodec::onGetFillValue(SkColorType colorType) const {
+uint64_t SkGifCodec::onGetFillValue(const SkImageInfo& dstInfo) const {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-    return get_color_table_fill_value(colorType, colorPtr, fFillIndex);
+    return get_color_table_fill_value(dstInfo.colorType(), dstInfo.alphaType(), colorPtr,
+                                      fFillIndex, nullptr);
 }
 
 SkCodec::Result SkGifCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
         const SkCodec::Options& opts, SkPMColor inputColorPtr[], int* inputColorCount) {
     return this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, opts);
 }
 
 void SkGifCodec::handleScanlineFrame(int count, int* rowsBeforeFrame, int* rowsInFrame) {
     if (fFrameIsSubset) {
         const int currRow = this->currScanline();
@@ skipping 20 matching lines @@
 }
 
 int SkGifCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
     int rowsBeforeFrame;
     int rowsInFrame;
     this->handleScanlineFrame(count, &rowsBeforeFrame, &rowsInFrame);
 
     if (fFrameIsSubset) {
         // Fill the requested rows
         SkImageInfo fillInfo = this->dstInfo().makeWH(this->dstInfo().width(), count);
-        uint32_t fillValue = this->onGetFillValue(this->dstInfo().colorType());
+        uint64_t fillValue = this->onGetFillValue(this->dstInfo());
         fSwizzler->fill(fillInfo, dst, rowBytes, fillValue, this->options().fZeroInitialized);
 
         // Start to write pixels at the start of the image frame
         dst = SkTAddOffset<void>(dst, rowBytes * rowsBeforeFrame);
     }
 
     for (int i = 0; i < rowsInFrame; i++) {
         if (!this->readRow()) {
             return i + rowsBeforeFrame;
         }
@@ skipping 28 matching lines @@
 int SkGifCodec::onOutputScanline(int inputScanline) const {
     if (fGif->Image.Interlace) {
         if (inputScanline < fFrameRect.top() || inputScanline >= fFrameRect.bottom()) {
             return inputScanline;
         }
         return get_output_row_interlaced(inputScanline - fFrameRect.top(), fFrameRect.height()) +
                 fFrameRect.top();
     }
     return inputScanline;
 }