File: graphite_precompile.cc

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (385 lines) | stat: -rw-r--r-- 15,821 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
// Copyright 2025 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/*
 * This file is, almost entirely, copy and pasted from Skia's
 * ChromePrecompileTest.cpp and then massaged to better match Chrome's coding
 * standard. Almost any change to this file should first be performed in the
 * Skia file and then copied here.
 */

#include "gpu/command_buffer/service/graphite_precompile.h"

#include "third_party/skia/include/gpu/graphite/PrecompileContext.h"
#include "third_party/skia/include/gpu/graphite/precompile/PaintOptions.h"
#include "third_party/skia/include/gpu/graphite/precompile/Precompile.h"
#include "third_party/skia/include/gpu/graphite/precompile/PrecompileColorFilter.h"
#include "third_party/skia/include/gpu/graphite/precompile/PrecompileShader.h"

namespace gpu {
namespace {

using ::skgpu::graphite::PrecompileShaders::GradientShaderFlags;
using ::skgpu::graphite::PrecompileShaders::ImageShaderFlags;
using ::skgpu::graphite::PrecompileShaders::YUVImageShaderFlags;

using ::skgpu::graphite::DepthStencilFlags;
using ::skgpu::graphite::DrawTypeFlags;
using ::skgpu::graphite::PaintOptions;
using ::skgpu::graphite::RenderPassProperties;

PaintOptions solid_srcover() {
  PaintOptions paintOptions;
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions linear_grad_sm_srcover() {
  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::LinearGradient(
      GradientShaderFlags::kSmall)});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions linear_grad_SRGB_sm_med_srcover() {
  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::LinearGradient(
      GradientShaderFlags::kNoLarge,
      {SkGradientShader::Interpolation::InPremul::kNo,
       SkGradientShader::Interpolation::ColorSpace::kSRGB,
       SkGradientShader::Interpolation::HueMethod::kShorter})});

  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  paintOptions.setDither(true);

  return paintOptions;
}

PaintOptions xparent_paint_image_premul_hw_and_clamp_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  SkTileMode tm = SkTileMode::kClamp;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {&tm, 1})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  paintOptions.setPaintColorIsOpaque(false);
  return paintOptions;
}

PaintOptions xparent_paint_image_premul_hw_only_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  paintOptions.setPaintColorIsOpaque(false);
  return paintOptions;
}

PaintOptions xparent_paint_srcover() {
  PaintOptions paintOptions;

  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  paintOptions.setPaintColorIsOpaque(false);
  return paintOptions;
}

PaintOptions solid_clear_src_srcover() {
  PaintOptions paintOptions;
  paintOptions.setBlendModes(
      {SkBlendMode::kClear, SkBlendMode::kSrc, SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions solid_src_srcover() {
  PaintOptions paintOptions;
  paintOptions.setBlendModes({SkBlendMode::kSrc, SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_premul_no_cubic_srcover() {
  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  SkTileMode tm = SkTileMode::kClamp;
  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {&tm, 1})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_premul_hw_only_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_premul_clamp_no_cubic_dstin() {
  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  SkTileMode tm = SkTileMode::kClamp;
  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {&tm, 1})});
  paintOptions.setBlendModes({SkBlendMode::kDstIn});
  return paintOptions;
}

PaintOptions image_premul_hw_only_dstin() {
  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setBlendModes({SkBlendMode::kDstIn});
  return paintOptions;
}

PaintOptions yuv_image_srgb_no_cubic_srcover() {
  SkColorInfo ci{
      kRGBA_8888_SkColorType, kPremul_SkAlphaType,
      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB)};

  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::YUVImage(
      YUVImageShaderFlags::kExcludeCubic, {&ci, 1})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions yuv_image_srgb_srcover2() {
  SkColorInfo ci{
      kRGBA_8888_SkColorType, kPremul_SkAlphaType,
      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB)};

  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::YUVImage(
      YUVImageShaderFlags::kNoCubicNoNonSwizzledHW, {&ci, 1})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_premul_no_cubic_src_srcover() {
  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  PaintOptions paintOptions;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setBlendModes({SkBlendMode::kSrc, SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_srgb_no_cubic_src() {
  PaintOptions paintOptions;

  SkColorInfo ci{
      kRGBA_8888_SkColorType, kPremul_SkAlphaType,
      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB)};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setBlendModes({SkBlendMode::kSrc});
  return paintOptions;
}

PaintOptions blend_porter_duff_cf_srcover() {
  PaintOptions paintOptions;
  // kSrcOver will trigger the PorterDuffBlender
  paintOptions.setColorFilters(
      {::skgpu::graphite::PrecompileColorFilters::Blend(
          {SkBlendMode::kSrcOver})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});

  return paintOptions;
}

PaintOptions image_alpha_hw_only_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{kAlpha_8_SkColorType, kUnpremul_SkAlphaType, nullptr};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_alpha_no_cubic_src() {
  PaintOptions paintOptions;

  SkColorInfo ci{kAlpha_8_SkColorType, kUnpremul_SkAlphaType, nullptr};
  SkTileMode tm = SkTileMode::kRepeat;
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {&tm, 1})});
  paintOptions.setBlendModes({SkBlendMode::kSrc});
  return paintOptions;
}

PaintOptions image_premul_hw_only_porter_duff_cf_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setColorFilters(
      {::skgpu::graphite::PrecompileColorFilters::Blend(
          {SkBlendMode::kSrcOver})});

  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_premul_hw_only_matrix_cf_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});
  paintOptions.setColorFilters(
      {::skgpu::graphite::PrecompileColorFilters::Matrix()});

  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

PaintOptions image_hw_only_srgb_srcover() {
  PaintOptions paintOptions;

  SkColorInfo ci{
      kRGBA_8888_SkColorType, kPremul_SkAlphaType,
      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB)};
  paintOptions.setShaders({::skgpu::graphite::PrecompileShaders::Image(
      ImageShaderFlags::kExcludeCubic, {&ci, 1}, {})});

  paintOptions.setBlendModes({SkBlendMode::kSrcOver});
  return paintOptions;
}

}  // anonymous namespace

void GraphitePerformPrecompilation(
    std::unique_ptr<skgpu::graphite::PrecompileContext> precompileContext) {
  // Single sampled R w/ just depth
  const RenderPassProperties kR_1_D{DepthStencilFlags::kDepth,
                                    kAlpha_8_SkColorType,
                                    /* fDstCS= */ nullptr,
                                    /* fRequiresMSAA= */ false};

  // MSAA R w/ depth and stencil
  const RenderPassProperties kR_4_DS{DepthStencilFlags::kDepthStencil,
                                     kAlpha_8_SkColorType,
                                     /* fDstCS= */ nullptr,
                                     /* fRequiresMSAA= */ true};

  // Single sampled BGRA w/ just depth
  const RenderPassProperties kBGRA_1_D{DepthStencilFlags::kDepth,
                                       kBGRA_8888_SkColorType,
                                       /* fDstCS= */ nullptr,
                                       /* fRequiresMSAA= */ false};

  // MSAA BGRA w/ just depth
  const RenderPassProperties kBGRA_4_D{DepthStencilFlags::kDepth,
                                       kBGRA_8888_SkColorType,
                                       /* fDstCS= */ nullptr,
                                       /* fRequiresMSAA= */ true};

  // MSAA BGRA w/ depth and stencil
  const RenderPassProperties kBGRA_4_DS{DepthStencilFlags::kDepthStencil,
                                        kBGRA_8888_SkColorType,
                                        /* fDstCS= */ nullptr,
                                        /* fRequiresMSAA= */ true};

  // The same as kBGRA_1_D but w/ an SRGB colorSpace
  const RenderPassProperties kBGRA_1_D_SRGB{DepthStencilFlags::kDepth,
                                            kBGRA_8888_SkColorType,
                                            SkColorSpace::MakeSRGB(),
                                            /* fRequiresMSAA= */ false};

  // The same as kBGRA_1_D but w/ an Adobe RGB colorSpace
  const RenderPassProperties kBGRA_1_D_Adobe{
      DepthStencilFlags::kDepth, kBGRA_8888_SkColorType,
      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB),
      /* fRequiresMSAA= */ false};

  // The same as kBGRA_4_DS but w/ an SRGB colorSpace
  const RenderPassProperties kBGRA_4_DS_SRGB{DepthStencilFlags::kDepthStencil,
                                             kBGRA_8888_SkColorType,
                                             SkColorSpace::MakeSRGB(),
                                             /* fRequiresMSAA= */ true};

  // The same as kBGRA_4_DS but w/ an Adobe RGB colorSpace
  const RenderPassProperties kBGRA_4_DS_Adobe{
      DepthStencilFlags::kDepthStencil, kBGRA_8888_SkColorType,
      SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB),
      /* fRequiresMSAA= */ true};

  constexpr DrawTypeFlags kRRectAndNonAARect = static_cast<DrawTypeFlags>(
      DrawTypeFlags::kAnalyticRRect | DrawTypeFlags::kNonAAFillRect);
  constexpr DrawTypeFlags kQuadAndNonAARect = static_cast<DrawTypeFlags>(
      DrawTypeFlags::kPerEdgeAAQuad | DrawTypeFlags::kNonAAFillRect);

  const struct PrecompileSettings {
    PaintOptions fPaintOptions;
    DrawTypeFlags fDrawTypeFlags = DrawTypeFlags::kNone;
    RenderPassProperties fRenderPassProps;
  } kPrecompileCases[] = {
      {blend_porter_duff_cf_srcover(), DrawTypeFlags::kBitmapText_Mask,
       kBGRA_1_D},
      {solid_srcover(), DrawTypeFlags::kBitmapText_Mask, kBGRA_1_D},
      {solid_srcover(), DrawTypeFlags::kBitmapText_Mask, kBGRA_4_D},
      {solid_srcover(), DrawTypeFlags::kBitmapText_Mask, kBGRA_4_DS},
      {linear_grad_sm_srcover(), DrawTypeFlags::kBitmapText_Mask, kBGRA_4_DS},
      {blend_porter_duff_cf_srcover(), DrawTypeFlags::kBitmapText_Mask,
       kBGRA_4_DS},
      {xparent_paint_srcover(), DrawTypeFlags::kBitmapText_Color, kBGRA_1_D},
      {solid_srcover(), DrawTypeFlags::kBitmapText_Color, kBGRA_1_D_Adobe},
      {solid_srcover(), DrawTypeFlags::kBitmapText_Color, kBGRA_4_DS_Adobe},
      {solid_srcover(), kRRectAndNonAARect, kR_1_D},
      {image_alpha_hw_only_srcover(), DrawTypeFlags::kPerEdgeAAQuad, kR_1_D},
      {image_alpha_no_cubic_src(), DrawTypeFlags::kNonAAFillRect, kR_1_D},
      {image_premul_clamp_no_cubic_dstin(), kQuadAndNonAARect, kBGRA_1_D},
      {image_premul_hw_only_matrix_cf_srcover(), DrawTypeFlags::kNonAAFillRect,
       kBGRA_1_D},
      {image_premul_hw_only_porter_duff_cf_srcover(),
       DrawTypeFlags::kPerEdgeAAQuad, kBGRA_1_D},
      {image_premul_no_cubic_srcover(), DrawTypeFlags::kAnalyticRRect,
       kBGRA_1_D},
      {image_premul_no_cubic_src_srcover(), kQuadAndNonAARect, kBGRA_1_D},
      {linear_grad_sm_srcover(), DrawTypeFlags::kNonAAFillRect, kBGRA_1_D},
      {solid_src_srcover(), DrawTypeFlags::kSimpleShape, kBGRA_1_D},
      {xparent_paint_image_premul_hw_and_clamp_srcover(), kQuadAndNonAARect,
       kBGRA_1_D},
      {linear_grad_SRGB_sm_med_srcover(), kRRectAndNonAARect, kBGRA_1_D_Adobe},
      {image_hw_only_srgb_srcover(), kRRectAndNonAARect, kBGRA_1_D_SRGB},
      {image_srgb_no_cubic_src(), kQuadAndNonAARect, kBGRA_1_D_SRGB},
      {yuv_image_srgb_no_cubic_srcover(), DrawTypeFlags::kSimpleShape,
       kBGRA_1_D_SRGB},
      {image_premul_hw_only_dstin(), DrawTypeFlags::kPerEdgeAAQuad, kBGRA_4_D},
      {image_premul_hw_only_srcover(), kQuadAndNonAARect, kBGRA_4_D},
      {solid_src_srcover(), kRRectAndNonAARect, kBGRA_4_D},
      {blend_porter_duff_cf_srcover(), DrawTypeFlags::kNonAAFillRect,
       kBGRA_4_DS},
      {image_premul_hw_only_dstin(), DrawTypeFlags::kPerEdgeAAQuad, kBGRA_4_DS},
      {image_premul_hw_only_matrix_cf_srcover(), DrawTypeFlags::kNonAAFillRect,
       kBGRA_4_DS},
      {image_premul_no_cubic_srcover(), kQuadAndNonAARect, kBGRA_4_DS},
      {solid_clear_src_srcover(), DrawTypeFlags::kNonAAFillRect, kBGRA_4_DS},
      {solid_srcover(), DrawTypeFlags::kNonSimpleShape, kBGRA_4_DS},
      {solid_srcover(), DrawTypeFlags::kAnalyticRRect, kBGRA_4_DS},
      {xparent_paint_image_premul_hw_only_srcover(),
       DrawTypeFlags::kPerEdgeAAQuad, kBGRA_4_DS},
      {linear_grad_SRGB_sm_med_srcover(), kRRectAndNonAARect, kBGRA_4_DS_Adobe},
      {image_hw_only_srgb_srcover(), DrawTypeFlags::kAnalyticRRect,
       kBGRA_4_DS_SRGB},
      {yuv_image_srgb_srcover2(), DrawTypeFlags::kSimpleShape, kBGRA_4_DS_SRGB},
  };

  for (const auto& c : kPrecompileCases) {
    Precompile(precompileContext.get(), c.fPaintOptions, c.fDrawTypeFlags,
               {&c.fRenderPassProps, 1});
  }
}

}  // namespace gpu