[Blimp Engine] BlimpImageSerializationProcessor handles kOpaque_SkAlphaType and kUnpremul_SkAlphaTy…

blimp/common/compositor/blimp_image_serialization_processor.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "blimp/common/compositor/blimp_image_serialization_processor.h"
 
 #include <stddef.h>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 32 matching lines @@
 
     // Ensure width and height are valid dimensions.
     if (!pixmap.width() || pixmap.width() > WEBP_MAX_DIMENSION)
       return nullptr;
     picture.width = pixmap.width();
     if (!pixmap.height() || pixmap.height() > WEBP_MAX_DIMENSION)
       return nullptr;
     picture.height = pixmap.height();
 
     // Import picture from raw pixels.
-    DCHECK(pixmap.alphaType() == kPremul_SkAlphaType);
     auto pixel_chars = static_cast<const unsigned char*>(pixmap.addr());
-    if (!PlatformPictureImport(pixel_chars, &picture))
+    if (!PlatformPictureImport(pixel_chars, &picture, pixmap.alphaType()))
       return nullptr;
 
     // Create a buffer for where to store the output data.
     std::vector<unsigned char> data;
     picture.custom_ptr = &data;
 
     // Use our own WebPWriterFunction implementation.
     picture.writer = &WebPImageEncoder::WriteOutput;
 
     // Setup the configuration for the output WebP picture. This is currently
     // the same as the default configuration for WebP, but since any change in
     // the WebP defaults would invalidate all caches they are hard coded.
+    config.lossless = 0;
     config.quality = 75.0;  // between 0 (smallest file) and 100 (biggest).
     config.method = 4;  // quality/speed trade-off (0=fast, 6=slower-better).
 
     // Encode the picture using the given configuration.
     bool success = WebPEncode(&config, &picture);
 
     // Release the memory allocated by WebPPictureImport*(). This does not free
     // the memory used by the picture object itself.
     WebPPictureFree(&picture);
 
@@ skipping 36 matching lines @@
         SkUnPreMultiply::Scale scale = table[alpha];
         *out_pixels++ = SkUnPreMultiply::ApplyScale(scale, in_pixels[0]);
         *out_pixels++ = SkUnPreMultiply::ApplyScale(scale, in_pixels[1]);
         *out_pixels++ = SkUnPreMultiply::ApplyScale(scale, in_pixels[2]);
         *out_pixels++ = alpha;
       }
     }
   }
 
   bool PlatformPictureImport(const unsigned char* pixels,
-                             WebPPicture* picture) {
-    // Need to unpremultiply each pixel, each pixel using 4 bytes (RGBA).
-    size_t pixel_count = picture->height * picture->width;
-    std::vector<unsigned char> unpremul_pixels(pixel_count * 4);
-    UnPremultiply(pixels, unpremul_pixels.data(), pixel_count);
-
+                             WebPPicture* picture,
+                             SkAlphaType alphaType) {
     // Each pixel uses 4 bytes (RGBA) which affects the stride per row.
     int row_stride = picture->width * 4;
+    if (alphaType == kPremul_SkAlphaType) {
+      // Need to unpremultiply each pixel, each pixel using 4 bytes (RGBA).
+      size_t pixel_count = picture->height * picture->width;
+      std::vector<unsigned char> unpremul_pixels(pixel_count * 4);
+      UnPremultiply(pixels, unpremul_pixels.data(), pixel_count);
+      if (SK_B32_SHIFT)  // Android
+        return WebPPictureImportRGBA(picture, unpremul_pixels.data(),
+                                     row_stride);
+      return WebPPictureImportBGRA(picture, unpremul_pixels.data(), row_stride);
+    }
 
     if (SK_B32_SHIFT)  // Android
-      return WebPPictureImportRGBA(picture, unpremul_pixels.data(), row_stride);
-    return WebPPictureImportBGRA(picture, unpremul_pixels.data(), row_stride);
+      return WebPPictureImportRGBA(picture, pixels, row_stride);
+    return WebPPictureImportBGRA(picture, pixels, row_stride);
   }
 };
 
 }  // namespace
 
 namespace blimp {
 
 BlimpImageSerializationProcessor::BlimpImageSerializationProcessor(Mode mode) {
   switch (mode) {
     case Mode::SERIALIZATION:
@@ skipping 14 matching lines @@
 SkPixelSerializer* BlimpImageSerializationProcessor::GetPixelSerializer() {
   return pixel_serializer_.get();
 }
 
 SkPicture::InstallPixelRefProc
 BlimpImageSerializationProcessor::GetPixelDeserializer() {
   return pixel_deserializer_;
 }
 
 }  // namespace blimp