PDF: remove last use of SkPDFImage

src/pdf/SkPDFBitmap.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 "SkColorPriv.h"
 #include "SkFlate.h"
 #include "SkPDFBitmap.h"
 #include "SkPDFCanon.h"
 #include "SkPDFCatalog.h"
 #include "SkStream.h"
 #include "SkUnPreMultiply.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static void pdf_stream_begin(SkWStream* stream) {
     static const char streamBegin[] = " stream\n";
     stream->write(streamBegin, strlen(streamBegin));
 }
 
 static void pdf_stream_end(SkWStream* stream) {
     static const char streamEnd[] = "\nendstream";
     stream->write(streamEnd, strlen(streamEnd));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
+// write a single byte to a stream n times.
+static void fill_stream(SkWStream* out, char value, size_t n) {
+    char buffer[4096];
+    memset(buffer, value, sizeof(buffer));
+    for (size_t i = 0; i < n / sizeof(buffer); ++i) {
+        out->write(buffer, sizeof(buffer));
+    }
+    out->write(buffer, n % sizeof(buffer));
+}
+
+// unpremultiply and extract R, G, B components.
+static void pmcolor_to_rgb24(SkPMColor pmColor, uint8_t* rgb) {
+    uint32_t s = SkUnPreMultiply::GetScale(SkGetPackedA32(pmColor));
+    rgb[0] = SkUnPreMultiply::ApplyScale(s, SkGetPackedR32(pmColor));
+    rgb[1] = SkUnPreMultiply::ApplyScale(s, SkGetPackedG32(pmColor));
+    rgb[2] = SkUnPreMultiply::ApplyScale(s, SkGetPackedB32(pmColor));
+}
+
+/* It is necessary to average the color component of transparent
+   pixels with their surrounding neighbors since the PDF renderer may
+   separately re-sample the alpha and color channels when the image is
+   not displayed at its native resolution. Since an alpha of zero
+   gives no information about the color component, the pathological
+   case is a white image with sharp transparency bounds - the color
+   channel goes to black, and the should-be-transparent pixels are
+   rendered as grey because of the separate soft mask and color
+   resizing. e.g.: gm/bitmappremul.cpp */
+static void get_neighbor_avg_color(const SkBitmap& bm,
+                                   int xOrig,
+                                   int yOrig,
+                                   uint8_t rgb[3]) {
+    SkASSERT(kN32_SkColorType == bm.colorType());
+    unsigned a = 0, r = 0, g = 0, b = 0;
+    // Clamp the range to the edge of the bitmap.
+    int yrange[2] = {SkTMax(0, yOrig - 1), SkTMin(yOrig + 2, bm.height())};
+    int xrange[2] = {SkTMax(0, xOrig - 1), SkTMin(xOrig + 2, bm.width())};
+    for (int y = yrange[0]; y < yrange[1]; ++y) {

[reed1, 2015/03/20 12:42:04]

range[0], range[1]... pretty hard to read. Why not ymin and ymax?

[hal.canary, 2015/03/20 13:49:50]

Done.

+        SkPMColor* scanline = bm.getAddr32(0, y);
+        for (int x = xrange[0]; x < xrange[1]; ++x) {
+            SkPMColor pmColor = scanline[x];
+            a += SkGetPackedA32(pmColor);
+            r += SkGetPackedR32(pmColor);
+            g += SkGetPackedG32(pmColor);
+            b += SkGetPackedB32(pmColor);
+        }
+    }
+    if (a > 0) {
+        rgb[0] = 255 * r / a;

[reed1, 2015/03/20 12:42:03]

SkToU8(...) -- this guy asserts in debug that we're not overflowing a byte, and
adds a cast to silence possible warnings.

[hal.canary, 2015/03/20 13:49:50]

Done.

+        rgb[1] = 255 * g / a;
+        rgb[2] = 255 * b / a;
+    } else {
+        rgb[0] = rgb[1] = rgb[2] = 0;
+    }
+}
+
 static size_t pixel_count(const SkBitmap& bm) {
     return SkToSizeT(bm.width()) * SkToSizeT(bm.height());
 }
 
-// write a single byte to a stream n times.
-static void fill_stream(SkWStream* out, char value, size_t n) {
-    char buffer[4096];
-    memset(buffer, value, sizeof(buffer));
-    while (n) {
-        size_t k = SkTMin(n, sizeof(buffer));
-        out->write(buffer, k);
-        n -= k;
+static const SkBitmap& not4444(const SkBitmap& input, SkBitmap* copy) {
+    if (input.colorType() != kARGB_4444_SkColorType) {
+        return input;
+    }
+    // ARGB_4444 is rarely used, so we can do a wasteful tmp copy.
+    SkAssertResult(input.copyTo(copy, kN32_SkColorType));
+    copy->setImmutable();
+    return *copy;
+}
+
+static void bitmap_to_rgb24(const SkBitmap& bitmap, SkWStream* out) {

[reed1, 2015/03/20 12:42:03]

Since this sometimes writes index8 or gray8, perhaps the function should have a
different name?

[hal.canary, 2015/03/20 13:49:50]

Done.

+    if (!bitmap.getPixels()) {
+        if (kIndex_8_SkColorType == bitmap.colorType()) {
+            fill_stream(out, '\x00', pixel_count(bitmap));
+        } else {
+            fill_stream(out, '\xFF', 3 * pixel_count(bitmap));
+        }
+        return;
+    }
+    SkBitmap copy;
+    const SkBitmap& bm = not4444(bitmap, &copy);
+    SkAutoLockPixels autoLockPixels(bm);
+    switch (bm.colorType()) {
+        case kN32_SkColorType: {
+            SkAutoTMalloc<uint8_t> scanline(3 * bm.width());
+            for (int y = 0; y < bm.height(); ++y) {
+                const SkPMColor* src = bm.getAddr32(0, y);
+                uint8_t* dst = scanline.get();
+                for (int x = 0; x < bm.width(); ++x) {
+                    SkPMColor color = *src++;
+                    U8CPU alpha = SkGetPackedA32(color);
+                    if (alpha != SK_AlphaTRANSPARENT) {
+                        pmcolor_to_rgb24(color, dst);
+                    } else {
+                        get_neighbor_avg_color(bm, x, y, dst);
+                    }
+                    dst += 3;
+                }
+                out->write(scanline.get(), 3 * bm.width());
+            }
+            return;
+        }
+        case kRGB_565_SkColorType: {
+            SkAutoTMalloc<uint8_t> scanline(3 * bm.width());
+            for (int y = 0; y < bm.height(); ++y) {
+                const uint16_t* src = bm.getAddr16(0, y);
+                uint8_t* dst = scanline.get();
+                for (int x = 0; x < bm.width(); ++x) {
+                    U16CPU color565 = *src++;
+                    *dst++ = SkPacked16ToR32(color565);
+                    *dst++ = SkPacked16ToG32(color565);
+                    *dst++ = SkPacked16ToB32(color565);
+                }
+                out->write(scanline.get(), 3 * bm.width());
+            }
+            return;
+        }
+        case kAlpha_8_SkColorType:
+            fill_stream(out, '\x00', 3 * pixel_count(bm));
+            return;
+        case kGray_8_SkColorType:   // grayscale8, not actually rgb24 format.
+        case kIndex_8_SkColorType:  // indexed8, not actually rgb24 format.
+            // these two formats need no transformation to serialize.
+            for (int y = 0; y < bm.height(); ++y) {
+                out->write(bm.getAddr8(0, y), bm.width());
+            }
+            return;
+        case kUnknown_SkColorType:
+        case kARGB_4444_SkColorType:
+        default:
+            SkASSERT(false);
     }
 }
 
-static SkPMColor get_pmcolor_neighbor_avg_color(const SkBitmap& bitmap,
-                                                int xOrig,
-                                                int yOrig) {
-    SkASSERT(kN32_SkColorType == bitmap.colorType());
-    SkASSERT(bitmap.getPixels());
-    uint8_t count = 0;
-    unsigned r = 0;
-    unsigned g = 0;
-    unsigned b = 0;
-    for (int y = yOrig - 1; y <= yOrig + 1; ++y) {
-        if (y < 0 || y >= bitmap.height()) {
-            continue;
+////////////////////////////////////////////////////////////////////////////////
+
+static void bitmap_alpha_to_a8(const SkBitmap& bitmap, SkWStream* out) {
+    if (!bitmap.getPixels()) {
+        fill_stream(out, '\xFF', pixel_count(bitmap));
+        return;
+    }
+    SkBitmap copy;
+    const SkBitmap& bm = not4444(bitmap, &copy);
+    SkAutoLockPixels autoLockPixels(bm);
+    switch (bm.colorType()) {
+        case kN32_SkColorType: {
+            SkAutoTMalloc<uint8_t> scanline(bm.width());
+            for (int y = 0; y < bm.height(); ++y) {
+                uint8_t* dst = scanline.get();
+                const SkPMColor* src = bm.getAddr32(0, y);
+                for (int x = 0; x < bm.width(); ++x) {
+                    *dst++ = SkGetPackedA32(*src++);
+                }
+                out->write(scanline.get(), bm.width());
+            }
+            return;
         }
-        uint32_t* src = bitmap.getAddr32(0, y);
-        for (int x = xOrig - 1; x <= xOrig + 1; ++x) {
-            if (x < 0 || x >= bitmap.width()) {
-                continue;
+        case kAlpha_8_SkColorType:
+            for (int y = 0; y < bm.height(); ++y) {
+                out->write(bm.getAddr8(0, y), bm.width());
             }
-            SkPMColor pmColor = src[x];
-            U8CPU alpha = SkGetPackedA32(pmColor);
-            if (alpha != SK_AlphaTRANSPARENT) {
-                uint32_t s = SkUnPreMultiply::GetScale(alpha);
-                r += SkUnPreMultiply::ApplyScale(s, SkGetPackedR32(pmColor));
-                g += SkUnPreMultiply::ApplyScale(s, SkGetPackedG32(pmColor));
-                b += SkUnPreMultiply::ApplyScale(s, SkGetPackedB32(pmColor));
-                ++count;
+            return;
+        case kIndex_8_SkColorType: {
+            SkColorTable* ct = bm.getColorTable();
+            SkASSERT(ct);
+            SkAutoTMalloc<uint8_t> scanline(bm.width());
+            for (int y = 0; y < bm.height(); ++y) {
+                uint8_t* dst = scanline.get();
+                const uint8_t* src = bm.getAddr8(0, y);
+                for (int x = 0; x < bm.width(); ++x) {
+                    *dst++ = SkGetPackedA32((*ct)[*src++]);
+                }
+                out->write(scanline.get(), bm.width());
             }
+            return;
         }
-    }
-    if (count == 0) {
-        return SkPackARGB32NoCheck(SK_AlphaOPAQUE, 0, 0, 0);
-    } else {
-        return SkPackARGB32NoCheck(
-                SK_AlphaOPAQUE, r / count, g / count, b / count);
+        case kRGB_565_SkColorType:    // no alpha
+        case kARGB_4444_SkColorType:  // converted to N32

[reed1, 2015/03/20 12:42:03]

what does "converted to N32" mean? Does it mean we should never see this enum in
this function? Should we assert that?

[hal.canary, 2015/03/20 13:49:50]

That's why I skassert(false).

+        case kGray_8_SkColorType:     // no alpha
+        case kUnknown_SkColorType:    // unsupported
+        default:
+            SkASSERT(false);
     }
 }
 
-static void pmcolor_to_rgb24(const SkBitmap& bm, SkWStream* out) {
-    SkASSERT(kN32_SkColorType == bm.colorType());
-    if (!bm.getPixels()) {
-        fill_stream(out, '\xFF', 3 * pixel_count(bm));
-        return;
-    }
-    size_t scanlineLength = 3 * bm.width();
-    SkAutoTMalloc<uint8_t> scanline(scanlineLength);
-    for (int y = 0; y < bm.height(); ++y) {
-        uint8_t* dst = scanline.get();
-        const SkPMColor* src = bm.getAddr32(0, y);
-        for (int x = 0; x < bm.width(); ++x) {
-            SkPMColor color = *src++;
-            U8CPU alpha = SkGetPackedA32(color);
-            if (alpha != SK_AlphaTRANSPARENT) {
-                uint32_t s = SkUnPreMultiply::GetScale(alpha);
-                *dst++ = SkUnPreMultiply::ApplyScale(s, SkGetPackedR32(color));
-                *dst++ = SkUnPreMultiply::ApplyScale(s, SkGetPackedG32(color));
-                *dst++ = SkUnPreMultiply::ApplyScale(s, SkGetPackedB32(color));
-            } else {
-                /* It is necessary to average the color component of
-                   transparent pixels with their surrounding neighbors
-                   since the PDF renderer may separately re-sample the
-                   alpha and color channels when the image is not
-                   displayed at its native resolution. Since an alpha
-                   of zero gives no information about the color
-                   component, the pathological case is a white image
-                   with sharp transparency bounds - the color channel
-                   goes to black, and the should-be-transparent pixels
-                   are rendered as grey because of the separate soft
-                   mask and color resizing. e.g.: gm/bitmappremul.cpp */
-                color = get_pmcolor_neighbor_avg_color(bm, x, y);
-                *dst++ = SkGetPackedR32(color);
-                *dst++ = SkGetPackedG32(color);
-                *dst++ = SkGetPackedB32(color);
-            }
-        }
-        out->write(scanline.get(), scanlineLength);
-    }
-}
-
-static void pmcolor_alpha_to_a8(const SkBitmap& bm, SkWStream* out) {
-    SkASSERT(kN32_SkColorType == bm.colorType());
-    if (!bm.getPixels()) {
-        fill_stream(out, '\xFF', pixel_count(bm));
-        return;
-    }
-    size_t scanlineLength = bm.width();
-    SkAutoTMalloc<uint8_t> scanline(scanlineLength);
-    for (int y = 0; y < bm.height(); ++y) {
-        uint8_t* dst = scanline.get();
-        const SkPMColor* src = bm.getAddr32(0, y);
-        for (int x = 0; x < bm.width(); ++x) {
-            *dst++ = SkGetPackedA32(*src++);
-        }
-        out->write(scanline.get(), scanlineLength);
-    }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 // This SkPDFObject only outputs the alpha layer of the given bitmap.
 class PDFAlphaBitmap : public SkPDFObject {
 public:
     PDFAlphaBitmap(const SkBitmap& bm) : fBitmap(bm) {}
     ~PDFAlphaBitmap() {}
     void emitObject(SkWStream*, SkPDFCatalog*) SK_OVERRIDE;
-    void addResources(SkTSet<SkPDFObject*>*, SkPDFCatalog*) const SK_OVERRIDE {}
 
 private:
     const SkBitmap fBitmap;
-    void emitDict(SkWStream*, SkPDFCatalog*, size_t, bool) const;
+    void emitDict(SkWStream*, SkPDFCatalog*, size_t) const;
 };
 
 void PDFAlphaBitmap::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     SkAutoLockPixels autoLockPixels(fBitmap);
+    SkASSERT(fBitmap.colorType() != kIndex_8_SkColorType ||
+             fBitmap.getColorTable());
 
-#ifndef SK_NO_FLATE
     // Write to a temporary buffer to get the compressed length.
     SkDynamicMemoryWStream buffer;
     SkDeflateWStream deflateWStream(&buffer);
-    pmcolor_alpha_to_a8(fBitmap, &deflateWStream);
+    bitmap_alpha_to_a8(fBitmap, &deflateWStream);
     deflateWStream.finalize();  // call before detachAsStream().
     SkAutoTDelete<SkStreamAsset> asset(buffer.detachAsStream());
 
-    this->emitDict(stream, catalog, asset->getLength(), /*deflate=*/true);
+    this->emitDict(stream, catalog, asset->getLength());
     pdf_stream_begin(stream);
     stream->writeStream(asset.get(), asset->getLength());
     pdf_stream_end(stream);
-#else
-    this->emitDict(stream, catalog, pixel_count(fBitmap), /*deflate=*/false);
-    pdf_stream_begin(stream);
-    pmcolor_alpha_to_a8(fBitmap, stream);
-    pdf_stream_end(stream);
-#endif  // SK_NO_FLATE
 }
 
 void PDFAlphaBitmap::emitDict(SkWStream* stream,
                               SkPDFCatalog* catalog,
-                              size_t length,
-                              bool deflate) const {
+                              size_t length) const {
     SkPDFDict pdfDict("XObject");
     pdfDict.insertName("Subtype", "Image");
     pdfDict.insertInt("Width", fBitmap.width());
     pdfDict.insertInt("Height", fBitmap.height());
     pdfDict.insertName("ColorSpace", "DeviceGray");
     pdfDict.insertInt("BitsPerComponent", 8);
-    if (deflate) {
-        pdfDict.insertName("Filter", "FlateDecode");
-    }
+    pdfDict.insertName("Filter", "FlateDecode");
     pdfDict.insertInt("Length", length);
     pdfDict.emitObject(stream, catalog);
 }
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void SkPDFBitmap::addResources(SkTSet<SkPDFObject*>* resourceSet,
                                SkPDFCatalog* catalog) const {
     if (fSMask.get()) {
-        resourceSet->add(fSMask.get());
+        if (resourceSet->add(fSMask.get())) {
+            fSMask->addResources(resourceSet, catalog);
+        }
     }
 }
 
 void SkPDFBitmap::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     SkAutoLockPixels autoLockPixels(fBitmap);
+    SkASSERT(fBitmap.colorType() != kIndex_8_SkColorType ||
+             fBitmap.getColorTable());
 
-#ifndef SK_NO_FLATE
     // Write to a temporary buffer to get the compressed length.
     SkDynamicMemoryWStream buffer;
     SkDeflateWStream deflateWStream(&buffer);
-    pmcolor_to_rgb24(fBitmap, &deflateWStream);
+    bitmap_to_rgb24(fBitmap, &deflateWStream);
     deflateWStream.finalize();  // call before detachAsStream().
     SkAutoTDelete<SkStreamAsset> asset(buffer.detachAsStream());
 
-    this->emitDict(stream, catalog, asset->getLength(), /*deflate=*/true);
+    this->emitDict(stream, catalog, asset->getLength());
     pdf_stream_begin(stream);
     stream->writeStream(asset.get(), asset->getLength());
     pdf_stream_end(stream);
-#else
-    this->emitDict(stream, catalog, 3 * pixel_count(fBitmap), /*deflate=*/false);
-    pdf_stream_begin(stream);
-    pmcolor_to_rgb24(fBitmap, stream);
-    pdf_stream_end(stream);
-    return;
-#endif  // SK_NO_FLATE
+}
+
+static SkPDFArray* make_indexed_color_space(const SkColorTable* table) {
+    SkPDFArray* result = SkNEW(SkPDFArray);
+    result->reserve(4);
+    result->appendName("Indexed");
+    result->appendName("DeviceRGB");
+    SkASSERT(table);
+    result->appendInt(table->count() - 1);
+
+    // Potentially, this could be represented in fewer bytes with a stream.
+    // Max size as a string is 1.5k.
+    char tableArray[768];
+    SkASSERT(3u * table->count() <= sizeof(tableArray));
+    uint8_t* tablePtr = reinterpret_cast<uint8_t*>(tableArray);
+    const SkPMColor* colors = table->readColors();
+    for (int i = 0; i < table->count(); i++) {
+        pmcolor_to_rgb24(colors[i], tablePtr);
+        tablePtr += 3;
+    }
+    SkString tableString(tableArray, 3 * table->count());
+    result->append(new SkPDFString(tableString))->unref();
+    return result;
 }
 
 void SkPDFBitmap::emitDict(SkWStream* stream,
                            SkPDFCatalog* catalog,
-                           size_t length,
-                           bool deflate) const {
+                           size_t length) const {
     SkPDFDict pdfDict("XObject");
     pdfDict.insertName("Subtype", "Image");
     pdfDict.insertInt("Width", fBitmap.width());
     pdfDict.insertInt("Height", fBitmap.height());
-    pdfDict.insertName("ColorSpace", "DeviceRGB");
+    if (fBitmap.colorType() == kGray_8_SkColorType) {
+        pdfDict.insertName("ColorSpace", "DeviceGray");
+    } else if (fBitmap.colorType() == kIndex_8_SkColorType) {
+        pdfDict.insert("ColorSpace", make_indexed_color_space(
+                                             fBitmap.getColorTable()))->unref();
+    } else {
+        pdfDict.insertName("ColorSpace", "DeviceRGB");
+    }
     pdfDict.insertInt("BitsPerComponent", 8);
     if (fSMask) {
         pdfDict.insert("SMask", new SkPDFObjRef(fSMask))->unref();
     }
-    if (deflate) {
-        pdfDict.insertName("Filter", "FlateDecode");
-    }
+    pdfDict.insertName("Filter", "FlateDecode");
     pdfDict.insertInt("Length", length);
     pdfDict.emitObject(stream, catalog);
 }
 
 SkPDFBitmap::SkPDFBitmap(const SkBitmap& bm,
                          SkPDFObject* smask)
     : fBitmap(bm), fSMask(smask) {}
 
 SkPDFBitmap::~SkPDFBitmap() {}
 
 ////////////////////////////////////////////////////////////////////////////////
-static bool is_transparent(const SkBitmap& bm) {
-    SkAutoLockPixels autoLockPixels(bm);
-    if (NULL == bm.getPixels()) {
-        return true;
+
+static const SkBitmap& immutable_bitmap(const SkBitmap& bm, SkBitmap* copy) {
+    if (bm.isImmutable()) {
+        return bm;
     }
-    SkASSERT(kN32_SkColorType == bm.colorType());
-    for (int y = 0; y < bm.height(); ++y) {
-        U8CPU alpha = 0;
-        const SkPMColor* src = bm.getAddr32(0, y);
-        for (int x = 0; x < bm.width(); ++x) {
-            alpha |= SkGetPackedA32(*src++);
-        }
-        if (alpha) {
-            return false;
-        }
-    }
-    return true;
+    bm.copyTo(copy);
+    copy->setImmutable();
+    return *copy;
 }
 
-SkPDFBitmap* SkPDFBitmap::Create(SkPDFCanon* canon,
-                                 const SkBitmap& bitmap,
-                                 const SkIRect& subset) {
+SkPDFBitmap* SkPDFBitmap::Create(SkPDFCanon* canon, const SkBitmap& bitmap) {
     SkASSERT(canon);
-    if (kN32_SkColorType != bitmap.colorType()) {
-        // TODO(halcanary): support other colortypes.
+    if (!SkColorTypeIsValid(bitmap.colorType()) ||
+        kUnknown_SkColorType == bitmap.colorType()) {
         return NULL;
     }
-    SkBitmap bm;
-    // Should extractSubset be done by the SkPDFDevice?
-    if (!bitmap.extractSubset(&bm, subset)) {
-        return NULL;
-    }
+    SkBitmap copy;
+    const SkBitmap& bm = immutable_bitmap(bitmap, &copy);
     if (bm.drawsNothing()) {
         return NULL;
     }
-    if (!bm.isImmutable()) {
-        SkBitmap copy;
-        if (!bm.copyTo(&copy)) {
-            return NULL;
-        }
-        copy.setImmutable();
-        bm = copy;
-    }
-
-    SkPDFBitmap* pdfBitmap = canon->findBitmap(bm);
-    if (pdfBitmap) {
-        return SkRef(pdfBitmap);
+    if (SkPDFBitmap* canonBitmap = canon->findBitmap(bm)) {
+        return SkRef(canonBitmap);
     }
     SkPDFObject* smask = NULL;
     if (!bm.isOpaque() && !SkBitmap::ComputeIsOpaque(bm)) {
-        if (is_transparent(bm)) {
-            return NULL;
-        }
-        // PDFAlphaBitmaps do not get directly canonicalized (they
-        // are refed by the SkPDFBitmap).
         smask = SkNEW_ARGS(PDFAlphaBitmap, (bm));
     }
-    pdfBitmap = SkNEW_ARGS(SkPDFBitmap, (bm, smask));
+    SkPDFBitmap* pdfBitmap = SkNEW_ARGS(SkPDFBitmap, (bm, smask));
     canon->addBitmap(pdfBitmap);
     return pdfBitmap;
 }