/*
 * 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 <optional>

#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<SkColorSpace>);

  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<base::TimeDelta> 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<SkImage> 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<SkBitmap::Allocator> 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<base::TimeDelta> 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.
  // WTF::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_