Color correct ImageBitmap(HTMLImageElement*) constructor

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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 "core/frame/ImageBitmap.h"
 
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
@@ skipping 214 matching lines @@
   SkImageInfo info = SkImageInfo::Make(input->width(), input->height(),
                                        kN32_SkColorType, kPremul_SkAlphaType);
   RefPtr<Uint8Array> dstPixels = copySkImageData(input, info);
   if (!dstPixels)
     return nullptr;
   return newSkImageFromRaster(
       info, std::move(dstPixels),
       static_cast<unsigned>(input->width()) * info.bytesPerPixel());
 }
 
+static sk_sp<SkImage> applyColorSpaceConversion(
+    sk_sp<SkImage> image,
+    bool premultiplyAlpha,
+    const ImageBitmapOptions* options) {
+  // Valid values for colorSpaceConversion are "default", "srgb" and
+  // "linear-rgb" here.
+  if (options->colorSpaceConversion() != "default" &&
+      options->colorSpaceConversion() != "srgb" &&
+      options->colorSpaceConversion() != "linear-rgb") {
+    NOTREACHED()
+        << "Invalid ImageBitmap creation attribute colorSpaceConversion: "
+        << options->colorSpaceConversion();
+    return image;

[xidachen, 2016/11/22 20:34:37]

This part should be moved to the function parseOptions().

+  }
+
+  bool colorCorrectRendering =
+      RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
+      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
+
+  // If color correct rendering is not set, only "default" is accepted here.
+  if (options->colorSpaceConversion() != "default" && !colorCorrectRendering) {
+    NOTREACHED()
+        << "Invalid ImageBitmap creation attribute colorSpaceConversion: "
+        << options->colorSpaceConversion();
+    return image;

[xidachen, 2016/11/22 20:34:37]

This part should be moved to parseOptions() as well.

[zakerinasab, 2016/11/24 18:18:32]

Done.

+  }
+
+  SkImageInfo imageInfo;
+  // If color space conversion is default and color correct rendering is
+  // not set, color correct the image to match display profile.
+  // For now we assume 8 bit per channel for display. This must be fixed
+  // to properly support color space conversion on HDR displays when
+  // they are supported in SkColorType.
+  if (options->colorSpaceConversion() == "default" && !colorCorrectRendering) {
+    imageInfo = SkImageInfo::Make(image->width(), image->height(),
+                                  SkColorType::kN32_SkColorType,
+                                  SkAlphaType::kPremul_SkAlphaType,
+                                  ImageDecoder::globalTargetColorSpace());
+
+    // If color space conversion is default and color correct rendering is
+    // set, color correct the image to sRGB.
+  } else if (options->colorSpaceConversion() == "default" ||
+             options->colorSpaceConversion() == "srgb") {
+    imageInfo = SkImageInfo::MakeS32(image->width(), image->height(),
+                                     SkAlphaType::kPremul_SkAlphaType);
+
+  } else if (options->colorSpaceConversion() == "linear-rgb") {
+    imageInfo = SkImageInfo::Make(
+        image->width(), image->height(), SkColorType::kRGBA_F16_SkColorType,
+        SkAlphaType::kPremul_SkAlphaType,
+        SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named));
+  }
+
+  sk_sp<SkSurface> surface = SkSurface::MakeRaster(imageInfo);
+  surface->getCanvas()->drawImage(image, 0, 0);
+  return surface->makeImageSnapshot();
+}
+
 sk_sp<SkImage> ImageBitmap::getSkImageFromDecoder(
     std::unique_ptr<ImageDecoder> decoder) {
   if (!decoder->frameCount())
     return nullptr;
   ImageFrame* frame = decoder->frameBufferAtIndex(0);
   if (!frame || frame->getStatus() != ImageFrame::FrameComplete)
     return nullptr;
   DCHECK(!frame->bitmap().isNull() && !frame->bitmap().empty());
   return frame->finalizePixelsAndGetImage();
 }
@@ skipping 25 matching lines @@
 // The parameter imageFormat indicates whether the first parameter "image" is
 // unpremultiplied or not.  imageFormat = PremultiplyAlpha means the image is in
 // premuliplied format For example, if the image is already in unpremultiplied
 // format and we want the created ImageBitmap in the same format, then we don't
 // need to use the ImageDecoder to decode the image.
 static PassRefPtr<StaticBitmapImage> cropImage(
     Image* image,
     const ParsedOptions& parsedOptions,
     AlphaDisposition imageFormat = PremultiplyAlpha,
     ImageDecoder::ColorSpaceOption colorSpaceOp =
-        ImageDecoder::ColorSpaceApplied) {
+        ImageDecoder::ColorSpaceApplied,
+    const ImageBitmapOptions* imageBitmapOptions = nullptr) {
   ASSERT(image);
   IntRect imgRect(IntPoint(), IntSize(image->width(), image->height()));
   const IntRect srcRect = intersection(imgRect, parsedOptions.cropRect);
 
   // In the case when cropRect doesn't intersect the source image and it
   // requires a umpremul image We immediately return a transparent black image
   // with cropRect.size()
   if (srcRect.isEmpty() && !parsedOptions.premultiplyAlpha) {
     SkImageInfo info =
         SkImageInfo::Make(parsedOptions.resizeWidth, parsedOptions.resizeHeight,
@@ skipping 24 matching lines @@
         colorSpaceOp));
     if (!decoder)
       return nullptr;
     skiaImage = ImageBitmap::getSkImageFromDecoder(std::move(decoder));
     if (!skiaImage)
       return nullptr;
   }
 
   if (parsedOptions.cropRect == srcRect && !parsedOptions.shouldScaleInput) {
     sk_sp<SkImage> croppedSkImage = skiaImage->makeSubset(srcRect);
+    if (colorSpaceOp == ImageDecoder::ColorSpaceApplied) {
+      croppedSkImage = applyColorSpaceConversion(
+          croppedSkImage, parsedOptions.premultiplyAlpha, imageBitmapOptions);

[xidachen, 2016/11/22 20:34:37]

Pass |parsedOptions| instead of the last two arguments.

[zakerinasab, 2016/11/24 18:18:32]

Done.

+    }
     if (parsedOptions.flipY)
       return StaticBitmapImage::create(flipSkImageVertically(
           croppedSkImage.get(), parsedOptions.premultiplyAlpha
                                     ? PremultiplyAlpha
                                     : DontPremultiplyAlpha));
     // Special case: The first parameter image is unpremul but we need to turn
     // it into premul.
     if (parsedOptions.premultiplyAlpha && imageFormat == DontPremultiplyAlpha)
       return StaticBitmapImage::create(
           unPremulSkImageToPremul(croppedSkImage.get()));
     // Call preroll to trigger image decoding.
     croppedSkImage->preroll();
     return StaticBitmapImage::create(std::move(croppedSkImage));
   }
 
+  // Currently ImageDecoder assumes at most 8 bits per channel for the decoded
+  // image. When this is fixed, we should change this code to create the
+  // surface according to the color depth of the decoded image.
   sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
       parsedOptions.resizeWidth, parsedOptions.resizeHeight);
   if (!surface)
     return nullptr;
   if (srcRect.isEmpty())
     return StaticBitmapImage::create(surface->makeImageSnapshot());
 
   SkScalar dstLeft = std::min(0, -parsedOptions.cropRect.x());
   SkScalar dstTop = std::min(0, -parsedOptions.cropRect.y());
   if (parsedOptions.cropRect.x() < 0)
@@ skipping 12 matching lines @@
                                           parsedOptions.resizeHeight);
     SkPaint paint;
     paint.setFilterQuality(parsedOptions.resizeQuality);
     surface->getCanvas()->drawImageRect(skiaImage, drawSrcRect, drawDstRect,
                                         &paint);
   } else {
     surface->getCanvas()->drawImage(skiaImage, dstLeft, dstTop);
   }
   skiaImage = surface->makeImageSnapshot();
 
+  if (colorSpaceOp == ImageDecoder::ColorSpaceApplied) {
+    skiaImage = applyColorSpaceConversion(
+        skiaImage, parsedOptions.premultiplyAlpha, imageBitmapOptions);

[xidachen, 2016/11/22 20:34:38]

Pass |parsedOptions| instead of the last two arguments.

[zakerinasab, 2016/11/24 18:18:32]

Done.

+  }
   if (parsedOptions.premultiplyAlpha) {
     if (imageFormat == DontPremultiplyAlpha)
       return StaticBitmapImage::create(
           unPremulSkImageToPremul(skiaImage.get()));
     return StaticBitmapImage::create(std::move(skiaImage));
   }
   return StaticBitmapImage::create(premulSkImageToUnPremul(skiaImage.get()));
 }
 
 ImageBitmap::ImageBitmap(HTMLImageElement* image,
                          Optional<IntRect> cropRect,
                          Document* document,
                          const ImageBitmapOptions& options) {
   RefPtr<Image> input = image->cachedImage()->getImage();
   ParsedOptions parsedOptions =
       parseOptions(options, cropRect, image->bitmapSourceSize());
   if (dstBufferSizeHasOverflow(parsedOptions))
     return;
 
   if (options.colorSpaceConversion() == "none") {
     m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
                         ImageDecoder::ColorSpaceIgnored);
   } else {
     m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha,
-                        ImageDecoder::ColorSpaceApplied);
+                        ImageDecoder::ColorSpaceApplied, &options);

[xidachen, 2016/11/22 20:34:37]

This is not the best way, and it is caused by my original implementation, sigh.

Please change the implementation to add a new item in the struct ParsedOptions,
maybe called "dstColorspace". It could be an enum, to represent the destination
color space.

Then in the function parseOptions(), you parse the input options, and assign the
right value to dstColorspace.

By doing the above, you don't need this additional |options| argument, you can
also get rid of the second last argument here which is the
|ImageDecoder::ColorSpaceApplied| because that should be determined by the
dstColorspace. Does that make sense?

[zakerinasab, 2016/11/24 18:18:32]

For now we need to keep ImageDecoder::ColorSpaceOption parameter as other parts
of the code expect the default value to be true. We will remove this after we
added the color conversion support to all the ImageBitmap constructors.

   }
   if (!m_image)
     return;
   // In the case where the source image is lazy-decoded, m_image may not be in
   // a decoded state, we trigger it here.
   sk_sp<SkImage> skImage = m_image->imageForCurrentFrame();
   SkPixmap pixmap;
   if (!skImage->isTextureBacked() && !skImage->peekPixels(&pixmap)) {
     sk_sp<SkSurface> surface =
         SkSurface::MakeRasterN32Premul(skImage->width(), skImage->height());
@@ skipping 455 matching lines @@
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect,
                                   FloatRect* dstRect) const {}
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink