blob: b5da3443bc090af46f04f1f8d100271a4fec34b0 [file] [log] [blame]
// Copyright 2017 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 <vector>
#include "base/gtest_prod_util.h"
#include "base/logging.h"
#include "cc/paint/frame_metadata.h"
#include "cc/paint/image_animation_count.h"
#include "cc/paint/paint_export.h"
#include "cc/paint/skia_paint_image_generator.h"
#include "third_party/skia/include/core/SkImage.h"
#include "ui/gfx/geometry/rect.h"
namespace cc {
class PaintImageGenerator;
class PaintOpBuffer;
using PaintRecord = PaintOpBuffer;
// A representation of an image for the compositor.
// Note that aside from default construction, it can only be constructed using a
// PaintImageBuilder, or copied/moved into using operator=.
class CC_PAINT_EXPORT PaintImage {
using Id = int;
using AnimationSequenceId = uint32_t;
// A ContentId is used to identify the content for which images which can be
// lazily generated (generator/record backed images). As opposed to Id, which
// stays constant for the same image, the content id can be updated when the
// backing encoded data for this image changes. For instance, in the case of
// images which can be progressively updated as more encoded data is received.
using ContentId = int;
// An id that can be used for all non-lazy images. Note that if an image is
// not lazy, it does not mean that this id must be used; one can still use
// GetNextId to generate a stable id for such images.
static const Id kNonLazyStableId;
// The default frame index to use if no index is provided. For multi-frame
// images, this would imply the first frame of the animation.
static const size_t kDefaultFrameIndex;
static const Id kInvalidId;
class CC_PAINT_EXPORT FrameKey {
FrameKey(ContentId content_id, size_t frame_index, gfx::Rect subset_rect);
bool operator==(const FrameKey& other) const;
bool operator!=(const FrameKey& other) const;
uint64_t hash() const { return hash_; }
std::string ToString() const;
size_t frame_index() const { return frame_index_; }
ContentId content_id_;
size_t frame_index_;
// TODO(khushalsagar): Remove this when callers take care of subsetting.
gfx::Rect subset_rect_;
size_t hash_;
struct CC_PAINT_EXPORT FrameKeyHash {
size_t operator()(const FrameKey& frame_key) const {
return frame_key.hash();
enum class AnimationType { ANIMATED, VIDEO, STATIC };
enum class CompletionState { DONE, PARTIALLY_DONE };
enum class DecodingMode {
// No preference has been specified. The compositor may choose to use sync
// or async decoding. See CheckerImageTracker for the default behaviour.
// It's preferred to display this image synchronously with the rest of the
// content updates, skipping any heuristics.
// Async is preferred. The compositor may decode async if it meets the
// heuristics used to avoid flickering (for instance vetoing of multipart
// response, animated, partially loaded images) and would be performant. See
// CheckerImageTracker for all heuristics used.
// Returns the more conservative mode out of the two given ones.
static DecodingMode GetConservative(DecodingMode one, DecodingMode two);
static Id GetNextId();
static ContentId GetNextContentId();
PaintImage(const PaintImage& other);
PaintImage(PaintImage&& other);
PaintImage& operator=(const PaintImage& other);
PaintImage& operator=(PaintImage&& other);
bool operator==(const PaintImage& other) const;
bool operator!=(const PaintImage& other) const { return !(*this == other); }
// Returns the smallest size that is at least as big as the requested_size
// such that we can decode to exactly that scale. If the requested size is
// larger than the image, this returns the image size. Any returned value is
// guaranteed to be stable. That is,
// GetSupportedDecodeSize(GetSupportedDecodeSize(size)) is guaranteed to be
// GetSupportedDecodeSize(size).
SkISize GetSupportedDecodeSize(const SkISize& requested_size) const;
// Decode the image into the given memory for the given SkImageInfo.
// - Size in |info| must be supported.
// - The amount of memory allocated must be at least
// |info|.minRowBytes() * |info|.height().
// Returns true on success and false on failure. Updates |info| to match the
// requested color space, if provided.
// Note that for non-lazy images this will do a copy or readback if the image
// is texture backed.
bool Decode(void* memory,
SkImageInfo* info,
sk_sp<SkColorSpace> color_space,
size_t frame_index) const;
Id stable_id() const { return id_; }
const sk_sp<SkImage>& GetSkImage() const;
AnimationType animation_type() const { return animation_type_; }
CompletionState completion_state() const { return completion_state_; }
bool is_multipart() const { return is_multipart_; }
int repetition_count() const { return repetition_count_; }
bool ShouldAnimate() const;
size_t frame_index() const { return frame_index_; }
AnimationSequenceId reset_animation_sequence_id() const {
return reset_animation_sequence_id_;
DecodingMode decoding_mode() const { return decoding_mode_; }
// TODO(vmpstr): Don't get the SkImage here if you don't need to.
uint32_t unique_id() const { return GetSkImage()->uniqueID(); }
explicit operator bool() const { return !!GetSkImage(); }
bool IsLazyGenerated() const { return GetSkImage()->isLazyGenerated(); }
int width() const { return GetSkImage()->width(); }
int height() const { return GetSkImage()->height(); }
SkColorSpace* color_space() const { return GetSkImage()->colorSpace(); }
// Returns a unique id for the pixel data for the frame at |frame_index|. Used
// only for lazy-generated images.
FrameKey GetKeyForFrame(size_t frame_index) const;
// Returns the metadata for each frame of a multi-frame image. Should only be
// used with animated images.
const std::vector<FrameMetadata>& GetFrameMetadata() const;
// Returns the total number of frames known to exist in this image.
size_t FrameCount() const;
std::string ToString() const;
static const ContentId kInvalidContentId = -1;
friend class PaintImageBuilder;
FRIEND_TEST_ALL_PREFIXES(PaintImageTest, Subsetting);
bool DecodeFromGenerator(void* memory,
SkImageInfo* info,
sk_sp<SkColorSpace> color_space,
size_t frame_index) const;
bool DecodeFromSkImage(void* memory,
SkImageInfo* info,
sk_sp<SkColorSpace> color_space,
size_t frame_index) const;
void CreateSkImage();
PaintImage MakeSubset(const gfx::Rect& subset) const;
// Returns an SkImage for the frame at |index|.
sk_sp<SkImage> GetSkImageForFrame(size_t index) const;
sk_sp<SkImage> sk_image_;
sk_sp<PaintRecord> paint_record_;
gfx::Rect paint_record_rect_;
ContentId paint_record_content_id_ = kInvalidContentId;
sk_sp<PaintImageGenerator> paint_image_generator_;
Id id_ = 0;
AnimationType animation_type_ = AnimationType::STATIC;
CompletionState completion_state_ = CompletionState::DONE;
int repetition_count_ = kAnimationNone;
// If non-empty, holds the subset of this image relative to the original image
// at the origin.
gfx::Rect subset_rect_;
// The frame index to use when rasterizing this image.
size_t frame_index_ = kDefaultFrameIndex;
// Whether the data fetched for this image is a part of a multpart response.
bool is_multipart_ = false;
// An incrementing sequence number maintained by the painter to indicate if
// this animation should be reset in the compositor. Incrementing this number
// will reset this animation in the compositor for the first frame which has a
// recording with a PaintImage storing the updated sequence id.
AnimationSequenceId reset_animation_sequence_id_ = 0u;
DecodingMode decoding_mode_ = DecodingMode::kSync;
// The |cached_sk_image_| can be derived/created from other inputs present in
// the PaintImage but we always construct it at creation time for 2 reasons:
// 1) This ensures that the underlying SkImage is shared across PaintImage
// copies, which is necessary to allow reuse of decodes from this image in
// skia's cache.
// 2) Ensures that accesses to it are thread-safe.
sk_sp<SkImage> cached_sk_image_;
} // namespace cc