Support lossy and lossless <canvas>.toDataURL for webp

Source/platform/image-encoders/skia/WEBPImageEncoder.cpp

 /*
  * Copyright (c) 2011, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 typedef int (*WebPImporter)(WebPPicture* const, const uint8_t* const data, int rowStride);
 
 namespace blink {
 
 static int writeOutput(const uint8_t* data, size_t size, const WebPPicture* const picture)
 {
     static_cast<Vector<unsigned char>*>(picture->custom_ptr)->append(data, size);
     return 1;
 }
 
-static bool rgbPictureImport(const unsigned char* pixels, bool premultiplied, WebPImporter importRGBX, WebPImporter importRGB, WebPPicture* picture)
+static bool rgbaPictureImport(const unsigned char* pixels, bool premultiplied, WebPImporter importRGBA, WebPPicture* picture)
 {
-    if (premultiplied)
-        return importRGBX(picture, pixels, picture->width * 4);
+    if (!premultiplied)
+        return importRGBA(picture, pixels, picture->width * 4);
 
-    // Write the RGB pixels to an rgb data buffer, alpha premultiplied, then import the rgb data.
+    static const SkUnPreMultiply::Scale* scale = SkUnPreMultiply::GetScaleTable();
 
     size_t pixelCount = picture->height * picture->width;
-
-    OwnPtr<unsigned char[]> rgb = adoptArrayPtr(new unsigned char[pixelCount * 3]);
-    if (!rgb.get())
+    OwnPtr<unsigned char[]> rgba = adoptArrayPtr(new unsigned char[pixelCount * 4]);
+    if (!rgba.get())
         return false;
 
-    for (unsigned char* data = rgb.get(); pixelCount-- > 0; pixels += 4) {
+    for (unsigned char* data = rgba.get(); pixelCount-- > 0; pixels += 4) {
         unsigned char alpha = pixels[3];
-        if (alpha != 255) {
-            *data++ = SkMulDiv255Round(pixels[0], alpha);
-            *data++ = SkMulDiv255Round(pixels[1], alpha);
-            *data++ = SkMulDiv255Round(pixels[2], alpha);
+        if ((alpha != 0) && (alpha != 255)) {
+            *data++ = SkUnPreMultiply::ApplyScale(scale[alpha], pixels[0]);
+            *data++ = SkUnPreMultiply::ApplyScale(scale[alpha], pixels[1]);
+            *data++ = SkUnPreMultiply::ApplyScale(scale[alpha], pixels[2]);
+            *data++ = alpha;
         } else {
             *data++ = pixels[0];
             *data++ = pixels[1];
             *data++ = pixels[2];
+            *data++ = alpha;
         }
     }
 
-    return importRGB(picture, rgb.get(), picture->width * 3);
+    return importRGBA(picture, rgba.get(), picture->width * 4);
 }
 
-template <bool Premultiplied> inline bool importPictureBGRX(const unsigned char* pixels, WebPPicture* picture)
+template <bool Premultiplied> inline bool importPictureBGRA(const unsigned char* pixels, WebPPicture* picture)
 {
-    return rgbPictureImport(pixels, Premultiplied, &WebPPictureImportBGRX, &WebPPictureImportBGR, picture);
+    return rgbaPictureImport(pixels, Premultiplied, &WebPPictureImportBGRA, picture);
 }
 
-template <bool Premultiplied> inline bool importPictureRGBX(const unsigned char* pixels, WebPPicture* picture)
+template <bool Premultiplied> inline bool importPictureRGBA(const unsigned char* pixels, WebPPicture* picture)
 {
-    return rgbPictureImport(pixels, Premultiplied, &WebPPictureImportRGBX, &WebPPictureImportRGB, picture);
+    return rgbaPictureImport(pixels, Premultiplied, &WebPPictureImportRGBA, picture);
 }
 
 static bool platformPremultipliedImportPicture(const unsigned char* pixels, WebPPicture* picture)
 {
     if (SK_B32_SHIFT) // Android
-        return importPictureRGBX<true>(pixels, picture);
+        return importPictureRGBA<true>(pixels, picture);
 
-    return importPictureBGRX<true>(pixels, picture);
+    return importPictureBGRA<true>(pixels, picture);
 }
 
-static bool encodePixels(IntSize imageSize, const unsigned char* pixels, bool premultiplied, int quality, Vector<unsigned char>* output)
+static bool encodePixels(IntSize imageSize, const unsigned char* pixels, bool premultiplied, int quality, Vector<unsigned char>* output, WEBPImageEncoder::Mode mode)
 {
     if (imageSize.width() <= 0 || imageSize.width() > WEBP_MAX_DIMENSION)
         return false;
     if (imageSize.height() <= 0 || imageSize.height() > WEBP_MAX_DIMENSION)
         return false;
 
     WebPConfig config;
     if (!WebPConfigInit(&config))
         return false;
     WebPPicture picture;
     if (!WebPPictureInit(&picture))
         return false;
 
     picture.width = imageSize.width();
     picture.height = imageSize.height();
+    if (quality > 99 || mode == WEBPImageEncoder::Lossless)
+        picture.use_argb = 1;
 

[acterhd, 2015/08/27 17:18:19]

I'm used backward compatibility with lossy without alpha channel. 

     if (premultiplied && !platformPremultipliedImportPicture(pixels, &picture))
         return false;
-    if (!premultiplied && !importPictureRGBX<false>(pixels, &picture))
+    if (!premultiplied && !importPictureRGBA<false>(pixels, &picture))
         return false;
 
     picture.custom_ptr = output;
     picture.writer = &writeOutput;
-    config.quality = quality;
-    config.method = 3;
+
+    if (mode == WEBPImageEncoder::Lossless) {
+        // libeweb > 0x0202 has a lossless preset http://bit.ly/1Pz9IkE
+        // api, but it is not in chrome yet. Approximate it.
+        ASSERT(quality >= 0 && quality <= 100);
+        config.quality = quality;
+        config.method = (quality * 6) / 100;

[urvang, 2015/08/27 17:18:23]

Large method values are pretty impractical: e.g. q=100 & m=6 is simply
impractical for canvas.toDataURL use case.
I would keep method from 0 to 3. 
And FYI: quality=100 & m=3 is still pretty good compression wise.
(even q=10, m = 0 in fact gives decent compression).

+        config.lossless = 1;
+    } else if (quality > 99) {

[acterhd, 2015/08/27 17:18:19]

Bad idea, particularly for video (WebM) encoders with quality = 100. 

+        // Use a middle-of-the-road quality, lossless webp encoding
+        //  -- to balance speed with compresssion time
+        //  -- to maintain sharpness (for text, see JPEG 4:4:4).
+        // FIXME: should we use WebPPictureSmartARGBToYUVA() instead
+        // for this case?  Maybe compare it with the approach here in
+        // terms of encoding speed and quality.

[Noel Gordon, 2015/08/26 23:13:49]

_and_ filesize.

+        config.quality = 75;

[Noel Gordon, 2015/08/26 23:52:03]

FIXME: use WEBPImageEncoder::DefaultCompressionQuality here?

+        config.method = 4;
+        config.lossless = 1;

[urvang, 2015/08/27 17:18:23]

We have a separate setting for lossless, so quality > 99 should NOT mean
lossless.
We should use losssy with WebPPictureSmartARGBToYUVA() instead, which would be
reasonably sharp and yet smaller in size and a bit faster than lossless.
In fact, Pascal suggested using it for all high qualities for lossy (q>=90 say)

+    } else {
+        config.quality = quality;
+        config.method = 3;
+        config.lossless = 0;
+    }
 
     bool success = WebPEncode(&config, &picture);
     WebPPictureFree(&picture);
     return success;
 }
 
-bool WEBPImageEncoder::encode(const SkBitmap& bitmap, int quality, Vector<unsigned char>* output)
+bool WEBPImageEncoder::encode(const SkBitmap& bitmap, int quality, Vector<unsigned char>* output, WEBPImageEncoder::Mode mode)

[Noel Gordon, 2015/08/26 23:43:14]

FIXME: since SkBitmap is being removed from chrome, we should remove this
encode() variant.  That means only the ImageDataBuffer encode variant is
required, and they ImageDataBuffer always contains unpremultiplied RGBA data. 
That fact could be used to greatly simplify this encoder, and the other encoders
(PNG, JPEG).

[Noel Gordon, 2015/08/27 12:43:00]

https://code.google.com/p/chromium/issues/detail?id=449197

[urvang, 2015/08/27 17:18:23]

Nice! That explains why I never hit this encoder in tests.
Let's remove this encode() variant first then!

 {
     SkAutoLockPixels bitmapLock(bitmap);
 
     if (bitmap.colorType() != kN32_SkColorType || !bitmap.getPixels())
         return false; // Only support 32 bit/pixel skia bitmaps.
 
-    return encodePixels(IntSize(bitmap.width(), bitmap.height()), static_cast<unsigned char *>(bitmap.getPixels()), true, quality, output);
+    return encodePixels(IntSize(bitmap.width(), bitmap.height()), static_cast<unsigned char *>(bitmap.getPixels()), true, quality, output, mode);
 }
 
-bool WEBPImageEncoder::encode(const ImageDataBuffer& imageData, int quality, Vector<unsigned char>* output)
+bool WEBPImageEncoder::encode(const ImageDataBuffer& imageData, int quality, Vector<unsigned char>* output, WEBPImageEncoder::Mode mode)
 {
     if (!imageData.pixels())
         return false;
 
-    return encodePixels(IntSize(imageData.width(), imageData.height()), imageData.pixels(), false, quality, output);
+    return encodePixels(IntSize(imageData.width(), imageData.height()), imageData.pixels(), false, quality, output, mode);
 }
 
 } // namespace blink