Implement ImageData::CropRect()

third_party/WebKit/Source/core/html/ImageData.cpp

 /*
  * Copyright (C) 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 347 matching lines @@
 
 // This function is called from unit tests, and all the parameters are supposed
 // to be validated on the call site.
 ImageData* ImageData::CreateForTest(
     const IntSize& size,
     DOMArrayBufferView* buffer_view,
     const ImageDataColorSettings* color_settings) {
   return new ImageData(size, buffer_view, color_settings);
 }
 
+// Crops ImageData to the intersect of its size and the given rectangle. If the
+// intersection is empty or it cannot create the cropped ImageData it returns
+// nullptr. This function leaves the source ImageData intact. When crop_rect
+// covers all the ImageData, a copy of the ImageData is returned.
+ImageData* ImageData::CropRect(const IntRect& crop_rect, bool flip_y) {
+  IntRect src_rect(IntPoint(), size_);
+  const IntRect dst_rect = Intersection(src_rect, crop_rect);
+  if (dst_rect.IsEmpty())
+    return nullptr;
+
+  unsigned data_size = 4 * dst_rect.Width() * dst_rect.Height();
+  DOMArrayBufferView* buffer_view = AllocateAndValidateDataArray(
+      data_size,
+      ImageData::GetImageDataStorageFormat(color_settings_.storageFormat()));
+  if (!buffer_view)
+    return nullptr;
+
+  if (src_rect == dst_rect && !flip_y) {
+    std::memcpy(buffer_view->BufferBase()->Data(), BufferBase()->Data(),
+                data_size * buffer_view->TypeSize());
+  } else {
+    int src_index = 0, dst_index = 0;
+    unsigned data_type_size =
+        ImageData::StorageFormatDataSize(color_settings_.storageFormat());
+    for (int i = 0; i < dst_rect.Height(); i++) {
+      src_index = ((i + dst_rect.X()) * src_rect.Width() + dst_rect.Y()) * 4;
+      dst_index = flip_y ? (dst_rect.Height() - i - 1) * dst_rect.Width() * 4

[Justin Novosad, 2017/05/30 19:45:22]

You can avoid having this conditional branch and arithmetic inside the loop by
computing a "row stride" before the loop and here you would just have dst_index
+= dst_row_stride;  it also save a bunch of arithmetic.

[zakerinasab, 2017/05/30 20:06:16]

Done.

+                         : i * dst_rect.Width() * 4;
+      std::memcpy(
+          static_cast<char*>(buffer_view->BufferBase()->Data()) +
+              dst_index * data_type_size,
+          static_cast<char*>(BufferBase()->Data()) + src_index * data_type_size,
+          dst_rect.Width() * 4 * data_type_size);
+    }
+  }
+  return new ImageData(dst_rect.Size(), buffer_view, &color_settings_);
+}
+
 ScriptPromise ImageData::CreateImageBitmap(ScriptState* script_state,
                                            EventTarget& event_target,
                                            Optional<IntRect> crop_rect,
                                            const ImageBitmapOptions& options,
                                            ExceptionState& exception_state) {
   if ((crop_rect &&
        !ImageBitmap::IsSourceSizeValid(crop_rect->Width(), crop_rect->Height(),
                                        exception_state)) ||
       !ImageBitmap::IsSourceSizeValid(BitmapSourceSize().Width(),
                                       BitmapSourceSize().Height(),
@@ skipping 215 matching lines @@
 
 // For ImageData, the color space is only specified by color settings.
 // It cannot have a SkColorSpace. This doesn't mean anything. Fix this.
 sk_sp<SkColorSpace> ImageData::GetSkColorSpace() {
   if (!RuntimeEnabledFeatures::colorCanvasExtensionsEnabled())
     return nullptr;
 
   return SkColorSpace::MakeSRGB();
 }
 
-// This function returns the proper SkColorSpace to color correct the pixels
-// stored in ImageData before copying to the canvas. For now, it assumes that
-// both ImageData and canvas use a linear gamma curve.
-sk_sp<SkColorSpace> ImageData::GetSkColorSpace(
-    const CanvasColorSpace& color_space,
-    const CanvasPixelFormat& pixel_format) {
-  switch (color_space) {
-    case kLegacyCanvasColorSpace:
-      return (gfx::ColorSpace::CreateSRGB()).ToSkColorSpace();
-    case kSRGBCanvasColorSpace:
-      if (pixel_format == kF16CanvasPixelFormat)
-        return (gfx::ColorSpace::CreateSCRGBLinear()).ToSkColorSpace();
-      return (gfx::ColorSpace::CreateSRGB()).ToSkColorSpace();
-    case kRec2020CanvasColorSpace:
-      return (gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT2020,
-                              gfx::ColorSpace::TransferID::LINEAR))
-          .ToSkColorSpace();
-    case kP3CanvasColorSpace:
-      return (gfx::ColorSpace(gfx::ColorSpace::PrimaryID::SMPTEST432_1,
-                              gfx::ColorSpace::TransferID::LINEAR))
-          .ToSkColorSpace();
-  }
-  NOTREACHED();
-  return nullptr;
-}
-
-sk_sp<SkColorSpace> ImageData::GetSkColorSpaceForTest(
-    const CanvasColorSpace& color_space,
-    const CanvasPixelFormat& pixel_format) {
-  return GetSkColorSpace(color_space, pixel_format);
-}
-
 bool ImageData::ImageDataInCanvasColorSettings(
     const CanvasColorSpace& canvas_color_space,
     const CanvasPixelFormat& canvas_pixel_format,
     std::unique_ptr<uint8_t[]>& converted_pixels) {
   if (!data_ && !data_u16_ && !data_f32_)
     return false;
 
   // If canvas and image data are both in the same color space and pixel format
   // is 8-8-8-8, just return the embedded data.
   CanvasColorSpace image_data_color_space =
@@ skipping 38 matching lines @@
   } else if (data_f32_) {
     src_data = static_cast<void*>(data_f32_->Data());
     DCHECK(src_data);
     src_color_format = SkColorSpaceXform::ColorFormat::kRGBA_F32_ColorFormat;
   } else {
     NOTREACHED();
   }
 
   sk_sp<SkColorSpace> src_color_space = nullptr;
   if (data_) {
-    src_color_space = ImageData::GetSkColorSpace(image_data_color_space,
-                                                 kRGBA8CanvasPixelFormat);
+    src_color_space =
+        CanvasColorParams(image_data_color_space, kRGBA8CanvasPixelFormat)
+            .GetSkColorSpaceForSkSurfaces();
   } else {
-    src_color_space = ImageData::GetSkColorSpace(image_data_color_space,
-                                                 kF16CanvasPixelFormat);
+    src_color_space =
+        CanvasColorParams(image_data_color_space, kF16CanvasPixelFormat)
+            .GetSkColorSpaceForSkSurfaces();
   }
 
   sk_sp<SkColorSpace> dst_color_space =
-      ImageData::GetSkColorSpace(canvas_color_space, canvas_pixel_format);
-
+      CanvasColorParams(canvas_color_space, canvas_pixel_format)
+          .GetSkColorSpaceForSkSurfaces();
   SkColorSpaceXform::ColorFormat dst_color_format =
       SkColorSpaceXform::ColorFormat::kRGBA_8888_ColorFormat;
   if (canvas_pixel_format == kF16CanvasPixelFormat)
     dst_color_format = SkColorSpaceXform::ColorFormat::kRGBA_F16_ColorFormat;
 
   if (SkColorSpace::Equals(src_color_space.get(), dst_color_space.get()) &&
       src_color_format == dst_color_format)
     return static_cast<unsigned char*>(src_data);
 
   std::unique_ptr<SkColorSpaceXform> xform =
@@ skipping 63 matching lines @@
       SECURITY_CHECK(static_cast<unsigned>(size.Width() * size.Height() * 4) <=
                      data_f32_->length());
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace blink