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"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
+#include "ui/gfx/icc_profile.h"
+#include "ui/gfx/color_space.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
 
 static const char* imageOrientationFlipY = "flipY";
 static const char* imageBitmapOptionNone = "none";
 
@@ skipping 201 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 colorConversionSpace: "
+                 << options->colorSpaceConversion();
+    return image;
+  }
+
+  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 colorConversionSpace in\
+                     not-color-corrected mode: "
+                 << options->colorSpaceConversion();
+    return image;
+  }
+  
+  SkImageInfo imageInfo;
+  // If color space conversion is default and color correct rendering is
+  // not set, color correct the image to display color space.
+  // For now we assume 8 bit per channel for display. This must be fixed
+  // to properly support color space conversion on HDR displays.
+  if (options->colorSpaceConversion() == "default" &&
+      !colorCorrectRendering) {

[ccameron, 2016/11/21 22:11:36]

Ah -- as soon as https://codereview.chromium.org/2512683003/ lands

You'll be able to query this directly using
ImageDecoder::globalTargetColorSpace()

+    gfx::ICCProfile iccProfile = gfx::ICCProfile::FromBestMonitor();
+    gfx::ColorSpace gfxColorSpace = iccProfile.GetColorSpace();
+    sk_sp<SkColorSpace> colorSpace =
+        (gfxColorSpace != gfx::ColorSpace()) ?
+        gfxColorSpace.ToSkColorSpace() :
+        SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named); 
+    imageInfo = SkImageInfo::Make(
+        image->width(), image->height(), 
+        SkColorType::kN32_SkColorType,
+        SkAlphaType::kPremul_SkAlphaType,
+        colorSpace);
+
+  // 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,
                           kN32_SkColorType, kUnpremul_SkAlphaType);
     RefPtr<ArrayBuffer> dstBuffer = ArrayBuffer::createOrNull(
         static_cast<unsigned>(info.width()) * info.height(),
         info.bytesPerPixel());
     if (!dstBuffer)
       return nullptr;
     RefPtr<Uint8Array> dstPixels =
         Uint8Array::create(dstBuffer, 0, dstBuffer->byteLength());
-    return StaticBitmapImage::create(newSkImageFromRaster(
-        info, std::move(dstPixels),
-        static_cast<unsigned>(info.width()) * info.bytesPerPixel()));
+    sk_sp<SkImage> croppedImage = newSkImageFromRaster(
+         info, std::move(dstPixels),
+        static_cast<size_t>(info.width()) * info.bytesPerPixel());
+    return StaticBitmapImage::create(croppedImage);
   }
 
   sk_sp<SkImage> skiaImage = image->imageForCurrentFrame();
   // Attempt to get raw unpremultiplied image data, executed only when skiaImage
   // is premultiplied.
   if ((((!parsedOptions.premultiplyAlpha && !skiaImage->isOpaque()) ||
         !skiaImage) &&
        image->data() && imageFormat == PremultiplyAlpha) ||
       colorSpaceOp == ImageDecoder::ColorSpaceIgnored) {
     std::unique_ptr<ImageDecoder> decoder(ImageDecoder::create(
         image->data(), true,
         parsedOptions.premultiplyAlpha ? ImageDecoder::AlphaPremultiplied
                                        : ImageDecoder::AlphaNotPremultiplied,
         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);
     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);
+
   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);
   }
   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