[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / 977e658ac1c9a155d9705762136530ed054ba439 / . / cc / raster / gpu_raster_buffer_provider.cc
blob: 49bffdb9ecd6c8534b74da3f5ff324907d232c1b [file] [log] [blame]
Avi Drissman3f7a9d82022-09-08 20:55:42[diff] [blame]1// Copyright 2014 The Chromium Authors
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]5#include "cc/raster/gpu_raster_buffer_provider.h"
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]6
avi02a4d172015-12-21 06:14:36[diff] [blame]7#include <stdint.h>
8
ernstm69fedbd2014-09-18 01:23:41[diff] [blame]9#include <algorithm>
Avi Drissmanb696fbf2023-12-04 22:54:24[diff] [blame]10#include <bit>
Robert Phillipsdbb0b7d2020-07-29 16:07:44[diff] [blame]11#include <memory>
Mike Reedf7074ff2019-03-14 14:28:16[diff] [blame]12#include <utility>
Robert Phillipsdbb0b7d2020-07-29 16:07:44[diff] [blame]13#include <vector>
ernstm69fedbd2014-09-18 01:23:41[diff] [blame]14
Hans Wennborg66d784de2020-06-17 20:23:03[diff] [blame]15#include "base/logging.h"
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]16#include "base/memory/raw_ptr.h"
ericrke4027312016-06-30 00:12:42[diff] [blame]17#include "base/metrics/histogram_macros.h"
Khushal3c3873a2018-11-06 18:14:01[diff] [blame]18#include "base/rand_util.h"
Alexandr Ilin0443a8f2018-07-20 20:14:50[diff] [blame]19#include "base/trace_event/process_memory_dump.h"
ssid904ce3b2015-01-27 15:20:16[diff] [blame]20#include "base/trace_event/trace_event.h"
Yuta Hijikata173c7d62020-11-10 06:21:37[diff] [blame]21#include "build/chromeos_buildflags.h"
Vasiliy Telezhnikovfa8768c52022-09-23 17:29:44[diff] [blame]22#include "cc/base/features.h"
ericrkc7c9e3f2016-07-01 17:30:16[diff] [blame]23#include "cc/base/histograms.h"
Adrienne Walker436a7752017-08-28 23:33:09[diff] [blame]24#include "cc/paint/display_item_list.h"
enne5a9630362017-02-24 23:41:03[diff] [blame]25#include "cc/paint/paint_canvas.h"
Adrienne Walker436a7752017-08-28 23:33:09[diff] [blame]26#include "cc/paint/paint_recorder.h"
chrishtrac41ff92017-03-17 05:07:30[diff] [blame]27#include "cc/raster/raster_source.h"
danakj57baa772018-05-29 15:59:14[diff] [blame]28#include "components/viz/client/client_resource_provider.h"
Maksim Sisov4dc61a12022-03-23 15:09:26[diff] [blame]29#include "components/viz/common/features.h"
Victor Miura29b7ea3d2017-12-19 20:23:59[diff] [blame]30#include "components/viz/common/gpu/raster_context_provider.h"
danakjaf3170e2018-02-09 17:31:58[diff] [blame]31#include "gpu/GLES2/gl2extchromium.h"
Mingjing Zhangdeb52562023-11-01 13:57:07[diff] [blame]32#include "gpu/command_buffer/client/client_shared_image.h"
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]33#include "gpu/command_buffer/client/context_support.h"
Victor Miura3a4ad4f82017-12-13 06:03:45[diff] [blame]34#include "gpu/command_buffer/client/raster_interface.h"
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]35#include "gpu/command_buffer/client/shared_image_interface.h"
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]36#include "gpu/command_buffer/common/shared_image_trace_utils.h"
37#include "gpu/command_buffer/common/shared_image_usage.h"
Ian Preste598eece2020-10-19 23:31:02[diff] [blame]38#include "skia/ext/legacy_display_globals.h"
hendrikw04cea972014-09-23 20:50:53[diff] [blame]39#include "third_party/skia/include/core/SkPictureRecorder.h"
reveman47560ab2014-09-18 19:39:21[diff] [blame]40#include "third_party/skia/include/core/SkSurface.h"
Peng Huang5f3d4352021-11-23 17:51:29[diff] [blame]41#include "ui/base/ui_base_features.h"
Adrienne Walker436a7752017-08-28 23:33:09[diff] [blame]42#include "ui/gfx/geometry/axis_transform2d.h"
Khushal49836ab2018-07-25 02:08:45[diff] [blame]43#include "url/gurl.h"
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]44
45namespace cc {
vmiura78b69282015-02-14 00:01:17[diff] [blame]46
danakjaf3170e2018-02-09 17:31:58[diff] [blame]47// Subclass for InUsePoolResource that holds ownership of a gpu-rastered backing
48// and does cleanup of the backing when destroyed.
49class GpuRasterBufferProvider::GpuRasterBacking
50 : public ResourcePool::GpuBacking {
51 public:
52 ~GpuRasterBacking() override {
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]53 if (!shared_image) {
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]54 return;
luci-bisection@appspot.gserviceaccount.come9ab19e2023-11-10 17:28:31[diff] [blame]55 }
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]56 auto* sii = worker_context_provider->SharedImageInterface();
danakjaf3170e2018-02-09 17:31:58[diff] [blame]57 if (returned_sync_token.HasData())
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]58 sii->DestroySharedImage(returned_sync_token, std::move(shared_image));
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]59 else if (mailbox_sync_token.HasData())
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]60 sii->DestroySharedImage(mailbox_sync_token, std::move(shared_image));
danakjaf3170e2018-02-09 17:31:58[diff] [blame]61 }
62
Alexandr Ilin0443a8f2018-07-20 20:14:50[diff] [blame]63 void OnMemoryDump(
64 base::trace_event::ProcessMemoryDump* pmd,
65 const base::trace_event::MemoryAllocatorDumpGuid& buffer_dump_guid,
66 uint64_t tracing_process_id,
67 int importance) const override {
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]68 if (!shared_image) {
Alexandr Ilin0443a8f2018-07-20 20:14:50[diff] [blame]69 return;
luci-bisection@appspot.gserviceaccount.come9ab19e2023-11-10 17:28:31[diff] [blame]70 }
Alexandr Ilin0443a8f2018-07-20 20:14:50[diff] [blame]71
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]72 auto tracing_guid = shared_image->GetGUIDForTracing();
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]73 pmd->CreateSharedGlobalAllocatorDump(tracing_guid);
74 pmd->AddOwnershipEdge(buffer_dump_guid, tracing_guid, importance);
danakjaf3170e2018-02-09 17:31:58[diff] [blame]75 }
danakjaf3170e2018-02-09 17:31:58[diff] [blame]76
kylecharffcf0912023-06-09 18:57:22[diff] [blame]77 // The context used to clean up the mailbox
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]78 raw_ptr<viz::RasterContextProvider> worker_context_provider = nullptr;
danakjaf3170e2018-02-09 17:31:58[diff] [blame]79};
80
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]81GpuRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
82 GpuRasterBufferProvider* client,
danakjaf3170e2018-02-09 17:31:58[diff] [blame]83 const ResourcePool::InUsePoolResource& in_use_resource,
84 GpuRasterBacking* backing,
Andres Calderon Jaramillob6b26dc2019-11-25 21:24:05[diff] [blame]85 bool resource_has_previous_content,
Andres Calderon Jaramillo5057f232019-11-29 23:05:48[diff] [blame]86 bool depends_on_at_raster_decodes,
87 bool depends_on_hardware_accelerated_jpeg_candidates,
88 bool depends_on_hardware_accelerated_webp_candidates)
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]89 : client_(client),
danakjaf3170e2018-02-09 17:31:58[diff] [blame]90 backing_(backing),
91 resource_size_(in_use_resource.size()),
Colin Blundell1190bd92023-03-21 11:49:05[diff] [blame]92 shared_image_format_(in_use_resource.format()),
danakjaf3170e2018-02-09 17:31:58[diff] [blame]93 color_space_(in_use_resource.color_space()),
94 resource_has_previous_content_(resource_has_previous_content),
Andres Calderon Jaramillob6b26dc2019-11-25 21:24:05[diff] [blame]95 depends_on_at_raster_decodes_(depends_on_at_raster_decodes),
Andres Calderon Jaramillo5057f232019-11-29 23:05:48[diff] [blame]96 depends_on_hardware_accelerated_jpeg_candidates_(
97 depends_on_hardware_accelerated_jpeg_candidates),
98 depends_on_hardware_accelerated_webp_candidates_(
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]99 depends_on_hardware_accelerated_webp_candidates) {
Yuta Hijikata173c7d62020-11-10 06:21:37[diff] [blame]100#if BUILDFLAG(IS_CHROMEOS_ASH)
kylechar14f8d7c02022-01-31 21:41:32[diff] [blame]101 // Only do this in Chrome OS because:
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]102 // 1) We will use this timestamp to measure raster scheduling delay and we
103 // only need to collect that data to assess the impact of hardware
kylechar14f8d7c02022-01-31 21:41:32[diff] [blame]104 // acceleration of image decodes which works only on Chrome OS.
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]105 // 2) We use CLOCK_MONOTONIC in that OS to get timestamps, so we can assert
106 // certain assumptions.
kylechar14f8d7c02022-01-31 21:41:32[diff] [blame]107 creation_time_ = base::TimeTicks::Now();
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]108#endif
109}
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]110
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]111GpuRasterBufferProvider::RasterBufferImpl::~RasterBufferImpl() = default;
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]112
113void GpuRasterBufferProvider::RasterBufferImpl::Playback(
114 const RasterSource* raster_source,
115 const gfx::Rect& raster_full_rect,
116 const gfx::Rect& raster_dirty_rect,
117 uint64_t new_content_id,
trchen178ac912017-04-04 10:11:10[diff] [blame]118 const gfx::AxisTransform2d& transform,
Khushal49836ab2018-07-25 02:08:45[diff] [blame]119 const RasterSource::PlaybackSettings& playback_settings,
120 const GURL& url) {
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]121 TRACE_EVENT0("cc", "GpuRasterBuffer::Playback");
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]122
123 viz::RasterContextProvider::ScopedRasterContextLock scoped_context(
124 client_->worker_context_provider_, url.possibly_invalid_spec().c_str());
125 gpu::raster::RasterInterface* ri =
126 client_->worker_context_provider_->RasterInterface();
127 PlaybackOnWorkerThread(raster_source, raster_full_rect, raster_dirty_rect,
128 new_content_id, transform, playback_settings, url);
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]129
130 backing_->mailbox_sync_token =
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]131 viz::ClientResourceProvider::GenerateSyncTokenHelper(ri);
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]132 backing_->returned_sync_token = gpu::SyncToken();
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]133}
134
Francois Dorayaffe0912020-06-30 20:29:21[diff] [blame]135bool GpuRasterBufferProvider::RasterBufferImpl::
136 SupportsBackgroundThreadPriority() const {
137 return true;
138}
139
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]140GpuRasterBufferProvider::GpuRasterBufferProvider(
kylecharffcf0912023-06-09 18:57:22[diff] [blame]141 viz::RasterContextProvider* compositor_context_provider,
Victor Miura29b7ea3d2017-12-19 20:23:59[diff] [blame]142 viz::RasterContextProvider* worker_context_provider,
kylechar8cce4942023-06-20 18:03:03[diff] [blame]143 const RasterCapabilities& raster_caps,
Eric Karl247f09c2018-03-15 02:06:36[diff] [blame]144 const gfx::Size& max_tile_size,
Eric Karla6ff8862018-04-16 20:21:06[diff] [blame]145 bool unpremultiply_and_dither_low_bit_depth_tiles,
Chris Blumee4d90f2cf2020-11-20 03:50:57[diff] [blame]146 RasterQueryQueue* const pending_raster_queries,
Aaron Krajeski6392a86f2019-07-18 13:40:47[diff] [blame]147 float raster_metric_probability)
danakj0de0c95a2016-05-25 01:42:49[diff] [blame]148 : compositor_context_provider_(compositor_context_provider),
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]149 worker_context_provider_(worker_context_provider),
kylechar8cce4942023-06-20 18:03:03[diff] [blame]150 tile_format_(raster_caps.tile_format),
kylechar58c09f72023-07-11 21:27:34[diff] [blame]151 tile_overlay_candidate_(raster_caps.tile_overlay_candidate),
152 tile_texture_target_(raster_caps.tile_texture_target),
Eric Karl247f09c2018-03-15 02:06:36[diff] [blame]153 max_tile_size_(max_tile_size),
Chris Blumee4d90f2cf2020-11-20 03:50:57[diff] [blame]154 pending_raster_queries_(pending_raster_queries),
Benoit Lize3a2c58f92022-07-05 10:40:44[diff] [blame]155 raster_metric_probability_(raster_metric_probability),
Vasiliy Telezhnikovfa8768c52022-09-23 17:29:44[diff] [blame]156 is_using_raw_draw_(features::IsUsingRawDraw()),
157 is_using_dmsaa_(
158 base::FeatureList::IsEnabled(features::kUseDMSAAForTiles)) {
Chris Blumee4d90f2cf2020-11-20 03:50:57[diff] [blame]159 DCHECK(pending_raster_queries);
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]160 DCHECK(compositor_context_provider);
Vikas Sonid2adcb242023-05-25 23:38:27[diff] [blame]161 CHECK(worker_context_provider);
162
163#if BUILDFLAG(IS_ANDROID)
Vikas Sonid2adcb242023-05-25 23:38:27[diff] [blame]164 {
Arthur Sonzognica067f262023-11-10 14:18:10[diff] [blame]165 std::optional<viz::RasterContextProvider::ScopedRasterContextLock> lock;
Vikas Sonid2adcb242023-05-25 23:38:27[diff] [blame]166 lock.emplace(worker_context_provider);
Vikas Soniff064b02023-09-01 21:50:46[diff] [blame]167 auto is_using_vulkan =
Vikas Sonid2adcb242023-05-25 23:38:27[diff] [blame]168 worker_context_provider->ContextCapabilities().using_vulkan_context;
Vikas Soniff064b02023-09-01 21:50:46[diff] [blame]169
170 // On Android, DMSAA on vulkan backend launch is controlled by
171 // kUseDMSAAForTiles whereas GL backend launch is controlled by
172 // kUseDMSAAForTilesAndroidGL.
173 is_using_dmsaa_ =
174 (base::FeatureList::IsEnabled(features::kUseDMSAAForTiles) &&
175 is_using_vulkan) ||
176 (base::FeatureList::IsEnabled(features::kUseDMSAAForTilesAndroidGL) &&
177 !is_using_vulkan);
Vikas Sonid2adcb242023-05-25 23:38:27[diff] [blame]178 }
179#endif
danakj0de0c95a2016-05-25 01:42:49[diff] [blame]180}
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]181
kylechar14f8d7c02022-01-31 21:41:32[diff] [blame]182GpuRasterBufferProvider::~GpuRasterBufferProvider() = default;
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]183
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]184std::unique_ptr<RasterBuffer> GpuRasterBufferProvider::AcquireBufferForRaster(
danakj4e871d82018-01-18 21:56:57[diff] [blame]185 const ResourcePool::InUsePoolResource& resource,
danakj510822aa2015-06-01 20:23:02[diff] [blame]186 uint64_t resource_content_id,
Andres Calderon Jaramillob6b26dc2019-11-25 21:24:05[diff] [blame]187 uint64_t previous_content_id,
Andres Calderon Jaramillo5057f232019-11-29 23:05:48[diff] [blame]188 bool depends_on_at_raster_decodes,
189 bool depends_on_hardware_accelerated_jpeg_candidates,
190 bool depends_on_hardware_accelerated_webp_candidates) {
danakjaf3170e2018-02-09 17:31:58[diff] [blame]191 if (!resource.gpu_backing()) {
192 auto backing = std::make_unique<GpuRasterBacking>();
Antoine Labour6283c792018-09-27 16:59:28[diff] [blame]193 backing->worker_context_provider = worker_context_provider_;
kylechar58c09f72023-07-11 21:27:34[diff] [blame]194 backing->overlay_candidate = tile_overlay_candidate_;
195 backing->texture_target = tile_texture_target_;
Peng Huanga2a92fe2022-02-08 22:41:30[diff] [blame]196 backing->is_using_raw_draw =
197 !backing->overlay_candidate && is_using_raw_draw_;
danakjaf3170e2018-02-09 17:31:58[diff] [blame]198 resource.set_gpu_backing(std::move(backing));
199 }
200 GpuRasterBacking* backing =
201 static_cast<GpuRasterBacking*>(resource.gpu_backing());
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]202 bool resource_has_previous_content =
203 resource_content_id && resource_content_id == previous_content_id;
Andres Calderon Jaramillo5057f232019-11-29 23:05:48[diff] [blame]204 return std::make_unique<RasterBufferImpl>(
205 this, resource, backing, resource_has_previous_content,
206 depends_on_at_raster_decodes,
207 depends_on_hardware_accelerated_jpeg_candidates,
208 depends_on_hardware_accelerated_webp_candidates);
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]209}
210
Sunny Sachanandani5f5419e22017-05-12 20:35:30[diff] [blame]211void GpuRasterBufferProvider::Flush() {
Victor Miuraff6488612017-12-21 04:16:15[diff] [blame]212 compositor_context_provider_->ContextSupport()->FlushPendingWork();
Sunny Sachanandani5f5419e22017-05-12 20:35:30[diff] [blame]213}
214
Colin Blundell68d83e72023-03-17 07:49:28[diff] [blame]215viz::SharedImageFormat GpuRasterBufferProvider::GetFormat() const {
danakja32578c2018-04-25 21:18:36[diff] [blame]216 return tile_format_;
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]217}
218
danakja32578c2018-04-25 21:18:36[diff] [blame]219bool GpuRasterBufferProvider::IsResourcePremultiplied() const {
Colin Blundell5f231f12023-03-17 13:47:17[diff] [blame]220 return !ShouldUnpremultiplyAndDitherResource(GetFormat());
Eric Karl247f09c2018-03-15 02:06:36[diff] [blame]221}
222
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]223bool GpuRasterBufferProvider::IsResourceReadyToDraw(
Steve Kobesad278432023-07-05 21:35:41[diff] [blame]224 const ResourcePool::InUsePoolResource& resource) {
225 FlushIfNeeded();
danakjaf3170e2018-02-09 17:31:58[diff] [blame]226 const gpu::SyncToken& sync_token = resource.gpu_backing()->mailbox_sync_token;
227 // This SyncToken() should have been set by calling OrderingBarrier() before
228 // calling this.
229 DCHECK(sync_token.HasData());
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]230
sunnyps74996292017-03-15 02:35:48[diff] [blame]231 // IsSyncTokenSignaled is thread-safe, no need for worker context lock.
232 return worker_context_provider_->ContextSupport()->IsSyncTokenSignaled(
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]233 sync_token);
234}
235
Khushalec3ba5dc2019-11-04 22:30:21[diff] [blame]236bool GpuRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
237 return true;
238}
239
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]240uint64_t GpuRasterBufferProvider::SetReadyToDrawCallback(
danakj4e871d82018-01-18 21:56:57[diff] [blame]241 const std::vector<const ResourcePool::InUsePoolResource*>& resources,
kylechar4bb144d2019-01-11 20:42:07[diff] [blame]242 base::OnceClosure callback,
Steve Kobesad278432023-07-05 21:35:41[diff] [blame]243 uint64_t pending_callback_id) {
244 FlushIfNeeded();
danakjaf3170e2018-02-09 17:31:58[diff] [blame]245 gpu::SyncToken latest_sync_token;
246 for (const auto* in_use : resources) {
247 const gpu::SyncToken& sync_token =
248 in_use->gpu_backing()->mailbox_sync_token;
249 if (sync_token.release_count() > latest_sync_token.release_count())
250 latest_sync_token = sync_token;
251 }
252 uint64_t callback_id = latest_sync_token.release_count();
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]253 DCHECK_NE(callback_id, 0u);
254
255 // If the callback is different from the one the caller is already waiting on,
sunnyps31c92fe2017-02-10 23:46:55[diff] [blame]256 // pass the callback through to SignalSyncToken. Otherwise the request is
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]257 // redundant.
258 if (callback_id != pending_callback_id) {
danakjaf3170e2018-02-09 17:31:58[diff] [blame]259 // Use the compositor context because we want this callback on the
260 // compositor thread.
261 compositor_context_provider_->ContextSupport()->SignalSyncToken(
kylechar4bb144d2019-01-11 20:42:07[diff] [blame]262 latest_sync_token, std::move(callback));
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]263 }
264
265 return callback_id;
266}
267
kylechar14f8d7c02022-01-31 21:41:32[diff] [blame]268void GpuRasterBufferProvider::Shutdown() {}
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]269
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]270void GpuRasterBufferProvider::RasterBufferImpl::PlaybackOnWorkerThread(
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]271 const RasterSource* raster_source,
272 const gfx::Rect& raster_full_rect,
273 const gfx::Rect& raster_dirty_rect,
274 uint64_t new_content_id,
trchen178ac912017-04-04 10:11:10[diff] [blame]275 const gfx::AxisTransform2d& transform,
Khushal49836ab2018-07-25 02:08:45[diff] [blame]276 const RasterSource::PlaybackSettings& playback_settings,
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]277 const GURL& url) {
Chris Blumee4d90f2cf2020-11-20 03:50:57[diff] [blame]278 RasterQuery query;
Andres Calderon Jaramillo5057f232019-11-29 23:05:48[diff] [blame]279 query.depends_on_hardware_accelerated_jpeg_candidates =
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]280 depends_on_hardware_accelerated_jpeg_candidates_;
Andres Calderon Jaramillo5057f232019-11-29 23:05:48[diff] [blame]281 query.depends_on_hardware_accelerated_webp_candidates =
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]282 depends_on_hardware_accelerated_webp_candidates_;
283 PlaybackOnWorkerThreadInternal(raster_source, raster_full_rect,
284 raster_dirty_rect, new_content_id, transform,
285 playback_settings, url, &query);
Khushal5d4e0962018-10-18 18:04:07[diff] [blame]286
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]287 if (query.raster_duration_query_id) {
288 if (query.raster_start_query_id)
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]289 query.raster_buffer_creation_time = creation_time_;
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]290
Khushal5d4e0962018-10-18 18:04:07[diff] [blame]291 // Note that it is important to scope the raster context lock to
Chris Blumee4d90f2cf2020-11-20 03:50:57[diff] [blame]292 // PlaybackOnWorkerThreadInternal and release it before calling this
293 // function to avoid a deadlock in
294 // RasterQueryQueue::CheckRasterFinishedQueries which acquires the raster
295 // context lock while holding a lock used in the function.
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]296 client_->pending_raster_queries_->Append(std::move(query));
Khushal5d4e0962018-10-18 18:04:07[diff] [blame]297 }
Khushal5d4e0962018-10-18 18:04:07[diff] [blame]298}
299
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]300void GpuRasterBufferProvider::RasterBufferImpl::PlaybackOnWorkerThreadInternal(
Khushal5d4e0962018-10-18 18:04:07[diff] [blame]301 const RasterSource* raster_source,
302 const gfx::Rect& raster_full_rect,
303 const gfx::Rect& raster_dirty_rect,
304 uint64_t new_content_id,
305 const gfx::AxisTransform2d& transform,
306 const RasterSource::PlaybackSettings& playback_settings,
307 const GURL& url,
Chris Blumee4d90f2cf2020-11-20 03:50:57[diff] [blame]308 RasterQuery* query) {
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]309 gpu::raster::RasterInterface* ri =
310 client_->worker_context_provider_->RasterInterface();
Victor Miura3a4ad4f82017-12-13 06:03:45[diff] [blame]311 DCHECK(ri);
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]312
Benoit Lize3a2c58f92022-07-05 10:40:44[diff] [blame]313 const bool measure_raster_metric = client_->metrics_subsampler_.ShouldSample(
314 client_->raster_metric_probability_);
Khushale898b992018-10-19 22:25:16[diff] [blame]315
Adrienne Walker436a7752017-08-28 23:33:09[diff] [blame]316 gfx::Rect playback_rect = raster_full_rect;
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]317 if (resource_has_previous_content_) {
Adrienne Walker436a7752017-08-28 23:33:09[diff] [blame]318 playback_rect.Intersect(raster_dirty_rect);
319 }
320 DCHECK(!playback_rect.IsEmpty())
321 << "Why are we rastering a tile that's not dirty?";
322
Khushale898b992018-10-19 22:25:16[diff] [blame]323 if (measure_raster_metric) {
Yuta Hijikata173c7d62020-11-10 06:21:37[diff] [blame]324#if BUILDFLAG(IS_CHROMEOS_ASH)
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]325 // Use a query to detect when the GPU side is ready to start issuing raster
326 // work to the driver. We will use the resulting timestamp to measure raster
kylechar14f8d7c02022-01-31 21:41:32[diff] [blame]327 // scheduling delay. We only care about this in Chrome OS because we will
328 // use this timestamp to measure raster scheduling delay and we only need to
329 // collect that data to assess the impact of hardware acceleration of image
330 // decodes which work only in Chrome OS. Furthermore, we don't count raster
331 // work that depends on at-raster image decodes. This is because we want the
332 // delay to always include image decoding and uploading time, and at-raster
333 // decodes should be relatively rare.
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]334 if (!depends_on_at_raster_decodes_) {
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]335 ri->GenQueriesEXT(1, &query->raster_start_query_id);
336 DCHECK_GT(query->raster_start_query_id, 0u);
337 ri->QueryCounterEXT(query->raster_start_query_id,
338 GL_COMMANDS_ISSUED_TIMESTAMP_CHROMIUM);
339 }
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]340#else
341 std::ignore = depends_on_at_raster_decodes_;
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]342#endif
Andres Calderon Jaramillob805fa82019-08-24 05:58:19[diff] [blame]343
344 // Use a query to time the GPU side work for rasterizing this tile.
345 ri->GenQueriesEXT(1, &query->raster_duration_query_id);
346 DCHECK_GT(query->raster_duration_query_id, 0u);
347 ri->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM,
348 query->raster_duration_query_id);
Khushale898b992018-10-19 22:25:16[diff] [blame]349 }
Khushalcd8fbb772018-10-16 22:46:14[diff] [blame]350
351 {
Arthur Sonzognica067f262023-11-10 14:18:10[diff] [blame]352 std::optional<base::ElapsedTimer> timer;
Khushale898b992018-10-19 22:25:16[diff] [blame]353 if (measure_raster_metric)
354 timer.emplace();
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]355 RasterizeSource(raster_source, raster_full_rect, playback_rect, transform,
356 playback_settings);
Andres Calderon Jaramillo01d329552019-08-23 17:14:30[diff] [blame]357 if (measure_raster_metric) {
358 query->worker_raster_duration = timer->Elapsed();
359 ri->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
360 }
Adrienne Walker436a7752017-08-28 23:33:09[diff] [blame]361 }
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]362}
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]363
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]364void GpuRasterBufferProvider::RasterBufferImpl::RasterizeSource(
365 const RasterSource* raster_source,
366 const gfx::Rect& raster_full_rect,
367 const gfx::Rect& playback_rect,
368 const gfx::AxisTransform2d& transform,
369 const RasterSource::PlaybackSettings& playback_settings) {
370 gpu::raster::RasterInterface* ri =
371 client_->worker_context_provider_->RasterInterface();
372 bool mailbox_needs_clear = false;
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]373 if (!backing_->shared_image) {
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]374 DCHECK(!backing_->returned_sync_token.HasData());
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]375 auto* sii = client_->worker_context_provider_->SharedImageInterface();
Colin Blundellf0af2a22024-01-31 17:15:04[diff] [blame]376
377 // This SharedImage will serve as the destination of the raster defined by
378 // `raster_source` before being sent off to the display compositor.
Michael Tang82400382022-10-03 20:22:13[diff] [blame]379 uint32_t flags = gpu::SHARED_IMAGE_USAGE_DISPLAY_READ |
Colin Blundella7afe1b2024-01-17 17:38:46[diff] [blame]380 gpu::SHARED_IMAGE_USAGE_RASTER_WRITE |
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]381 gpu::SHARED_IMAGE_USAGE_OOP_RASTERIZATION;
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]382 if (backing_->overlay_candidate) {
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]383 flags |= gpu::SHARED_IMAGE_USAGE_SCANOUT;
Maksim Sisov4dc61a12022-03-23 15:09:26[diff] [blame]384 if (features::IsDelegatedCompositingEnabled())
385 flags |= gpu::SHARED_IMAGE_USAGE_RASTER_DELEGATED_COMPOSITING;
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]386 } else if (client_->is_using_raw_draw_) {
387 flags |= gpu::SHARED_IMAGE_USAGE_RAW_DRAW;
388 }
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]389 backing_->shared_image = sii->CreateSharedImage(
Colin Blundellfd033e92023-02-16 08:16:58[diff] [blame]390 shared_image_format_, resource_size_, color_space_,
Rafael Cintronde3d9b82023-04-19 20:19:28[diff] [blame]391 kTopLeft_GrSurfaceOrigin, kPremul_SkAlphaType, flags, "GpuRasterTile",
Colin Blundellfd033e92023-02-16 08:16:58[diff] [blame]392 gpu::kNullSurfaceHandle);
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]393 CHECK(backing_->shared_image);
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]394 mailbox_needs_clear = true;
395 ri->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData());
396 } else {
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]397 ri->WaitSyncTokenCHROMIUM(backing_->returned_sync_token.GetConstData());
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]398 }
399
400 // Assume legacy MSAA if sample count is positive.
Vasiliy Telezhnikovfa8768c52022-09-23 17:29:44[diff] [blame]401 gpu::raster::MsaaMode msaa_mode =
402 playback_settings.msaa_sample_count > 0
403 ? (client_->is_using_dmsaa_ ? gpu::raster::kDMSAA
404 : gpu::raster::kMSAA)
405 : gpu::raster::kNoMSAA;
Peng Huangacb64c02022-02-28 20:36:44[diff] [blame]406 // msaa_sample_count should be 1, 2, 4, 8, 16, 32, 64,
407 // and log2(msaa_sample_count) should be [0,6].
408 // If playback_settings.msaa_sample_count <= 0, the MSAA is not used. It is
409 // equivalent to MSAA sample count 1.
410 uint32_t sample_count =
Ho Cheungd90e2ff2023-04-22 18:48:37[diff] [blame]411 std::clamp(playback_settings.msaa_sample_count, 1, 64);
Peng Huangacb64c02022-02-28 20:36:44[diff] [blame]412 UMA_HISTOGRAM_CUSTOM_COUNTS("Gpu.Rasterization.Raster.MSAASampleCountLog2",
Avi Drissmanb696fbf2023-12-04 22:54:24[diff] [blame]413 std::bit_width(sample_count) - 1, 0, 7, 7);
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]414 // With Raw Draw, the framebuffer will be the rasterization target. It cannot
415 // support LCD text, so disable LCD text for Raw Draw backings.
Kevin Lubick64006972023-06-09 20:47:34[diff] [blame]416 // TODO(penghuang): remove it when sktext::gpu::Slug can be serialized.
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]417 bool is_raw_draw_backing =
Peng Huang253518e2022-02-09 14:08:32[diff] [blame]418 client_->is_using_raw_draw_ && !backing_->overlay_candidate;
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]419 bool use_lcd_text = playback_settings.use_lcd_text && !is_raw_draw_backing;
Aaron Krajeskid7d51a52022-05-25 13:29:09[diff] [blame]420
Peng Huang5ff70dff2022-03-03 19:55:11[diff] [blame]421 ri->BeginRasterCHROMIUM(
Aaron Krajeskid7d51a52022-05-25 13:29:09[diff] [blame]422 raster_source->background_color(), mailbox_needs_clear,
Peng Huang5ff70dff2022-03-03 19:55:11[diff] [blame]423 playback_settings.msaa_sample_count, msaa_mode, use_lcd_text,
Christopher Cameron060d382e72023-10-04 23:12:42[diff] [blame]424 playback_settings.visible, color_space_, playback_settings.hdr_headroom,
Mingjing Zhang9a99ee42023-11-22 16:23:19[diff] [blame]425 backing_->shared_image->mailbox().name);
Aaron Krajeskid7d51a52022-05-25 13:29:09[diff] [blame]426
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]427 gfx::Vector2dF recording_to_raster_scale = transform.scale();
Ramy El Garawany09579a8c2022-09-16 03:03:48[diff] [blame]428 recording_to_raster_scale.InvScale(raster_source->recording_scale_factor());
Peng Huangb79a26452022-02-07 15:53:51[diff] [blame]429 gfx::Size content_size = raster_source->GetContentSize(transform.scale());
430
431 // TODO(enne): could skip the clear on new textures, as the service side has
432 // to do that anyway. resource_has_previous_content implies that the texture
433 // is not new, but the reverse does not hold, so more plumbing is needed.
434 ri->RasterCHROMIUM(
435 raster_source->GetDisplayItemList().get(),
436 playback_settings.image_provider, content_size, raster_full_rect,
437 playback_rect, transform.translation(), recording_to_raster_scale,
438 raster_source->requires_clear(),
439 const_cast<RasterSource*>(raster_source)->max_op_size_hint());
440 ri->EndRasterCHROMIUM();
441
442 // TODO(ericrk): Handle unpremultiply+dither for 4444 cases.
443 // https://crbug.com/789153
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]444}
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]445
Eric Karla6ff8862018-04-16 20:21:06[diff] [blame]446bool GpuRasterBufferProvider::ShouldUnpremultiplyAndDitherResource(
Colin Blundell5f231f12023-03-17 13:47:17[diff] [blame]447 viz::SharedImageFormat format) const {
Khushal8a168082020-11-21 01:29:34[diff] [blame]448 // TODO(crbug.com/1151490): Re-enable for OOPR.
449 return false;
Eric Karla6ff8862018-04-16 20:21:06[diff] [blame]450}
451
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]452} // namespace cc