add colortable support to imagegenerator

src/images/SkDecodingImageGenerator.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkImageDecoder.h"
 #include "SkImageInfo.h"
 #include "SkImageGenerator.h"
 #include "SkImagePriv.h"
 #include "SkStream.h"
 #include "SkUtils.h"
 
 namespace {
 bool equal_modulo_alpha(const SkImageInfo& a, const SkImageInfo& b) {
     return a.width() == b.width() && a.height() == b.height() &&
            a.colorType() == b.colorType();
 }
 
 class DecodingImageGenerator : public SkImageGenerator {
 public:
     virtual ~DecodingImageGenerator();
-    virtual SkData* refEncodedData() SK_OVERRIDE;
-    // This implementaion of getInfo() always returns true.
-    virtual bool getInfo(SkImageInfo* info) SK_OVERRIDE;
-    virtual bool getPixels(const SkImageInfo& info,
-                           void* pixels,
-                           size_t rowBytes) SK_OVERRIDE;
 
     SkData*                fData;
     SkStreamRewindable*    fStream;
     const SkImageInfo      fInfo;
     const int              fSampleSize;
     const bool             fDitherImage;
 
     DecodingImageGenerator(SkData* data,
                            SkStreamRewindable* stream,
                            const SkImageInfo& info,
                            int sampleSize,
                            bool ditherImage);
+
+protected:
+    virtual SkData* onRefEncodedData() SK_OVERRIDE;
+    virtual bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+        *info = fInfo;
+        return true;
+    }
+    virtual bool onGetPixels(const SkImageInfo& info,
+                             void* pixels, size_t rowBytes,
+                             SkPMColor ctable[], int* ctableCount) SK_OVERRIDE;
+
+private:
     typedef SkImageGenerator INHERITED;
 };
 
 /**
  *  Special allocator used by getPixels(). Uses preallocated memory
  *  provided if possible, else fall-back on the default allocator
  */
 class TargetAllocator : public SkBitmap::Allocator {
 public:
     TargetAllocator(const SkImageInfo& info,
@@ skipping 62 matching lines @@
 {
     SkASSERT(stream != NULL);
     SkSafeRef(fData);  // may be NULL.
 }
 
 DecodingImageGenerator::~DecodingImageGenerator() {
     SkSafeUnref(fData);
     fStream->unref();
 }
 
-bool DecodingImageGenerator::getInfo(SkImageInfo* info) {
-    if (info != NULL) {
-        *info = fInfo;
-    }
-    return true;
-}
-
-SkData* DecodingImageGenerator::refEncodedData() {
+SkData* DecodingImageGenerator::onRefEncodedData() {
     // This functionality is used in `gm --serialize`
     // Does not encode options.
     if (fData != NULL) {
         return SkSafeRef(fData);
     }
     // TODO(halcanary): SkStreamRewindable needs a refData() function
     // which returns a cheap copy of the underlying data.
     if (!fStream->rewind()) {
         return NULL;
     }
     size_t length = fStream->getLength();
     if (0 == length) {
         return NULL;
     }
     void* buffer = sk_malloc_flags(length, 0);
     SkCheckResult(fStream->read(buffer, length), length);
     fData = SkData::NewFromMalloc(buffer, length);
     return SkSafeRef(fData);
 }
 
-bool DecodingImageGenerator::getPixels(const SkImageInfo& info,
-                                         void* pixels,
-                                         size_t rowBytes) {
-    if (NULL == pixels) {
-        return false;
-    }
+bool DecodingImageGenerator::onGetPixels(const SkImageInfo& info,
+                                         void* pixels, size_t rowBytes,
+                                         SkPMColor ctableEntries[], int* ctableCount) {
     if (fInfo != info) {
         // The caller has specified a different info.  This is an
         // error for this kind of SkImageGenerator.  Use the Options
         // to change the settings.
         return false;
     }
-    if (info.minRowBytes() > rowBytes) {
-        // The caller has specified a bad rowBytes.
-        return false;
-    }
 
     SkAssertResult(fStream->rewind());
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(fStream));
     if (NULL == decoder.get()) {
         return false;
     }
     decoder->setDitherImage(fDitherImage);
     decoder->setSampleSize(fSampleSize);
     decoder->setRequireUnpremultipliedColors(
             info.fAlphaType == kUnpremul_SkAlphaType);
@@ skipping 15 matching lines @@
         bool copySuccess = bitmap.copyTo(&bm, info.colorType(), &allocator);
         if (!copySuccess || allocator.isReady()) {
             SkDEBUGFAIL("bitmap.copyTo(requestedConfig) failed.");
             // Earlier we checked canCopyto(); we expect consistency.
             return false;
         }
         SkASSERT(check_alpha(info.alphaType(), bm.alphaType()));
     } else {
         SkASSERT(check_alpha(info.alphaType(), bitmap.alphaType()));
     }
+
+    if (kIndex_8_SkColorType == info.colorType()) {
+        if (kIndex_8_SkColorType != bitmap.colorType()) {
+            return false;   // they asked for Index8, but we didn't receive that from decoder
+        }
+        SkColorTable* ctable = bitmap.getColorTable();
+        if (NULL == ctable) {
+            return false;
+        }
+        const int count = ctable->count();
+        memcpy(ctableEntries, ctable->lockColors(), count * sizeof(SkPMColor));
+        ctable->unlockColors();
+        *ctableCount = count;
+    }
     return true;
 }
 
 // A contructor-type function that returns NULL on failure.  This
 // prevents the returned SkImageGenerator from ever being in a bad
 // state.  Called by both Create() functions
 SkImageGenerator* CreateDecodingImageGenerator(
         SkData* data,
         SkStreamRewindable* stream,
         const SkDecodingImageGenerator::Options& opts) {
     SkASSERT(stream);
     SkAutoTUnref<SkStreamRewindable> autoStream(stream);  // always unref this.
     if (opts.fUseRequestedColorType &&
         (kIndex_8_SkColorType == opts.fRequestedColorType)) {
         // We do not support indexed color with SkImageGenerators,

[scroggo, 2014/05/28 15:01:37]

This block can be removed.

[reed1, 2014/05/28 15:48:02]

Good catch. Done.

         return NULL;
     }
     SkAssertResult(autoStream->rewind());
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(autoStream));
     if (NULL == decoder.get()) {
         return NULL;
     }
     SkBitmap bitmap;
     decoder->setSampleSize(opts.fSampleSize);
     decoder->setRequireUnpremultipliedColors(opts.fRequireUnpremul);
-    if (!decoder->decode(stream, &bitmap,
-                         SkImageDecoder::kDecodeBounds_Mode)) {
+    if (!decoder->decode(stream, &bitmap, SkImageDecoder::kDecodeBounds_Mode)) {
         return NULL;
     }
-    if (bitmap.config() == SkBitmap::kNo_Config) {
+    if (kUnknown_SkColorType == bitmap.colorType()) {
         return NULL;
     }
 
     SkImageInfo info = bitmap.info();
 
-    if (!opts.fUseRequestedColorType) {
-        // Use default
-        if (kIndex_8_SkColorType == bitmap.colorType()) {
-            // We don't support kIndex8 because we don't support
-            // colortables in this workflow.
-            info.fColorType = kN32_SkColorType;
-        }
-    } else {
+    if (opts.fUseRequestedColorType && (opts.fRequestedColorType != info.colorType())) {
         if (!bitmap.canCopyTo(opts.fRequestedColorType)) {
             SkASSERT(bitmap.colorType() != opts.fRequestedColorType);
             return NULL;  // Can not translate to needed config.
         }
         info.fColorType = opts.fRequestedColorType;
     }
 
     if (opts.fRequireUnpremul && info.fAlphaType != kOpaque_SkAlphaType) {
         info.fAlphaType = kUnpremul_SkAlphaType;
     }
@@ skipping 23 matching lines @@
         SkStreamRewindable* stream,
         const SkDecodingImageGenerator::Options& opts) {
     SkASSERT(stream != NULL);
     SkASSERT(stream->unique());
     if ((stream == NULL) || !stream->unique()) {
         SkSafeUnref(stream);
         return NULL;
     }
     return CreateDecodingImageGenerator(NULL, stream, opts);
 }