[poc] curve-filter

third_party/WebKit/Source/platform/graphics/BitmapImage.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/graphics/BitmapImage.h"
 
 #include "platform/PlatformInstrumentation.h"
 #include "platform/Timer.h"
 #include "platform/TraceEvent.h"
 #include "platform/geometry/FloatRect.h"
+#include "platform/graphics/ColorSpaceFilter.h"
+#include "platform/graphics/ColorSpaceProfile.h"
 #include "platform/graphics/DeferredImageDecoder.h"
+#include "platform/graphics/GraphicsScreen.h"
+#include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
 #include "wtf/PassRefPtr.h"
+#include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 PassRefPtr<BitmapImage> BitmapImage::createWithOrientationForTesting(const SkBitmap& bitmap, ImageOrientation orientation)
 {
     if (bitmap.isNull()) {
         return BitmapImage::create();
     }
 
@@ skipping 12 matching lines @@
     , m_repetitionsComplete(0)
     , m_desiredFrameStartTime(0)
     , m_frameCount(0)
     , m_animationPolicy(ImageAnimationPolicyAllowed)
     , m_animationFinished(false)
     , m_allDataReceived(false)
     , m_haveSize(false)
     , m_sizeAvailable(false)
     , m_hasUniformFrameSize(true)
     , m_haveFrameCount(false)
+    , m_drawingToCanvasElement(false)
 {
 }
 
 BitmapImage::BitmapImage(const SkBitmap& bitmap, ImageObserver* observer)
     : Image(observer)
     , m_size(bitmap.width(), bitmap.height())
     , m_currentFrame(0)
     , m_repetitionCount(cAnimationNone)
     , m_repetitionCountStatus(Unknown)
     , m_repetitionsComplete(0)
     , m_frameCount(1)
     , m_animationPolicy(ImageAnimationPolicyAllowed)
     , m_animationFinished(true)
     , m_allDataReceived(true)
     , m_haveSize(true)
     , m_sizeAvailable(true)
     , m_haveFrameCount(true)
+    , m_drawingToCanvasElement(false)
 {
     // Since we don't have a decoder, we can't figure out the image orientation.
     // Set m_sizeRespectingOrientation to be the same as m_size so it's not 0x0.
     m_sizeRespectingOrientation = m_size;
 
     m_frames.grow(1);
     m_frames[0].m_hasAlpha = !bitmap.isOpaque();
     m_frames[0].m_frame = adoptRef(SkImage::NewFromBitmap(bitmap));
     m_frames[0].m_haveMetadata = true;
 }
@@ skipping 195 matching lines @@
 
         canvas->concat(affineTransformToSkMatrix(orientation.transformFromDefault(adjustedDstRect.size())));
 
         if (orientation.usesWidthAsHeight()) {
             // The destination rect will have it's width and height already reversed for the orientation of
             // the image, as it was needed for page layout, so we need to reverse it back here.
             adjustedDstRect = FloatRect(adjustedDstRect.x(), adjustedDstRect.y(), adjustedDstRect.height(), adjustedDstRect.width());
         }
     }
 
+    if (RefPtr<ColorSpaceProfile> source = colorProfile()) {
+        // Tagged images (those that have a color profile) are drawn color-correct on supported platforms.
+        RefPtr<ColorSpaceProfile> screen = screenColorProfile(currentScreenId());
+        if (RefPtr<SkColorFilter> colorTransform = createColorSpaceFilter(source.get(), screen.get())) {
+            fprintf(stderr, "BitmapImage::draw color transform [%s]\n", colorSpaceFilterKey(colorTransform.get()).latin1().data());
+            if (currentScreenId()) {
+                if (drawingToCanvasElement()) // FIXME: debug for the <canvas> case.
+                    exit(0);
+                const_cast<SkPaint*>(&paint)->setColorFilter(colorTransform.get());
+            } else {
+                if (!drawingToCanvasElement()) // FIXME: Only <canvas> draws outside normal paint flows.
+                    exit(0);
+                // FIXME: normal bitmap drawing paths apply the transform filter, but the canvas drawing
+                // path does not. Paint with the color transform, into a local Imagebuffer, then extract
+                // the result as a SkImage, which will be used to do the final drawImageRect() pass.
+                SkPaint transformPaint;
+                transformPaint.setColorFilter(colorTransform.get());
+                OwnPtr<ImageBuffer> buffer = ImageBuffer::create(size(), currentFrameKnownToBeOpaque() ? Opaque : NonOpaque);
+                FloatRect source = IntRect(IntPoint(), size());
+                SkCanvas::SrcRectConstraint skSrcRectClamp = WebCoreClampingModeToSkiaRectConstraint(Image::ClampImageToSourceRect);
+                buffer->canvas()->drawImageRect(image.get(), source, source, &transformPaint, skSrcRectClamp);
+                image = buffer->newSkImageSnapshot(PreferNoAcceleration);
+            }
+            fflush(stderr);
+        }
+    } else {
+        // For sRGB assumed images: easy, just interpolate the sRGB color profile here as the src profile?
+        // FIXME: untagged images should be drawn from sRGB color space, per CSS2.1 onwards, a change that
+        // would also require that all CSS content, including <canvas>, be drawn from sRGB space to match,
+        // and the same for plugins (Flash, NaCl) which don't define their color space at all, <video> and
+        // OOPIF, and so on ...
+    }
+
     SkRect skSrcRect = adjustedSrcRect;
-    canvas->drawImageRect(image.get(), skSrcRect, adjustedDstRect, &paint,
-        WebCoreClampingModeToSkiaRectConstraint(clampMode));
+    canvas->drawImageRect(image.get(), skSrcRect, adjustedDstRect, &paint, WebCoreClampingModeToSkiaRectConstraint(clampMode));
     canvas->restoreToCount(initialSaveCount);
 
     if (currentFrameIsLazyDecoded())
         PlatformInstrumentation::didDrawLazyPixelRef(image->uniqueID());
 
     if (ImageObserver* observer = imageObserver())
         observer->didDraw(this);
 
     startAnimation();
 }
@@ skipping 347 matching lines @@
     destroyDecodedDataIfNecessary();
 
     // We need to draw this frame if we advanced to it while not skipping, or if
     // while trying to skip frames we hit the last frame and thus had to stop.
     if (skippingFrames != advancedAnimation)
         imageObserver()->animationAdvanced(this);
     return advancedAnimation;
 }
 
 } // namespace blink