/* * Copyright (C) 2006 Apple Computer, Inc. All rights reserved. * Copyright (C) Research In Motion Limited 2009-2010. 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 * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_IMAGE_DECODERS_IMAGE_FRAME_H_ #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_IMAGE_DECODERS_IMAGE_FRAME_H_ #include #include "base/check_op.h" #include "base/compiler_specific.h" #include "base/memory/raw_ptr.h" #include "base/notreached.h" #include "base/time/time.h" #include "skia/ext/pmcolor_utils.h" #include "third_party/blink/renderer/platform/platform_export.h" #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h" #include "third_party/blink/renderer/platform/wtf/wtf_size_t.h" #include "third_party/skia/include/core/SkBitmap.h" #include "third_party/skia/include/core/SkImage.h" #include "third_party/skia/include/core/SkPixmap.h" #include "third_party/skia/include/private/chromium/SkPMColor.h" #include "ui/gfx/geometry/rect.h" class SkImage; namespace blink { // ImageFrame represents the decoded image data. This buffer is what all // decoders write a single frame into. class PLATFORM_EXPORT ImageFrame final { DISALLOW_NEW(); public: enum PixelFormat { kN32, kRGBA_F16 }; enum Status { kFrameEmpty, kFrameInitialized, kFramePartial, kFrameComplete }; enum DisposalMethod { // If you change the numeric values of these, make sure you audit // all users, as some users may cast raw values to/from these // constants. kDisposeNotSpecified, // Leave frame in framebuffer kDisposeKeep, // Leave frame in framebuffer kDisposeOverwriteBgcolor, // Clear frame to fully transparent kDisposeOverwritePrevious // Clear frame to previous framebuffer contents }; // Indicates how non-opaque pixels in the current frame rectangle // are blended with those in the previous frame. // Notes: // * GIF always uses 'BlendAtopPreviousFrame'. // * WebP also uses the 'BlendAtopBgcolor' option. This is useful for // cases where one wants to transform a few opaque pixels of the // previous frame into non-opaque pixels in the current frame. enum AlphaBlendSource { // Blend non-opaque pixels atop the corresponding pixels in the // initial buffer state (i.e. any previous frame buffer after having // been properly disposed). kBlendAtopPreviousFrame, // Blend non-opaque pixels against fully transparent (i.e. simply // overwrite the corresponding pixels). kBlendAtopBgcolor, }; typedef uint32_t PixelData; typedef uint64_t PixelDataF16; ImageFrame(); ~ImageFrame(); // The assignment operator reads has_alpha_ (inside SetStatus()) before it // sets it (in SetHasAlpha()). This doesn't cause any problems, since the // SetHasAlpha() call ensures all state is set correctly, but it means we // need to initialize has_alpha_ to some value before calling the operator // lest any tools complain about using an uninitialized value. ImageFrame(const ImageFrame& other); // For backends which refcount their data, this operator doesn't need to // create a new copy of the image data, only increase the ref count. ImageFrame& operator=(const ImageFrame& other); // These do not touch other metadata, only the raw pixel data. void ClearPixelData(); void ZeroFillPixelData(); void ZeroFillFrameRect(const gfx::Rect&); // Makes this frame have an independent copy of the provided image's // pixel data, so that modifications in one frame are not reflected in // the other. Returns whether the copy succeeded. bool CopyBitmapData(const ImageFrame&); // Moves the bitmap data from the provided frame to this one, leaving the // provided frame empty. Operation is successful only if bitmap data is not // marked as done (immutable). Returns whether the move succeeded. bool TakeBitmapDataIfWritable(ImageFrame*); // Copies the pixel data at [(start_x, start_y), (end_x, start_y)) to the // same X-coordinates on each subsequent row up to but not including // end_y. void CopyRowNTimes(int start_x, int end_x, int start_y, int end_y) { DCHECK(pixel_format_ == kN32); DCHECK_LT(start_x, Width()); DCHECK_LE(end_x, Width()); DCHECK_LT(start_y, Height()); DCHECK_LE(end_y, Height()); const int row_bytes = (end_x - start_x) * sizeof(PixelData); const PixelData* const start_addr = GetAddr(start_x, start_y); for (int dest_y = start_y + 1; dest_y < end_y; ++dest_y) { UNSAFE_TODO(memcpy(GetAddr(start_x, dest_y), start_addr, row_bytes)); } } // Allocates space for the pixel data. Must be called before any pixels are // written, and should only be called once. The specified color space may be // null if and only if color correct rendering is enabled. Returns true if the // allocation succeeded. [[nodiscard]] bool AllocatePixelData(int new_width, int new_height, sk_sp); bool HasAlpha() const { return has_alpha_; } PixelFormat GetPixelFormat() const { return pixel_format_; } const gfx::Rect& OriginalFrameRect() const { return original_frame_rect_; } Status GetStatus() const { return status_; } std::optional Timestamp() const { return timestamp_; } base::TimeDelta Duration() const { return duration_; } DisposalMethod GetDisposalMethod() const { return disposal_method_; } AlphaBlendSource GetAlphaBlendSource() const { return alpha_blend_source_; } bool PremultiplyAlpha() const { return premultiply_alpha_; } SkBitmap::Allocator* GetAllocator() const { return allocator_; } // Returns the bitmap that is the output of decoding. const SkBitmap& Bitmap() const { return bitmap_; } // Create SkImage from Bitmap() and return it. This should be called only // if frame is complete. The bitmap is set immutable before creating // SkImage to avoid copying bitmap in SkImages::RasterFromBitmap(bitmap_). sk_sp FinalizePixelsAndGetImage(); // Returns true if the pixels changed, but the bitmap has not yet been // notified. bool PixelsChanged() const { return pixels_changed_; } wtf_size_t RequiredPreviousFrameIndex() const { return required_previous_frame_index_; } void SetHasAlpha(bool alpha); void SetPixelFormat(PixelFormat format) { pixel_format_ = format; } void SetOriginalFrameRect(const gfx::Rect& r) { original_frame_rect_ = r; } void SetStatus(Status); void SetTimestamp(base::TimeDelta timestamp) { timestamp_ = timestamp; } void SetDuration(base::TimeDelta duration) { duration_ = duration; } void SetDisposalMethod(DisposalMethod disposal_method) { disposal_method_ = disposal_method; } void SetAlphaBlendSource(AlphaBlendSource alpha_blend_source) { alpha_blend_source_ = alpha_blend_source; } void SetPremultiplyAlpha(bool premultiply_alpha) { premultiply_alpha_ = premultiply_alpha; } void SetMemoryAllocator(SkBitmap::Allocator* allocator) { allocator_ = allocator; } // The pixels_changed flag needs to be set when the raw pixel data was // directly modified (e.g. through a pointer or SetRGBA). The flag is usually // set after a batch of changes has been made. void SetPixelsChanged(bool pixels_changed) { pixels_changed_ = pixels_changed; } void SetRequiredPreviousFrameIndex(wtf_size_t previous_frame_index) { required_previous_frame_index_ = previous_frame_index; } inline PixelData* GetAddr(int x, int y) { DCHECK(pixel_format_ == kN32); return bitmap_.getAddr32(x, y); } inline PixelDataF16* GetAddrF16(int x, int y) { DCHECK(pixel_format_ == kRGBA_F16); SkPixmap pixmap; if (!bitmap_.peekPixels(&pixmap)) { NOTREACHED(); } return pixmap.writable_addr64(x, y); } inline void SetRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a) { DCHECK(pixel_format_ == kN32); SetRGBA(GetAddr(x, y), r, g, b, a); } inline void SetRGBA(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { DCHECK(pixel_format_ == kN32); if (premultiply_alpha_) { SetRGBAPremultiply(dest, r, g, b, a); } else { *dest = SkPMColorSetARGB(a, r, g, b); } } static inline void SetRGBAPremultiply(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { enum FractionControl { kRoundFractionControl = 257 * 128 }; if (a < 255) { unsigned alpha = a * 257; r = (r * alpha + kRoundFractionControl) >> 16; g = (g * alpha + kRoundFractionControl) >> 16; b = (b * alpha + kRoundFractionControl) >> 16; } *dest = SkPMColorSetARGB(a, r, g, b); } static inline void SetRGBARaw(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { *dest = SkPMColorSetARGB(a, r, g, b); } // Blend the RGBA pixel provided by |red|, |green|, |blue| and |alpha| over // the pixel in |dest|, without premultiplication, and overwrite |dest| with // the result. static void BlendRGBARaw(PixelData* dest, unsigned red, unsigned green, unsigned blue, unsigned alpha); static void BlendRGBARawF16Buffer(PixelDataF16* dst, PixelDataF16* src, size_t num_pixels); // Blend the pixel in |src| over |dst| and overwrite |src| with the result. // This requires |src| and |dst| to not have alpha premultiplied on the rgb // channels. static void BlendSrcOverDstRaw(PixelData* src, PixelData dst); // Blend the RGBA pixel provided by |r|, |g|, |b|, |a| over the pixel in // |dest| and overwrite |dest| with the result. Premultiply the pixel values // before blending. static inline void BlendRGBAPremultiplied(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a) { // If the new pixel is completely transparent, no operation is necessary // since |dest| contains the background pixel. if (a == 0x0) { return; } // If the new pixel is opaque, no need for blending - just write the // pixel. if (a == 0xFF) { SetRGBAPremultiply(dest, r, g, b, a); return; } PixelData src; SetRGBAPremultiply(&src, r, g, b, a); *dest = skia::BlendSrcOver(src, *dest); } static void BlendRGBAPremultipliedF16Buffer(PixelDataF16* dst, PixelDataF16* src, size_t num_pixels); // Blend the pixel in |src| over |dst| and overwrite |src| with the result. // This requires |src| and |dst| to be premultiplied already. static inline void BlendSrcOverDstPremultiplied(PixelData* src, PixelData dst) { *src = skia::BlendSrcOver(*src, dst); } // Notifies the SkBitmap if any pixels changed and resets the flag. inline void NotifyBitmapIfPixelsChanged() { if (pixels_changed_) { bitmap_.notifyPixelsChanged(); } pixels_changed_ = false; } private: int Width() const { return bitmap_.width(); } int Height() const { return bitmap_.height(); } SkAlphaType ComputeAlphaType() const; SkBitmap bitmap_; raw_ptr allocator_ = nullptr; bool has_alpha_ = true; PixelFormat pixel_format_ = kN32; // This will always just be the entire buffer except for GIF or WebP // frames whose original rect was smaller than the overall image size. gfx::Rect original_frame_rect_; Status status_ = kFrameEmpty; std::optional timestamp_; base::TimeDelta duration_; DisposalMethod disposal_method_ = kDisposeNotSpecified; AlphaBlendSource alpha_blend_source_ = kBlendAtopPreviousFrame; bool premultiply_alpha_ = true; // True if the pixels changed, but the bitmap has not yet been notified. bool pixels_changed_ = false; // The frame that must be decoded before this frame can be decoded. // kNotFound if this frame doesn't require any previous frame. // This is used by ImageDecoder::ClearCacheExceptFrame(), and will never // be read for image formats that do not have multiple frames. wtf_size_t required_previous_frame_index_ = kNotFound; }; } // namespace blink #endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_IMAGE_DECODERS_IMAGE_FRAME_H_