Make SkAndroidCodec support ico

src/codec/SkBmpStandardCodec.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 "SkBmpStandardCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 42 matching lines @@
 
     Result result = this->prepareToDecode(dstInfo, opts, inputColorPtr, inputColorCount);
     if (kSuccess != result) {
         return result;
     }
     int rows = this->decodeRows(dstInfo, dst, dstRowBytes, opts);
     if (rows != dstInfo.height()) {
         *rowsDecoded = rows;
         return kIncompleteInput;
     }
-    if (fInIco) {
-        return this->decodeIcoMask(dstInfo, dst, dstRowBytes);
-    }
     return kSuccess;
 }
 
 /*
  * Process the color table for the bmp input
  */
  bool SkBmpStandardCodec::createColorTable(SkAlphaType alphaType, int* numColors) {
     // Allocate memory for color table
     uint32_t colorBytes = 0;
     SkPMColor colorTable[256];
@@ skipping 144 matching lines @@
     if (!this->initializeSwizzler(dstInfo, options)) {
         SkCodecPrintf("Error: cannot initialize swizzler.\n");
         return SkCodec::kInvalidConversion;
     }
     return SkCodec::kSuccess;
 }
 
 /*
  * Performs the bitmap decoding for standard input format
  */
-int SkBmpStandardCodec::decodeRows(const SkImageInfo& dstInfo,
-                                               void* dst, size_t dstRowBytes,
-                                               const Options& opts) {
+int SkBmpStandardCodec::decodeRows(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes,
+        const Options& opts) {
     // Iterate over rows of the image
     const int height = dstInfo.height();
     for (int y = 0; y < height; y++) {
         // Read a row of the input
         if (this->stream()->read(fSrcBuffer.get(), fSrcRowBytes) != fSrcRowBytes) {
             SkCodecPrintf("Warning: incomplete input stream.\n");
             return y;
         }
 
         // Decode the row in destination format
         uint32_t row = this->getDstRow(y, dstInfo.height());
 
         void* dstRow = SkTAddOffset<void>(dst, row * dstRowBytes);
         fSwizzler->swizzle(dstRow, fSrcBuffer.get());
     }
 
-    // Finished decoding the entire image
+    if (fInIco) {
+        const int startScanline = this->currScanline();
+        const size_t andMaskRowBytes = SkAlign4(compute_row_bytes(this->getInfo().width(), 1));
+        if (startScanline < 0) {
+            // We are not performing a scanline decode.
+            // Just decode the entire ICO mask and return.
+            decodeIcoMask(dstInfo, dst, dstRowBytes, andMaskRowBytes);
+            return height;
+        }
+
+        // In order to perform a scanline ICO decode, we must be able
+        // to skip ahead in the stream in order to apply the AND mask
+        // to the requested scanlines.  We also must be able to return
+        // the stream to its original position in order to decode the
+        // next scanline on a subsequent request.
+        // We will do this by taking advantage of the fact that
+        // SkIcoCodec always uses a SkMemoryStream as its underlying
+        // representation of the stream.
+        SkMemoryStream* stream = (SkMemoryStream*) this->stream();
+        const size_t startPosition = stream->getPosition();
+
+        const int remainingScanlines = this->getInfo().height() - startScanline - height;
+        const size_t bytesToSkip = remainingScanlines * fSrcRowBytes +
+                startScanline * andMaskRowBytes;
+        if (bytesToSkip != stream->skip(bytesToSkip)) {
+            // FIXME: How can we indicate that this decode was actually incomplete?
+            stream->seek(startPosition);
+            return height;
+        }
+        // FIXME: If decodeIcoMask does not succeed, is there a way that we can
+        //        indicate the decode was incomplete?
+        decodeIcoMask(dstInfo, dst, dstRowBytes, andMaskRowBytes);
+        stream->seek(startPosition);
+    }
+
     return height;
 }
 
-// TODO (msarett): This function will need to be modified in order to perform row by row decodes
-//                 when the Ico scanline decoder is implemented.
-SkCodec::Result SkBmpStandardCodec::decodeIcoMask(const SkImageInfo& dstInfo,
-        void* dst, size_t dstRowBytes) {
+void SkBmpStandardCodec::decodeIcoMask(const SkImageInfo& dstInfo,
+        void* dst, size_t dstRowBytes, size_t srcRowBytes) {
     // BMP in ICO have transparency, so this cannot be 565, and this mask
     // prevents us from using kIndex8. The below code depends on the output
     // being an SkPMColor.
     SkASSERT(dstInfo.colorType() == kN32_SkColorType);
 
-    // The AND mask is always 1 bit per pixel
-    const int width = this->getInfo().width();
-    const size_t rowBytes = SkAlign4(compute_row_bytes(width, 1));
-
     SkPMColor* dstPtr = (SkPMColor*) dst;
     for (int y = 0; y < dstInfo.height(); y++) {
         // The srcBuffer will at least be large enough
-        if (stream()->read(fSrcBuffer.get(), rowBytes) != rowBytes) {
+        if (this->stream()->read(fSrcBuffer.get(), srcRowBytes) != srcRowBytes) {
             SkCodecPrintf("Warning: incomplete AND mask for bmp-in-ico.\n");
-            return kIncompleteInput;
+            return;
         }
 
         int row = this->getDstRow(y, dstInfo.height());
 
         SkPMColor* dstRow =
                 SkTAddOffset<SkPMColor>(dstPtr, row * dstRowBytes);
 
-        for (int x = 0; x < width; x++) {
+        for (int x = 0; x < this->getInfo().width(); x++) {
             int quotient;
             int modulus;
             SkTDivMod(x, 8, &quotient, &modulus);
             uint32_t shift = 7 - modulus;
             uint32_t alphaBit =
                     (fSrcBuffer.get()[quotient] >> shift) & 0x1;
             dstRow[x] &= alphaBit - 1;

[msarett, 2015/11/24 22:43:35]

This is currently broken.  We either need to know about sampling here or we need
to handle decodeIcoMask() in the swizzler.

         }
     }
-    return kSuccess;
 }
 
 uint32_t SkBmpStandardCodec::onGetFillValue(SkColorType colorType, SkAlphaType alphaType) const {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
     if (colorPtr) {
         return get_color_table_fill_value(colorType, colorPtr, 0);
     }
     return INHERITED::onGetFillValue(colorType, alphaType);
 }