SkPixelSerializer: support indexed pixels

src/images/SkImageEncoder.cpp

 /*
  * Copyright 2009 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageEncoder.h"
 #include "SkBitmap.h"
+#include "SkPixelSerializer.h"
+#include "SkPixmap.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 
 SkImageEncoder::~SkImageEncoder() {}
 
 bool SkImageEncoder::encodeStream(SkWStream* stream, const SkBitmap& bm,
                                   int quality) {
     quality = SkMin32(100, SkMax32(0, quality));
     return this->onEncode(stream, bm, quality);
 }
@@ skipping 30 matching lines @@
     SkAutoTDelete<SkImageEncoder> enc(SkImageEncoder::Create(t));
     return enc.get() ? enc.get()->encodeData(bm, quality) : nullptr;
 }
 
 SkData* SkImageEncoder::EncodeData(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                    Type t, int quality) {
     SkBitmap bm;
     if (!bm.installPixels(info, const_cast<void*>(pixels), rowBytes)) {
         return nullptr;
     }
-    SkAutoTDelete<SkImageEncoder> enc(SkImageEncoder::Create(t));
-    return enc.get() ? enc.get()->encodeData(bm, quality) : nullptr;
+    bm.setImmutable();

[reed1, 2015/12/07 15:01:28]

why is this needed?

[hal.canary, 2015/12/07 15:15:36]

I think it's a good idea to call setImmutable() to absolutely ensure that the
const_cast is okay.

[reed1, 2015/12/07 15:28:29]

I don't disagree, but I think its extraneous, since we're not enforcing it via
an assert, and we don't behave differently w/ or w/o it. My nit-request is to
not call it.

+    return SkImageEncoder::EncodeData(bm, t, quality);
 }
+
+SkData* SkImageEncoder::EncodeData(const SkPixmap& pixmap,
+                                   Type t, int quality) {
+    SkBitmap bm;
+    if (!bm.installPixels(pixmap.info(),
+                          const_cast<void*>(pixmap.addr()),
+                          pixmap.rowBytes(),
+                          pixmap.ctable(), nullptr, nullptr)) {
+        return nullptr;
+    }
+    bm.setImmutable();
+    return SkImageEncoder::EncodeData(bm, t, quality);
+}
+
+namespace {
+class ImageEncoderPixelSerializer final : public SkPixelSerializer {
+protected:
+    bool onUseEncodedData(const void*, size_t) override { return true; }
+    SkData* onEncode(const SkPixmap& pixmap) override {
+        return SkImageEncoder::EncodeData(pixmap, SkImageEncoder::kPNG_Type, 100);
+    }
+    SkData* onEncodePixels(const SkImageInfo& info,
+                           const void* pixels,
+                           size_t rowBytes) override {
+        return SkImageEncoder::EncodeData(info, pixels, rowBytes,
+                                          SkImageEncoder::kPNG_Type, 100);
+    }
+};
+} // namespace
+
+SkPixelSerializer* SkImageEncoder::CreatePixelSerializer() {
+    return new ImageEncoderPixelSerializer;
+}