1 /*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "src/core/SkColorSpacePriv.h"
9 #include "src/core/SkOpts.h"
10 #include "src/core/SkRasterPipeline.h"
11 #include <algorithm>
12
SkRasterPipeline(SkArenaAlloc * alloc)13 SkRasterPipeline::SkRasterPipeline(SkArenaAlloc* alloc) : fAlloc(alloc) {
14 this->reset();
15 }
reset()16 void SkRasterPipeline::reset() {
17 fStages = nullptr;
18 fNumStages = 0;
19 fSlotsNeeded = 1; // We always need one extra slot for just_return().
20 }
21
append(StockStage stage,void * ctx)22 void SkRasterPipeline::append(StockStage stage, void* ctx) {
23 SkASSERT(stage != uniform_color); // Please use append_constant_color().
24 SkASSERT(stage != unbounded_uniform_color); // Please use append_constant_color().
25 SkASSERT(stage != set_rgb); // Please use append_set_rgb().
26 SkASSERT(stage != unbounded_set_rgb); // Please use append_set_rgb().
27 SkASSERT(stage != clamp_gamut); // Please use append_gamut_clamp_if_normalized().
28 SkASSERT(stage != parametric); // Please use append_transfer_function().
29 SkASSERT(stage != gamma_); // Please use append_transfer_function().
30 SkASSERT(stage != PQish); // Please use append_transfer_function().
31 SkASSERT(stage != HLGish); // Please use append_transfer_function().
32 SkASSERT(stage != HLGinvish); // Please use append_transfer_function().
33 this->unchecked_append(stage, ctx);
34 }
unchecked_append(StockStage stage,void * ctx)35 void SkRasterPipeline::unchecked_append(StockStage stage, void* ctx) {
36 fStages = fAlloc->make<StageList>( StageList{fStages, stage, ctx} );
37 fNumStages += 1;
38 fSlotsNeeded += ctx ? 2 : 1;
39 }
append(StockStage stage,uintptr_t ctx)40 void SkRasterPipeline::append(StockStage stage, uintptr_t ctx) {
41 void* ptrCtx;
42 memcpy(&ptrCtx, &ctx, sizeof(ctx));
43 this->append(stage, ptrCtx);
44 }
45
extend(const SkRasterPipeline & src)46 void SkRasterPipeline::extend(const SkRasterPipeline& src) {
47 if (src.empty()) {
48 return;
49 }
50 auto stages = fAlloc->makeArrayDefault<StageList>(src.fNumStages);
51
52 int n = src.fNumStages;
53 const StageList* st = src.fStages;
54 while (n --> 1) {
55 stages[n] = *st;
56 stages[n].prev = &stages[n-1];
57 st = st->prev;
58 }
59 stages[0] = *st;
60 stages[0].prev = fStages;
61
62 fStages = &stages[src.fNumStages - 1];
63 fNumStages += src.fNumStages;
64 fSlotsNeeded += src.fSlotsNeeded - 1; // Don't double count just_returns().
65 }
66
dump() const67 void SkRasterPipeline::dump() const {
68 SkDebugf("SkRasterPipeline, %d stages\n", fNumStages);
69 std::vector<const char*> stages;
70 for (auto st = fStages; st; st = st->prev) {
71 const char* name = "";
72 switch (st->stage) {
73 #define M(x) case x: name = #x; break;
74 SK_RASTER_PIPELINE_STAGES(M)
75 #undef M
76 }
77 stages.push_back(name);
78 }
79 std::reverse(stages.begin(), stages.end());
80 for (const char* name : stages) {
81 SkDebugf("\t%s\n", name);
82 }
83 SkDebugf("\n");
84 }
85
append_set_rgb(SkArenaAlloc * alloc,const float rgb[3])86 void SkRasterPipeline::append_set_rgb(SkArenaAlloc* alloc, const float rgb[3]) {
87 auto arg = alloc->makeArrayDefault<float>(3);
88 arg[0] = rgb[0];
89 arg[1] = rgb[1];
90 arg[2] = rgb[2];
91
92 auto stage = unbounded_set_rgb;
93 if (0 <= rgb[0] && rgb[0] <= 1 &&
94 0 <= rgb[1] && rgb[1] <= 1 &&
95 0 <= rgb[2] && rgb[2] <= 1)
96 {
97 stage = set_rgb;
98 }
99
100 this->unchecked_append(stage, arg);
101 }
102
append_constant_color(SkArenaAlloc * alloc,const float rgba[4])103 void SkRasterPipeline::append_constant_color(SkArenaAlloc* alloc, const float rgba[4]) {
104 // r,g,b might be outside [0,1], but alpha should probably always be in [0,1].
105 SkASSERT(0 <= rgba[3] && rgba[3] <= 1);
106
107 if (rgba[0] == 0 && rgba[1] == 0 && rgba[2] == 0 && rgba[3] == 1) {
108 this->append(black_color);
109 } else if (rgba[0] == 1 && rgba[1] == 1 && rgba[2] == 1 && rgba[3] == 1) {
110 this->append(white_color);
111 } else {
112 auto ctx = alloc->make<SkRasterPipeline_UniformColorCtx>();
113 Sk4f color = Sk4f::Load(rgba);
114 color.store(&ctx->r);
115
116 // uniform_color requires colors in range and can go lowp,
117 // while unbounded_uniform_color supports out-of-range colors too but not lowp.
118 if (0 <= rgba[0] && rgba[0] <= rgba[3] &&
119 0 <= rgba[1] && rgba[1] <= rgba[3] &&
120 0 <= rgba[2] && rgba[2] <= rgba[3]) {
121 // To make loads more direct, we store 8-bit values in 16-bit slots.
122 color = color * 255.0f + 0.5f;
123 ctx->rgba[0] = (uint16_t)color[0];
124 ctx->rgba[1] = (uint16_t)color[1];
125 ctx->rgba[2] = (uint16_t)color[2];
126 ctx->rgba[3] = (uint16_t)color[3];
127 this->unchecked_append(uniform_color, ctx);
128 } else {
129 this->unchecked_append(unbounded_uniform_color, ctx);
130 }
131 }
132 }
133
append_matrix(SkArenaAlloc * alloc,const SkMatrix & matrix)134 void SkRasterPipeline::append_matrix(SkArenaAlloc* alloc, const SkMatrix& matrix) {
135 SkMatrix::TypeMask mt = matrix.getType();
136
137 if (mt == SkMatrix::kIdentity_Mask) {
138 return;
139 }
140 if (mt == SkMatrix::kTranslate_Mask) {
141 float* trans = alloc->makeArrayDefault<float>(2);
142 trans[0] = matrix.getTranslateX();
143 trans[1] = matrix.getTranslateY();
144 this->append(SkRasterPipeline::matrix_translate, trans);
145 } else if ((mt | (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) ==
146 (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
147 float* scaleTrans = alloc->makeArrayDefault<float>(4);
148 scaleTrans[0] = matrix.getScaleX();
149 scaleTrans[1] = matrix.getScaleY();
150 scaleTrans[2] = matrix.getTranslateX();
151 scaleTrans[3] = matrix.getTranslateY();
152 this->append(SkRasterPipeline::matrix_scale_translate, scaleTrans);
153 } else {
154 float* storage = alloc->makeArrayDefault<float>(9);
155 if (matrix.asAffine(storage)) {
156 // note: asAffine and the 2x3 stage really only need 6 entries
157 this->append(SkRasterPipeline::matrix_2x3, storage);
158 } else {
159 matrix.get9(storage);
160 this->append(SkRasterPipeline::matrix_perspective, storage);
161 }
162 }
163 }
164
append_load(SkColorType ct,const SkRasterPipeline_MemoryCtx * ctx)165 void SkRasterPipeline::append_load(SkColorType ct, const SkRasterPipeline_MemoryCtx* ctx) {
166 switch (ct) {
167 case kUnknown_SkColorType: SkASSERT(false); break;
168
169 case kAlpha_8_SkColorType: this->append(load_a8, ctx); break;
170 case kA16_unorm_SkColorType: this->append(load_a16, ctx); break;
171 case kA16_float_SkColorType: this->append(load_af16, ctx); break;
172 case kRGB_565_SkColorType: this->append(load_565, ctx); break;
173 case kARGB_4444_SkColorType: this->append(load_4444, ctx); break;
174 case kR8G8_unorm_SkColorType: this->append(load_rg88, ctx); break;
175 case kR16G16_unorm_SkColorType: this->append(load_rg1616, ctx); break;
176 case kR16G16_float_SkColorType: this->append(load_rgf16, ctx); break;
177 case kRGBA_8888_SkColorType: this->append(load_8888, ctx); break;
178 case kRGBA_1010102_SkColorType: this->append(load_1010102, ctx); break;
179 case kR16G16B16A16_unorm_SkColorType:this->append(load_16161616,ctx); break;
180 case kRGBA_F16Norm_SkColorType:
181 case kRGBA_F16_SkColorType: this->append(load_f16, ctx); break;
182 case kRGBA_F32_SkColorType: this->append(load_f32, ctx); break;
183
184 case kGray_8_SkColorType: this->append(load_a8, ctx);
185 this->append(alpha_to_gray);
186 break;
187
188 case kRGB_888x_SkColorType: this->append(load_8888, ctx);
189 this->append(force_opaque);
190 break;
191
192 case kRGB_101010x_SkColorType: this->append(load_1010102, ctx);
193 this->append(force_opaque);
194 break;
195
196 case kBGRA_8888_SkColorType: this->append(load_8888, ctx);
197 this->append(swap_rb);
198 break;
199 }
200 }
201
append_load_dst(SkColorType ct,const SkRasterPipeline_MemoryCtx * ctx)202 void SkRasterPipeline::append_load_dst(SkColorType ct, const SkRasterPipeline_MemoryCtx* ctx) {
203 switch (ct) {
204 case kUnknown_SkColorType: SkASSERT(false); break;
205
206 case kAlpha_8_SkColorType: this->append(load_a8_dst, ctx); break;
207 case kA16_unorm_SkColorType: this->append(load_a16_dst, ctx); break;
208 case kA16_float_SkColorType: this->append(load_af16_dst, ctx); break;
209 case kRGB_565_SkColorType: this->append(load_565_dst, ctx); break;
210 case kARGB_4444_SkColorType: this->append(load_4444_dst, ctx); break;
211 case kR8G8_unorm_SkColorType: this->append(load_rg88_dst, ctx); break;
212 case kR16G16_unorm_SkColorType: this->append(load_rg1616_dst, ctx); break;
213 case kR16G16_float_SkColorType: this->append(load_rgf16_dst, ctx); break;
214 case kRGBA_8888_SkColorType: this->append(load_8888_dst, ctx); break;
215 case kRGBA_1010102_SkColorType: this->append(load_1010102_dst, ctx); break;
216 case kR16G16B16A16_unorm_SkColorType: this->append(load_16161616_dst,ctx); break;
217 case kRGBA_F16Norm_SkColorType:
218 case kRGBA_F16_SkColorType: this->append(load_f16_dst, ctx); break;
219 case kRGBA_F32_SkColorType: this->append(load_f32_dst, ctx); break;
220
221 case kGray_8_SkColorType: this->append(load_a8_dst, ctx);
222 this->append(alpha_to_gray_dst);
223 break;
224
225 case kRGB_888x_SkColorType: this->append(load_8888_dst, ctx);
226 this->append(force_opaque_dst);
227 break;
228
229 case kRGB_101010x_SkColorType: this->append(load_1010102_dst, ctx);
230 this->append(force_opaque_dst);
231 break;
232
233 case kBGRA_8888_SkColorType: this->append(load_8888_dst, ctx);
234 this->append(swap_rb_dst);
235 break;
236 }
237 }
238
append_store(SkColorType ct,const SkRasterPipeline_MemoryCtx * ctx)239 void SkRasterPipeline::append_store(SkColorType ct, const SkRasterPipeline_MemoryCtx* ctx) {
240 switch (ct) {
241 case kUnknown_SkColorType: SkASSERT(false); break;
242
243 case kAlpha_8_SkColorType: this->append(store_a8, ctx); break;
244 case kA16_unorm_SkColorType: this->append(store_a16, ctx); break;
245 case kA16_float_SkColorType: this->append(store_af16, ctx); break;
246 case kRGB_565_SkColorType: this->append(store_565, ctx); break;
247 case kARGB_4444_SkColorType: this->append(store_4444, ctx); break;
248 case kR8G8_unorm_SkColorType: this->append(store_rg88, ctx); break;
249 case kR16G16_unorm_SkColorType: this->append(store_rg1616, ctx); break;
250 case kR16G16_float_SkColorType: this->append(store_rgf16, ctx); break;
251 case kRGBA_8888_SkColorType: this->append(store_8888, ctx); break;
252 case kRGBA_1010102_SkColorType: this->append(store_1010102, ctx); break;
253 case kR16G16B16A16_unorm_SkColorType: this->append(store_16161616,ctx); break;
254 case kRGBA_F16Norm_SkColorType:
255 case kRGBA_F16_SkColorType: this->append(store_f16, ctx); break;
256 case kRGBA_F32_SkColorType: this->append(store_f32, ctx); break;
257
258 case kRGB_888x_SkColorType: this->append(force_opaque);
259 this->append(store_8888, ctx);
260 break;
261
262 case kRGB_101010x_SkColorType: this->append(force_opaque);
263 this->append(store_1010102, ctx);
264 break;
265
266 case kGray_8_SkColorType: this->append(bt709_luminance_or_luma_to_alpha);
267 this->append(store_a8, ctx);
268 break;
269
270 case kBGRA_8888_SkColorType: this->append(swap_rb);
271 this->append(store_8888, ctx);
272 break;
273 }
274 }
275
append_transfer_function(const skcms_TransferFunction & tf)276 void SkRasterPipeline::append_transfer_function(const skcms_TransferFunction& tf) {
277 void* ctx = const_cast<void*>(static_cast<const void*>(&tf));
278 switch (classify_transfer_fn(tf)) {
279 case Bad_TF: SkASSERT(false); break;
280
281 case TFKind::sRGBish_TF:
282 if (tf.a == 1 && tf.b == 0 && tf.c == 0 && tf.d == 0 && tf.e == 0 && tf.f == 0) {
283 this->unchecked_append(gamma_, ctx);
284 } else {
285 this->unchecked_append(parametric, ctx);
286 }
287 break;
288 case PQish_TF: this->unchecked_append(PQish, ctx); break;
289 case HLGish_TF: this->unchecked_append(HLGish, ctx); break;
290 case HLGinvish_TF: this->unchecked_append(HLGinvish, ctx); break;
291 }
292 }
293
append_gamut_clamp_if_normalized(const SkImageInfo & dstInfo)294 void SkRasterPipeline::append_gamut_clamp_if_normalized(const SkImageInfo& dstInfo) {
295 // N.B. we _do_ clamp for kRGBA_F16Norm_SkColorType... because it's normalized.
296 if (dstInfo.colorType() != kRGBA_F16_SkColorType &&
297 dstInfo.colorType() != kRGBA_F32_SkColorType &&
298 dstInfo.alphaType() == kPremul_SkAlphaType)
299 {
300 this->unchecked_append(SkRasterPipeline::clamp_gamut, nullptr);
301 }
302 }
303
build_pipeline(void ** ip) const304 SkRasterPipeline::StartPipelineFn SkRasterPipeline::build_pipeline(void** ip) const {
305 // We'll try to build a lowp pipeline, but if that fails fallback to a highp float pipeline.
306 void** reset_point = ip;
307
308 // Stages are stored backwards in fStages, so we reverse here, back to front.
309 *--ip = (void*)SkOpts::just_return_lowp;
310 for (const StageList* st = fStages; st; st = st->prev) {
311 if (auto fn = SkOpts::stages_lowp[st->stage]) {
312 if (st->ctx) {
313 *--ip = st->ctx;
314 }
315 *--ip = (void*)fn;
316 } else {
317 ip = reset_point;
318 break;
319 }
320 }
321 if (ip != reset_point) {
322 return SkOpts::start_pipeline_lowp;
323 }
324
325 *--ip = (void*)SkOpts::just_return_highp;
326 for (const StageList* st = fStages; st; st = st->prev) {
327 if (st->ctx) {
328 *--ip = st->ctx;
329 }
330 *--ip = (void*)SkOpts::stages_highp[st->stage];
331 }
332 return SkOpts::start_pipeline_highp;
333 }
334
run(size_t x,size_t y,size_t w,size_t h) const335 void SkRasterPipeline::run(size_t x, size_t y, size_t w, size_t h) const {
336 if (this->empty()) {
337 return;
338 }
339
340 // Best to not use fAlloc here... we can't bound how often run() will be called.
341 SkAutoSTMalloc<64, void*> program(fSlotsNeeded);
342
343 auto start_pipeline = this->build_pipeline(program.get() + fSlotsNeeded);
344 start_pipeline(x,y,x+w,y+h, program.get());
345 }
346
compile() const347 std::function<void(size_t, size_t, size_t, size_t)> SkRasterPipeline::compile() const {
348 if (this->empty()) {
349 return [](size_t, size_t, size_t, size_t) {};
350 }
351
352 void** program = fAlloc->makeArray<void*>(fSlotsNeeded);
353
354 auto start_pipeline = this->build_pipeline(program + fSlotsNeeded);
355 return [=](size_t x, size_t y, size_t w, size_t h) {
356 start_pipeline(x,y,x+w,y+h, program);
357 };
358 }
359