Unpremultiply SkBitmaps for PDF output

src/pdf/SkPDFImage.cpp

Index: src/pdf/SkPDFImage.cpp
diff --git a/src/pdf/SkPDFImage.cpp b/src/pdf/SkPDFImage.cpp
index a5cb4c20d1b9e187948cc6654d590b219df4d686..b24065ca3714ffdaa915744c572d400bbde6b568 100644
--- a/src/pdf/SkPDFImage.cpp
+++ b/src/pdf/SkPDFImage.cpp
@@ -18,6 +18,51 @@
 
 namespace {
 
+/**
+ * Unpremultiply an ARGB color, keeping the output in the same format
+ * as the input.
+ */
+static void pack_argb8888(uint32_t src, uint8_t* dst) {
+    dst[0] = SkGetPackedR32(src);
+    dst[1] = SkGetPackedG32(src);
+    dst[2] = SkGetPackedB32(src);
+}
+
+static void pack_argb4444(uint16_t src0, uint16_t src1, uint8_t* dst) {
+    dst[0] = (SkGetPackedR4444(src0) << 4) |
+        SkGetPackedG4444(src0);
+    dst[1] = (SkGetPackedB4444(src0) << 4) |
+        SkGetPackedR4444(src1);
+    dst[2] = (SkGetPackedG4444(src1) << 4) |
+        SkGetPackedB4444(src1);
+}
+
+static void unpremultiply_and_pack_argb8888(uint8_t alpha, uint32_t src,
+                                            uint8_t* dst) {
+    SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(alpha);
+
+    dst[0] = SkUnPreMultiply::ApplyScale(scale, SkGetPackedR32(src));
+    dst[1] = SkUnPreMultiply::ApplyScale(scale, SkGetPackedG32(src));
+    dst[2] = SkUnPreMultiply::ApplyScale(scale, SkGetPackedB32(src));
+}
+
+static void unpremultiply_and_pack_argb4444(uint8_t alpha0, uint8_t alpha1,
+                                            uint16_t src0, uint16_t src1,
+                                            uint8_t* dst) {
+    // Convert alpha from 4 bit to 8 bit, consistent with SkPixel4444ToPixel32
+    alpha0 = alpha0 | (alpha0 << 4);
+    alpha1 = alpha1 | (alpha1 << 4);
+    SkUnPreMultiply::Scale scale0 = SkUnPreMultiply::GetScale(alpha0);
+    SkUnPreMultiply::Scale scale1 = SkUnPreMultiply::GetScale(alpha1);
+
+    dst[0] = (SkUnPreMultiply::ApplyScale(scale0, SkGetPackedR4444(src0)) << 4);
+    dst[0] |= SkUnPreMultiply::ApplyScale(scale0, SkGetPackedG4444(src0));
+    dst[1] = (SkUnPreMultiply::ApplyScale(scale0, SkGetPackedB4444(src0)) << 4);
+    dst[1] |= SkUnPreMultiply::ApplyScale(scale1, SkGetPackedR4444(src1));
+    dst[2] = (SkUnPreMultiply::ApplyScale(scale1, SkGetPackedG4444(src1)) << 4);
+    dst[2] |= SkUnPreMultiply::ApplyScale(scale1, SkGetPackedB4444(src1));
+}
+
 void extractImageData(const SkBitmap& bitmap, const SkIRect& srcRect,
                       SkStream** imageData, SkStream** alphaData) {
     SkMemoryStream* image = NULL;
@@ -49,36 +94,50 @@ void extractImageData(const SkBitmap& bitmap, const SkIRect& srcRect,
                 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]);
+                    uint16_t pixel0 = src[x];

[vandebo (ex-Chrome), 2013/08/12 15:56:05]

I was imagining the following code - push the conditional down into the
function.

alphaDst[0] = (SkGetPackedA4444(src[x]) << 4) ||
               SkGetPackedA4444(src[x + 1]);	
if (alphaDst[0] != 0xFF) {
    hasAlpha = true;
}
unpremultiply_and_pack_argb4444(alphaDst[0], src[x], src[x + 1], dst);

[ducky, 2013/08/12 20:51:58]

Done.

+                    uint16_t pixel1 = src[x + 1];
+                    uint8_t alpha0 = SkGetPackedA4444(pixel0);
+                    uint8_t alpha1 = SkGetPackedA4444(pixel1);
+                    alphaDst[0] = (alpha0 << 4) | alpha1;
                     if (alphaDst[0] != 0xFF) {

[vandebo (ex-Chrome), 2013/08/12 15:56:05]

SK_AlphaOPAQUE

[ducky, 2013/08/12 20:51:58]

Done.

                         hasAlpha = true;
+                        unpremultiply_and_pack_argb4444(alpha0, alpha1,
+                                                        pixel0, pixel1,
+                                                        dst);
+                    } else {
+                        pack_argb4444(pixel0, pixel1, dst);
                     }
                     if (alphaDst[0]) {
                         isTransparent = false;
                     }
+
                     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];
+                    uint8_t alpha = SkGetPackedA4444(pixel);
+                    alphaDst[0] = (alpha << 4);
+                    // Use a buffer to translate from the usual 2 4444 values
+                    // in 12 bytes to the single 4444 value in 2 bytes.
+                    uint8_t buffer[3];
                     if (alphaDst[0] != 0xF0) {
                         hasAlpha = true;
+                        unpremultiply_and_pack_argb4444(alpha, 0x00,
+                                                        pixel, 0x00,
+                                                        buffer);
+                    } else {
+                        pack_argb4444(pixel, 0x00, buffer);
                     }
                     if (alphaDst[0] & 0xF0) {
                         isTransparent = false;
                     }
+
+                    dst[0] = buffer[0];
+                    dst[1] = buffer[1];
+
                     alphaDst++;
+                    dst += 2;
                 }
             }
             break;
@@ -108,18 +167,22 @@ void extractImageData(const SkBitmap& bitmap, const SkIRect& srcRect,
             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;
+                        unpremultiply_and_pack_argb8888(alphaDst[0],
+                                                        pixel,
+                                                        dst);
+                    } else {
+                        pack_argb8888(pixel, dst);
                     }
-                    if (alphaDst[0]) {
+                    if (alphaDst[0] != SK_AlphaTRANSPARENT) {
                         isTransparent = false;
                     }
+
                     alphaDst++;
+                    dst += 3;
                 }
             }
             break;