Adding png scanline decoding to kIndex8

src/codec/SkCodec_libpng.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_libpng.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkBitmap.h"
 #include "SkMath.h"
 #include "SkScanlineDecoder.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
-#include "SkUtils.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper macros
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef png_jmpbuf
 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
 #endif
 
 /* These were dropped in libpng >= 1.4 */
@@ skipping 393 matching lines @@
         case kN32_SkColorType:
             return true;
         default:
             return dst.colorType() == src.colorType();
     }
 }
 
 SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
                                                void* dst, size_t rowBytes,
                                                const Options& options,
+                                               SkPMColor ctable[],
                                                int* ctableCount) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
 
     // FIXME: We already retrieved this information. Store it in SkPngCodec?
     png_uint_32 origWidth, origHeight;
@@ skipping 15 matching lines @@
     } else if (kAlpha_8_SkColorType == requestedInfo.colorType()) {
         // Note: we check the destination, since otherwise we would have
         // told png to upscale.
         SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
         fSrcConfig = SkSwizzler::kGray;
     } else if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
         fSrcConfig = SkSwizzler::kRGBX;
     } else {
         fSrcConfig = SkSwizzler::kRGBA;
     }
+
+    // Copy the color table to the client if they request kIndex8 mode
+    copy_color_table(requestedInfo, fColorTable, ctable, ctableCount);
+
+    // Create the swizzler.  SkPngCodec retains ownership of the color table.
     const SkPMColor* colors = fColorTable ? fColorTable->readColors() : NULL;
     fSwizzler.reset(SkSwizzler::CreateSwizzler(fSrcConfig, colors, requestedInfo,
             dst, rowBytes, options.fZeroInitialized));
     if (!fSwizzler) {
         // FIXME: CreateSwizzler could fail for another reason.
         return kUnimplemented;
     }
 
     // FIXME: Here is where we should likely insert some of the modifications
     // made in the factory.
@@ skipping 36 matching lines @@
     if (!this->handleRewind()) {
         return kCouldNotRewind;
     }
     if (requestedInfo.dimensions() != this->getInfo().dimensions()) {
         return kInvalidScale;
     }
     if (!conversion_possible(requestedInfo, this->getInfo())) {
         return kInvalidConversion;
     }
 
-    // Note that ctableCount will be modified if there is a color table
+    // Note that ctable and ctableCount may be modified if there is a color table
     const Result result = this->initializeSwizzler(requestedInfo, dst, rowBytes,
-                                                   options, ctableCount);
-
-    // Copy the color table to the client if necessary
-    if (kIndex_8_SkColorType == requestedInfo.colorType()) {
-        SkASSERT(NULL != ctable);
-        SkASSERT(NULL != ctableCount);
-        SkASSERT(NULL != fColorTable.get());
-        sk_memcpy32(ctable, fColorTable->readColors(), *ctableCount);
-    }
+                                                   options, ctable, ctableCount);
 
     if (result != kSuccess) {
         return result;
     }
 
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
@@ skipping 97 matching lines @@
 
 private:
     SkPngCodec*         fCodec;     // Unowned.
     bool                fHasAlpha;
     SkAutoMalloc        fStorage;
     uint8_t*            fSrcRow;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
-SkScanlineDecoder* SkPngCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo) {
+SkScanlineDecoder* SkPngCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo,
+        const Options& options, SkPMColor ctable[], int* ctableCount) {
     if (!this->handleRewind()) {
         return NULL;
     }
 
     // Check to see if scaling was requested.
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         return NULL;
     }
 
     if (!conversion_possible(dstInfo, this->getInfo())) {
         SkCodecPrintf("no conversion possible\n");
         return NULL;
     }
 
     // Note: We set dst to NULL since we do not know it yet. rowBytes is not needed,
     // since we'll be manually updating the dstRow, but the SkSwizzler requires it to
     // be at least dstInfo.minRowBytes.
-    Options opts;
-    // FIXME: Pass this in to getScanlineDecoder?
-    opts.fZeroInitialized = kNo_ZeroInitialized;
-    // FIXME: onGetScanlineDecoder does not currently have a way to get color table information
-    // for a kIndex8 decoder.
-    if (this->initializeSwizzler(dstInfo, NULL, dstInfo.minRowBytes(), opts, NULL) != kSuccess) {
+    if (this->initializeSwizzler(dstInfo, NULL, dstInfo.minRowBytes(), options, ctable,
+            ctableCount) != kSuccess) {
         SkCodecPrintf("failed to initialize the swizzler.\n");
         return NULL;
     }
 
     SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
     if (fNumberPasses > 1) {
         // We cannot efficiently do scanline decoding.
         return NULL;
     }
 
     return SkNEW_ARGS(SkPngScanlineDecoder, (dstInfo, this));
 }