Unpremultiply SkBitmaps for PDF output

src/pdf/SkPDFImage.cpp

 /*
  * Copyright 2010 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 "SkPDFImage.h"
 
 #include "SkBitmap.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkPDFCatalog.h"
 #include "SkRect.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkUnPreMultiply.h"
 
 namespace {
 
+/**
+ * Unpremultiply an ARGB color, keeping the output in the same format
+ * as the input.
+ */
+static uint32_t unpremultiply_argb8888(uint32_t src) {
+    uint8_t a = SkGetPackedA32(src);
+    SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(a);
+    return SkPackARGB32NoCheck(
+            a,
+            SkUnPreMultiply::ApplyScale(scale, SkGetPackedR32(src)),
+            SkUnPreMultiply::ApplyScale(scale, SkGetPackedG32(src)),
+            SkUnPreMultiply::ApplyScale(scale, SkGetPackedB32(src)));
+}
+
+static uint16_t unpremultiply_argb4444(uint16_t src) {
+    uint32_t src32 = SkPixel4444ToPixel32(src);
+    uint8_t a = SkGetPackedA32(src32);
+    SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(a);
+    src32 = SkPackARGB32NoCheck(
+                a,
+                SkUnPreMultiply::ApplyScale(scale, SkGetPackedR32(src32)),
+                SkUnPreMultiply::ApplyScale(scale, SkGetPackedG32(src32)),
+                SkUnPreMultiply::ApplyScale(scale, SkGetPackedB32(src32)));
+    return SkPixel32ToPixel4444(src32);
+}
+
 void extractImageData(const SkBitmap& bitmap, const SkIRect& srcRect,
                       SkStream** imageData, SkStream** alphaData) {
     SkMemoryStream* image = NULL;
     SkMemoryStream* alpha = NULL;
     bool hasAlpha = false;
     bool isTransparent = false;
 
     bitmap.lockPixels();
     switch (bitmap.getConfig()) {
         case SkBitmap::kIndex8_Config: {
@@ skipping 11 matching lines @@
             const int rowBytes = (srcRect.width() * 3 + 1) / 2;
             const int alphaRowBytes = (srcRect.width() + 1) / 2;
             image = new SkMemoryStream(rowBytes * srcRect.height());
             alpha = new SkMemoryStream(alphaRowBytes * srcRect.height());
             uint8_t* dst = (uint8_t*)image->getMemoryBase();
             uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase();
             for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
                 uint16_t* src = bitmap.getAddr16(0, y);
                 int x;
                 for (x = srcRect.fLeft; x + 1 < srcRect.fRight; x += 2) {
-                    dst[0] = (SkGetPackedR4444(src[x]) << 4) |
-                        SkGetPackedG4444(src[x]);
-                    dst[1] = (SkGetPackedB4444(src[x]) << 4) |
-                        SkGetPackedR4444(src[x + 1]);
-                    dst[2] = (SkGetPackedG4444(src[x + 1]) << 4) |
-                        SkGetPackedB4444(src[x + 1]);
-                    dst += 3;
-                    alphaDst[0] = (SkGetPackedA4444(src[x]) << 4) |
-                        SkGetPackedA4444(src[x + 1]);
-                    if (alphaDst[0] != 0xFF) {
+                    uint16_t pixel0 = src[x], pixel1 = src[x + 1];

[vandebo (ex-Chrome), 2013/08/09 16:56:49]

two lines.

[ducky, 2013/08/09 21:45:14]

Done.

+
+                    alphaDst[0] = (SkGetPackedA4444(pixel0) << 4) |
+                                   SkGetPackedA4444(pixel1);
+                    if (SkGetPackedA4444(pixel0) != 0xF) {
                         hasAlpha = true;
+                        pixel0 = unpremultiply_argb4444(pixel0);
+                    }
+                    if (SkGetPackedA4444(pixel1) != 0xF) {
+                        hasAlpha = true;
+                        pixel1 = unpremultiply_argb4444(pixel1);
                     }
                     if (alphaDst[0]) {
                         isTransparent = false;
                     }
+
+                    dst[0] = (SkGetPackedR4444(pixel0) << 4) |
+                        SkGetPackedG4444(pixel0);
+                    dst[1] = (SkGetPackedB4444(pixel0) << 4) |
+                        SkGetPackedR4444(pixel1);
+                    dst[2] = (SkGetPackedG4444(pixel1) << 4) |
+                        SkGetPackedB4444(pixel1);
+
                     alphaDst++;
+                    dst += 3;
                 }
                 if (srcRect.width() & 1) {
-                    dst[0] = (SkGetPackedR4444(src[x]) << 4) |
-                        SkGetPackedG4444(src[x]);
-                    dst[1] = (SkGetPackedB4444(src[x]) << 4);
-                    dst += 2;
-                    alphaDst[0] = (SkGetPackedA4444(src[x]) << 4);
+                    uint16_t pixel = src[x];
+
+                    alphaDst[0] = (SkGetPackedA4444(pixel) << 4);
                     if (alphaDst[0] != 0xF0) {
                         hasAlpha = true;
+                        pixel = unpremultiply_argb4444(pixel);
                     }
                     if (alphaDst[0] & 0xF0) {
                         isTransparent = false;
                     }
+
+                    dst[0] = (SkGetPackedR4444(pixel) << 4) |
+                        SkGetPackedG4444(pixel);
+                    dst[1] = (SkGetPackedB4444(pixel) << 4);
+
                     alphaDst++;
+                    dst += 2;
                 }
             }
             break;
         }
         case SkBitmap::kRGB_565_Config: {
             const int rowBytes = srcRect.width() * 3;
             image = new SkMemoryStream(rowBytes * srcRect.height());
             uint8_t* dst = (uint8_t*)image->getMemoryBase();
             for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
                 uint16_t* src = bitmap.getAddr16(0, y);
                 for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
                     dst[0] = SkGetPackedR16(src[x]);
                     dst[1] = SkGetPackedG16(src[x]);
                     dst[2] = SkGetPackedB16(src[x]);
                     dst += 3;
                 }
             }
             break;
         }
         case SkBitmap::kARGB_8888_Config: {
             isTransparent = true;
             const int rowBytes = srcRect.width() * 3;
             image = new SkMemoryStream(rowBytes * srcRect.height());
             alpha = new SkMemoryStream(srcRect.width() * srcRect.height());
             uint8_t* dst = (uint8_t*)image->getMemoryBase();
             uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase();
             for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
                 uint32_t* src = bitmap.getAddr32(0, y);
                 for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
-                    dst[0] = SkGetPackedR32(src[x]);
-                    dst[1] = SkGetPackedG32(src[x]);
-                    dst[2] = SkGetPackedB32(src[x]);
-                    dst += 3;
-                    alphaDst[0] = SkGetPackedA32(src[x]);
-                    if (alphaDst[0] != 0xFF) {
+                    uint32_t pixel = src[x];
+                    alphaDst[0] = SkGetPackedA32(pixel);
+                    if (alphaDst[0] != SK_AlphaOPAQUE) {
                         hasAlpha = true;
+                        pixel = unpremultiply_argb8888(pixel);
                     }
-                    if (alphaDst[0]) {
+                    if (alphaDst[0] != SK_AlphaTRANSPARENT) {
                         isTransparent = false;
                     }
+
+                    dst[0] = SkGetPackedR32(pixel);
+                    dst[1] = SkGetPackedG32(pixel);
+                    dst[2] = SkGetPackedB32(pixel);
+
                     alphaDst++;
+                    dst += 3;
                 }
             }
             break;
         }
         case SkBitmap::kA1_Config: {
             isTransparent = true;
             image = new SkMemoryStream(1);
             ((uint8_t*)image->getMemoryBase())[0] = 0;
 
             const int alphaRowBytes = (srcRect.width() + 7) / 8;
@@ skipping 197 matching lines @@
         decodeValue->reserve(6);
         decodeValue->append(zeroVal.get());
         decodeValue->append(scale5Val.get());
         decodeValue->append(zeroVal.get());
         decodeValue->append(scale6Val.get());
         decodeValue->append(zeroVal.get());
         decodeValue->append(scale5Val.get());
         insert("Decode", decodeValue.get());
     }
 }