// 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 "cc/paint/paint_shader.h" #include "base/atomic_sequence_num.h" #include "cc/paint/paint_image_builder.h" #include "cc/paint/paint_op_writer.h" #include "cc/paint/paint_record.h" #include "third_party/skia/include/core/SkPictureRecorder.h" #include "third_party/skia/include/effects/SkGradientShader.h" namespace cc { namespace { base::AtomicSequenceNumber g_next_shader_id; sk_sp ToSkPicture(sk_sp record, const SkRect& bounds, const gfx::SizeF* raster_scale, ImageProvider* image_provider) { SkPictureRecorder recorder; SkCanvas* canvas = recorder.beginRecording(SkRect::MakeWH(bounds.width(), bounds.height())); canvas->translate(-bounds.fLeft, -bounds.fTop); if (raster_scale) canvas->scale(raster_scale->width(), raster_scale->height()); record->Playback(canvas, PlaybackParams(image_provider)); return recorder.finishRecordingAsPicture(); } bool CompareMatrices(const SkMatrix& a, const SkMatrix& b, bool ignore_scaling_differences) { if (!ignore_scaling_differences) return PaintOp::AreSkMatricesEqual(a, b); SkSize scale; SkMatrix a_without_scale; SkMatrix b_without_scale; const bool decomposes = a.decomposeScale(&scale, &a_without_scale); if (decomposes != b.decomposeScale(&scale, &b_without_scale)) return false; if (!decomposes) return true; return PaintOp::AreSkMatricesEqual(a_without_scale, b_without_scale); } } // namespace const PaintShader::RecordShaderId PaintShader::kInvalidRecordShaderId = -1; sk_sp PaintShader::MakeColor(SkColor color) { sk_sp shader(new PaintShader(Type::kColor)); // Just one color. Store it in the fallback color. Easy. shader->fallback_color_ = color; shader->CreateSkShader(); return shader; } sk_sp PaintShader::MakeLinearGradient(const SkPoint points[], const SkColor colors[], const SkScalar pos[], int count, SkShader::TileMode mode, uint32_t flags, const SkMatrix* local_matrix, SkColor fallback_color) { sk_sp shader(new PaintShader(Type::kLinearGradient)); // There are always two points, the start and the end. shader->start_point_ = points[0]; shader->end_point_ = points[1]; shader->SetColorsAndPositions(colors, pos, count); shader->SetMatrixAndTiling(local_matrix, mode, mode); shader->SetFlagsAndFallback(flags, fallback_color); shader->CreateSkShader(); return shader; } sk_sp PaintShader::MakeRadialGradient(const SkPoint& center, SkScalar radius, const SkColor colors[], const SkScalar pos[], int count, SkShader::TileMode mode, uint32_t flags, const SkMatrix* local_matrix, SkColor fallback_color) { sk_sp shader(new PaintShader(Type::kRadialGradient)); shader->center_ = center; shader->start_radius_ = shader->end_radius_ = radius; shader->SetColorsAndPositions(colors, pos, count); shader->SetMatrixAndTiling(local_matrix, mode, mode); shader->SetFlagsAndFallback(flags, fallback_color); shader->CreateSkShader(); return shader; } sk_sp PaintShader::MakeTwoPointConicalGradient( const SkPoint& start, SkScalar start_radius, const SkPoint& end, SkScalar end_radius, const SkColor colors[], const SkScalar pos[], int count, SkShader::TileMode mode, uint32_t flags, const SkMatrix* local_matrix, SkColor fallback_color) { sk_sp shader(new PaintShader(Type::kTwoPointConicalGradient)); shader->start_point_ = start; shader->end_point_ = end; shader->start_radius_ = start_radius; shader->end_radius_ = end_radius; shader->SetColorsAndPositions(colors, pos, count); shader->SetMatrixAndTiling(local_matrix, mode, mode); shader->SetFlagsAndFallback(flags, fallback_color); shader->CreateSkShader(); return shader; } sk_sp PaintShader::MakeSweepGradient(SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int color_count, SkShader::TileMode mode, SkScalar start_degrees, SkScalar end_degrees, uint32_t flags, const SkMatrix* local_matrix, SkColor fallback_color) { sk_sp shader(new PaintShader(Type::kSweepGradient)); shader->center_ = SkPoint::Make(cx, cy); shader->start_degrees_ = start_degrees; shader->end_degrees_ = end_degrees; shader->SetColorsAndPositions(colors, pos, color_count); shader->SetMatrixAndTiling(local_matrix, mode, mode); shader->SetFlagsAndFallback(flags, fallback_color); shader->CreateSkShader(); return shader; } sk_sp PaintShader::MakeImage(const PaintImage& image, SkShader::TileMode tx, SkShader::TileMode ty, const SkMatrix* local_matrix) { sk_sp shader(new PaintShader(Type::kImage)); shader->image_ = image; shader->SetMatrixAndTiling(local_matrix, tx, ty); shader->CreateSkShader(); return shader; } sk_sp PaintShader::MakePaintRecord( sk_sp record, const SkRect& tile, SkShader::TileMode tx, SkShader::TileMode ty, const SkMatrix* local_matrix, ScalingBehavior scaling_behavior) { sk_sp shader(new PaintShader(Type::kPaintRecord)); shader->record_ = std::move(record); shader->id_ = g_next_shader_id.GetNext(); shader->tile_ = tile; shader->scaling_behavior_ = scaling_behavior; shader->SetMatrixAndTiling(local_matrix, tx, ty); shader->CreateSkShader(); return shader; } // static size_t PaintShader::GetSerializedSize(const PaintShader* shader) { size_t bool_size = sizeof(bool); if (!shader) return bool_size; return bool_size + sizeof(shader->shader_type_) + sizeof(shader->flags_) + sizeof(shader->end_radius_) + sizeof(shader->start_radius_) + sizeof(shader->tx_) + sizeof(shader->ty_) + sizeof(shader->fallback_color_) + sizeof(shader->scaling_behavior_) + bool_size + sizeof(*shader->local_matrix_) + sizeof(shader->center_) + sizeof(shader->tile_) + sizeof(shader->start_point_) + sizeof(shader->end_point_) + sizeof(shader->start_degrees_) + sizeof(shader->end_degrees_) + PaintOpWriter::GetImageSize(shader->image_) + PaintOpWriter::GetImageSize(shader->image_) + bool_size + sizeof(shader->id_) + PaintOpWriter::GetRecordSize(shader->record_.get()) + sizeof(shader->colors_.size()) + shader->colors_.size() * sizeof(SkColor) + sizeof(shader->positions_.size()) + shader->positions_.size() * sizeof(SkScalar); } PaintShader::PaintShader(Type type) : shader_type_(type) {} PaintShader::~PaintShader() = default; bool PaintShader::has_discardable_images() const { return (image_ && image_.IsLazyGenerated()) || (record_ && record_->HasDiscardableImages()); } bool PaintShader::GetRasterizationTileRect(const SkMatrix& ctm, SkRect* tile_rect) const { DCHECK_EQ(shader_type_, Type::kPaintRecord); // If we are using a fixed scale, the record is rasterized with the original // tile size and scaling is applied to the generated output. if (scaling_behavior_ == ScalingBehavior::kFixedScale) { *tile_rect = tile_; return true; } SkMatrix matrix = ctm; if (local_matrix_.has_value()) matrix.preConcat(local_matrix_.value()); SkSize scale; if (!matrix.decomposeScale(&scale)) { // Decomposition failed, use an approximation. scale.set(SkScalarSqrt(matrix.getScaleX() * matrix.getScaleX() + matrix.getSkewX() * matrix.getSkewX()), SkScalarSqrt(matrix.getScaleY() * matrix.getScaleY() + matrix.getSkewY() * matrix.getSkewY())); } SkScalar tile_area = tile_.width() * tile_.height() * scale.width() * scale.height(); // Clamp the tile size to about 4M pixels. // TODO(khushalsagar): We need to consider the max texture size as well. static const SkScalar kMaxTileArea = 2048 * 2048; if (tile_area > kMaxTileArea) { SkScalar clamp_scale = SkScalarSqrt(kMaxTileArea / tile_area); scale.set(clamp_scale, clamp_scale); } *tile_rect = SkRect::MakeXYWH( tile_.fLeft * scale.width(), tile_.fTop * scale.height(), SkScalarCeilToInt(SkScalarAbs(scale.width() * tile_.width())), SkScalarCeilToInt(SkScalarAbs(scale.height() * tile_.height()))); if (tile_rect->isEmpty()) return false; return true; } sk_sp PaintShader::CreateScaledPaintRecord( const SkMatrix& ctm, gfx::SizeF* raster_scale) const { DCHECK_EQ(shader_type_, Type::kPaintRecord); // For creating a decoded PaintRecord shader, we need to do the following: // 1) Figure out the scale at which the record should be rasterization given // the ctm and local_matrix on the shader. // 2) Transform this record to an SkPicture with this scale and replace // encoded images in this record with decodes from the ImageProvider. This // is done by setting the raster_matrix_ for this shader to be used // in GetSkShader. // 3) Since the SkShader will use a scaled SkPicture, we use a kFixedScale for // the decoded shader which creates an SkPicture backed SkImage for // creating the decoded SkShader. // Note that the scaling logic here is replicated from // SkPictureShader::refBitmapShader. SkRect tile_rect; if (!GetRasterizationTileRect(ctm, &tile_rect)) return nullptr; sk_sp shader(new PaintShader(Type::kPaintRecord)); shader->record_ = record_; shader->id_ = id_; shader->tile_ = tile_rect; // Use a fixed scale since we have already scaled the tile rect and fixed the // raster scale. shader->scaling_behavior_ = ScalingBehavior::kFixedScale; shader->tx_ = tx_; shader->ty_ = ty_; *raster_scale = gfx::SizeF(SkIntToScalar(tile_rect.width()) / tile_.width(), SkIntToScalar(tile_rect.height()) / tile_.height()); shader->local_matrix_ = GetLocalMatrix(); shader->local_matrix_->preScale(1 / raster_scale->width(), 1 / raster_scale->height()); return shader; } sk_sp PaintShader::CreateDecodedImage( const SkMatrix& ctm, SkFilterQuality quality, ImageProvider* image_provider, uint32_t* transfer_cache_entry_id, SkFilterQuality* raster_quality, bool* needs_mips) const { DCHECK_EQ(shader_type_, Type::kImage); if (!image_) return nullptr; SkMatrix total_image_matrix = GetLocalMatrix(); total_image_matrix.preConcat(ctm); SkRect src_rect = SkRect::MakeIWH(image_.width(), image_.height()); SkIRect int_src_rect; src_rect.roundOut(&int_src_rect); DrawImage draw_image(image_, int_src_rect, quality, total_image_matrix); auto decoded_draw_image = image_provider->GetDecodedDrawImage(draw_image); if (!decoded_draw_image) return nullptr; auto decoded_image = decoded_draw_image.decoded_image(); SkMatrix final_matrix = GetLocalMatrix(); bool need_scale = !decoded_image.is_scale_adjustment_identity(); if (need_scale) { final_matrix.preScale(1.f / decoded_image.scale_adjustment().width(), 1.f / decoded_image.scale_adjustment().height()); } PaintImage decoded_paint_image; if (decoded_image.transfer_cache_entry_id()) { decoded_paint_image = image_; *transfer_cache_entry_id = *decoded_image.transfer_cache_entry_id(); } else { DCHECK(decoded_image.image()); sk_sp sk_image = sk_ref_sp(const_cast(decoded_image.image().get())); decoded_paint_image = PaintImageBuilder::WithDefault() .set_id(image_.stable_id()) .set_image(std::move(sk_image), image_.content_id()) .TakePaintImage(); } // TODO(khushalsagar): Remove filter quality from DecodedDrawImage. All we // want to do is cap the filter quality used, but Gpu and Sw cache have // different behaviour. D: *raster_quality = decoded_image.filter_quality(); *needs_mips = decoded_image.transfer_cache_entry_needs_mips(); return PaintShader::MakeImage(decoded_paint_image, tx_, ty_, &final_matrix); } sk_sp PaintShader::GetSkShader() const { return cached_shader_; } void PaintShader::CreateSkShader(const gfx::SizeF* raster_scale, ImageProvider* image_provider) { DCHECK(!cached_shader_); switch (shader_type_) { case Type::kColor: // This will be handled by the fallback check below. break; case Type::kLinearGradient: { SkPoint points[2] = {start_point_, end_point_}; cached_shader_ = SkGradientShader::MakeLinear( points, colors_.data(), positions_.empty() ? nullptr : positions_.data(), static_cast(colors_.size()), tx_, flags_, base::OptionalOrNullptr(local_matrix_)); break; } case Type::kRadialGradient: cached_shader_ = SkGradientShader::MakeRadial( center_, start_radius_, colors_.data(), positions_.empty() ? nullptr : positions_.data(), static_cast(colors_.size()), tx_, flags_, base::OptionalOrNullptr(local_matrix_)); break; case Type::kTwoPointConicalGradient: cached_shader_ = SkGradientShader::MakeTwoPointConical( start_point_, start_radius_, end_point_, end_radius_, colors_.data(), positions_.empty() ? nullptr : positions_.data(), static_cast(colors_.size()), tx_, flags_, base::OptionalOrNullptr(local_matrix_)); break; case Type::kSweepGradient: cached_shader_ = SkGradientShader::MakeSweep( center_.x(), center_.y(), colors_.data(), positions_.empty() ? nullptr : positions_.data(), static_cast(colors_.size()), tx_, start_degrees_, end_degrees_, flags_, base::OptionalOrNullptr(local_matrix_)); break; case Type::kImage: if (image_) { cached_shader_ = image_.GetSkImage()->makeShader( tx_, ty_, base::OptionalOrNullptr(local_matrix_)); } break; case Type::kPaintRecord: { // Create a recording at the desired scale if this record has images which // have been decoded before raster. auto picture = ToSkPicture(record_, tile_, raster_scale, image_provider); switch (scaling_behavior_) { // For raster scale, we create a picture shader directly. case ScalingBehavior::kRasterAtScale: cached_shader_ = SkShader::MakePictureShader( std::move(picture), tx_, ty_, base::OptionalOrNullptr(local_matrix_), nullptr); break; // For fixed scale, we create an image shader with an image backed by // the picture. case ScalingBehavior::kFixedScale: { auto image = SkImage::MakeFromPicture( std::move(picture), SkISize::Make(tile_.width(), tile_.height()), nullptr, nullptr, SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB()); cached_shader_ = image->makeShader( tx_, ty_, base::OptionalOrNullptr(local_matrix_)); break; } } break; } case Type::kShaderCount: NOTREACHED(); break; } // If we didn't create a shader for whatever reason, create a fallback color // one. if (!cached_shader_) cached_shader_ = SkShader::MakeColorShader(fallback_color_); } void PaintShader::SetColorsAndPositions(const SkColor* colors, const SkScalar* positions, int count) { #if DCHECK_IS_ON() static const int kMaxShaderColorsSupported = 10000; DCHECK_GE(count, 2); DCHECK_LE(count, kMaxShaderColorsSupported); #endif colors_.assign(colors, colors + count); if (positions) positions_.assign(positions, positions + count); } void PaintShader::SetMatrixAndTiling(const SkMatrix* matrix, SkShader::TileMode tx, SkShader::TileMode ty) { if (matrix) local_matrix_ = *matrix; tx_ = tx; ty_ = ty; } void PaintShader::SetFlagsAndFallback(uint32_t flags, SkColor fallback_color) { flags_ = flags; fallback_color_ = fallback_color; } bool PaintShader::IsOpaque() const { // TODO(enne): don't create a shader to answer this. return GetSkShader()->isOpaque(); } bool PaintShader::IsValid() const { // If we managed to create a shader already, then we should be valid. if (cached_shader_) return true; switch (shader_type_) { case Type::kColor: return true; case Type::kSweepGradient: if (!std::isfinite(start_degrees_) || !std::isfinite(end_degrees_) || start_degrees_ >= end_degrees_) { return false; } FALLTHROUGH; case Type::kLinearGradient: case Type::kRadialGradient: case Type::kTwoPointConicalGradient: return colors_.size() >= 2 && (positions_.empty() || positions_.size() == colors_.size()); case Type::kImage: // We may not be able to decode the image, in which case it would be // false, but that would still make a valid shader. return true; case Type::kPaintRecord: return !!record_; case Type::kShaderCount: return false; } return false; } bool PaintShader::operator==(const PaintShader& other) const { if (shader_type_ != other.shader_type_) return false; // Record and image shaders are scaled during serialization. const bool ignore_scaling_differences = shader_type_ == PaintShader::Type::kPaintRecord || shader_type_ == PaintShader::Type::kImage; // Variables that all shaders use. const SkMatrix& local_matrix = local_matrix_ ? *local_matrix_ : SkMatrix::I(); const SkMatrix& other_local_matrix = other.local_matrix_ ? *other.local_matrix_ : SkMatrix::I(); if (!CompareMatrices(local_matrix, other_local_matrix, ignore_scaling_differences)) { return false; } if (fallback_color_ != other.fallback_color_) return false; if (flags_ != other.flags_) return false; if (tx_ != other.tx_) return false; if (ty_ != other.ty_) return false; if (!ignore_scaling_differences && scaling_behavior_ != other.scaling_behavior_) return false; // Variables that only some shaders use. switch (shader_type_) { case Type::kColor: break; case Type::kSweepGradient: if (!PaintOp::AreEqualEvenIfNaN(start_degrees_, other.start_degrees_)) return false; if (!PaintOp::AreEqualEvenIfNaN(end_degrees_, other.end_degrees_)) return false; FALLTHROUGH; case Type::kLinearGradient: case Type::kRadialGradient: case Type::kTwoPointConicalGradient: if (!PaintOp::AreEqualEvenIfNaN(start_radius_, other.start_radius_)) return false; if (!PaintOp::AreEqualEvenIfNaN(end_radius_, other.end_radius_)) return false; if (!PaintOp::AreSkPointsEqual(center_, other.center_)) return false; if (!PaintOp::AreSkPointsEqual(start_point_, other.start_point_)) return false; if (!PaintOp::AreSkPointsEqual(end_point_, other.end_point_)) return false; if (colors_ != other.colors_) return false; if (positions_.size() != other.positions_.size()) return false; for (size_t i = 0; i < positions_.size(); ++i) { if (!PaintOp::AreEqualEvenIfNaN(positions_[i], other.positions_[i])) return false; } break; case Type::kImage: // TODO(enne): add comparison of images once those are serialized. break; case Type::kPaintRecord: // If we have a record but not other.record, or vice versa, then shaders // aren't the same. if (!record_ != !other.record_) return false; // tile_ and record_ intentionally omitted since they are modified on the // serialized shader based on the ctm. break; case Type::kShaderCount: break; } return true; } } // namespace cc