SkPDF: handle unpremul right

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 "SkData.h"
 #include "SkDeflate.h"
@@ skipping 74 matching lines @@
 static U8CPU SkGetR32Component(uint32_t value, SkColorType ct) {
     return (value >> (SkIsBGRA(ct) ? SK_BGRA_R32_SHIFT : SK_RGBA_R32_SHIFT)) & 0xFF;
 }
 static U8CPU SkGetG32Component(uint32_t value, SkColorType ct) {
     return (value >> (SkIsBGRA(ct) ? SK_BGRA_G32_SHIFT : SK_RGBA_G32_SHIFT)) & 0xFF;
 }
 static U8CPU SkGetB32Component(uint32_t value, SkColorType ct) {
     return (value >> (SkIsBGRA(ct) ? SK_BGRA_B32_SHIFT : SK_RGBA_B32_SHIFT)) & 0xFF;
 }
 
-
 // unpremultiply and extract R, G, B components.
 static void pmcolor_to_rgb24(uint32_t color, uint8_t* rgb, SkColorType ct) {
     uint32_t s = SkUnPreMultiply::GetScale(SkGetA32Component(color, ct));
     rgb[0] = SkUnPreMultiply::ApplyScale(s, SkGetR32Component(color, ct));
     rgb[1] = SkUnPreMultiply::ApplyScale(s, SkGetG32Component(color, ct));
     rgb[2] = SkUnPreMultiply::ApplyScale(s, SkGetB32Component(color, ct));
 }
 
 /* It is necessary to average the color component of transparent
    pixels with their surrounding neighbors since the PDF renderer may
@@ skipping 70 matching lines @@
     if (!bitmap.getPixels()) {
         size_t size = pixel_count(bitmap) *
                       pdf_color_component_count(bitmap.colorType());
         fill_stream(out, '\x00', size);
         return;
     }
     SkBitmap copy;
     const SkBitmap& bm = not4444(bitmap, &copy);
     SkAutoLockPixels autoLockPixels(bm);
     SkColorType colorType = bm.colorType();
+    SkAlphaType alphaType = bm.alphaType();
     switch (colorType) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType: {
             SkASSERT(3 == pdf_color_component_count(colorType));
             SkAutoTMalloc<uint8_t> scanline(3 * bm.width());
             for (int y = 0; y < bm.height(); ++y) {
                 const uint32_t* src = bm.getAddr32(0, y);
                 uint8_t* dst = scanline.get();
                 for (int x = 0; x < bm.width(); ++x) {
-                    uint32_t color = *src++;
-                    U8CPU alpha = SkGetA32Component(color, colorType);
-                    if (alpha != SK_AlphaTRANSPARENT) {
-                        pmcolor_to_rgb24(color, dst, colorType);
+                    if (alphaType == kPremul_SkAlphaType) {
+                        uint32_t color = *src++;
+                        U8CPU alpha = SkGetA32Component(color, colorType);
+                        if (alpha != SK_AlphaTRANSPARENT) {
+                            pmcolor_to_rgb24(color, dst, colorType);
+                        } else {
+                            get_neighbor_avg_color(bm, x, y, dst, colorType);
+                        }
+                        dst += 3;
                     } else {
-                        get_neighbor_avg_color(bm, x, y, dst, colorType);
+                        uint32_t color = *src++;
+                        *dst++ = SkGetR32Component(color, colorType);
+                        *dst++ = SkGetG32Component(color, colorType);
+                        *dst++ = SkGetB32Component(color, colorType);
                     }
-                    dst += 3;
                 }
                 out->write(scanline.get(), 3 * bm.width());
             }
             return;
         }
         case kRGB_565_SkColorType: {
             SkASSERT(3 == pdf_color_component_count(colorType));
             SkAutoTMalloc<uint8_t> scanline(3 * bm.width());
             for (int y = 0; y < bm.height(); ++y) {
                 const uint16_t* src = bm.getAddr16(0, y);
@@ skipping 77 matching lines @@
             return;
         case kARGB_4444_SkColorType:
             SkDEBUGFAIL("4444 color type should have been converted to N32");
             return;
         case kUnknown_SkColorType:
         default:
             SkDEBUGFAIL("unexpected color type");
     }
 }
 
-static sk_sp<SkPDFArray> make_indexed_color_space(const SkColorTable* table) {
+static sk_sp<SkPDFArray> make_indexed_color_space(
+        const SkColorTable* table,
+        SkAlphaType alphaType) {
     auto result = sk_make_sp<SkPDFArray>();
     result->reserve(4);
     result->appendName("Indexed");
     result->appendName("DeviceRGB");
     SkASSERT(table);
     if (table->count() < 1) {
         result->appendInt(0);
         char shortTableArray[3] = {0, 0, 0};
         SkString tableString(shortTableArray, SK_ARRAY_COUNT(shortTableArray));
         result->appendString(tableString);
         return result;
     }
     result->appendInt(table->count() - 1);  // maximum color index.
 
     // Potentially, this could be represented in fewer bytes with a stream.
     // Max size as a string is 1.5k.
     char tableArray[256 * 3];
     SkASSERT(3u * table->count() <= SK_ARRAY_COUNT(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, kN32_SkColorType);
-        tablePtr += 3;
+        if (alphaType == kPremul_SkAlphaType) {
+            pmcolor_to_rgb24(colors[i], tablePtr, kN32_SkColorType);
+            tablePtr += 3;
+        } else {
+            *tablePtr++ = SkGetR32Component(colors[i], kN32_SkColorType);
+            *tablePtr++ = SkGetG32Component(colors[i], kN32_SkColorType);
+            *tablePtr++ = SkGetB32Component(colors[i], kN32_SkColorType);
+        }
     }
     SkString tableString(tableArray, 3 * table->count());
     result->appendString(tableString);
     return result;
 }
 
 static void emit_image_xobject(SkWStream* stream,
                                const SkImage* image,
                                bool alpha,
                                const sk_sp<SkPDFObject>& smask,
@@ skipping 16 matching lines @@
 
     SkPDFDict pdfDict("XObject");
     pdfDict.insertName("Subtype", "Image");
     pdfDict.insertInt("Width", bitmap.width());
     pdfDict.insertInt("Height", bitmap.height());
     if (alpha) {
         pdfDict.insertName("ColorSpace", "DeviceGray");
     } else if (bitmap.colorType() == kIndex_8_SkColorType) {
         SkASSERT(1 == pdf_color_component_count(bitmap.colorType()));
         pdfDict.insertObject("ColorSpace",
-                             make_indexed_color_space(bitmap.getColorTable()));
+                             make_indexed_color_space(bitmap.getColorTable(),
+                                                      bitmap.alphaType()));
     } else if (1 == pdf_color_component_count(bitmap.colorType())) {
         pdfDict.insertName("ColorSpace", "DeviceGray");
     } else {
         pdfDict.insertName("ColorSpace", "DeviceRGB");
     }
     if (smask) {
         pdfDict.insertObjRef("SMask", smask);
     }
     pdfDict.insertInt("BitsPerComponent", 8);
     pdfDict.insertName("Filter", "FlateDecode");
@@ skipping 140 matching lines @@
 
     sk_sp<SkPDFObject> smask;
     if (!image_compute_is_opaque(image.get())) {
         smask = sk_make_sp<PDFAlphaBitmap>(image);
     }
     #ifdef SK_PDF_IMAGE_STATS
     gRegularImageObjects.fetch_add(1);
     #endif
     return sk_make_sp<PDFDefaultBitmap>(std::move(image), std::move(smask));
 }