blob: fb15014a8571d5d1a92a1674691262b5b4a9d0b4 [file] [log] [blame]
mtklein9a5c47f2016-07-22 11:05:04 -07001/*
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
Herb Derbyac04fef2017-01-13 17:34:33 -05008#include "SkArenaAlloc.h"
mtklein9a5c47f2016-07-22 11:05:04 -07009#include "SkBlitter.h"
Mike Kleine902f8d2016-10-26 15:32:26 -040010#include "SkBlendModePriv.h"
mtklein9a5c47f2016-07-22 11:05:04 -070011#include "SkColor.h"
12#include "SkColorFilter.h"
Mike Klein3b840e92017-05-23 15:06:17 -040013#include "SkColorSpaceXformer.h"
Mike Kleinbaaf8ad2016-09-29 09:04:15 -040014#include "SkOpts.h"
mtklein9a5c47f2016-07-22 11:05:04 -070015#include "SkPM4f.h"
Mike Klein744908e2016-11-11 12:51:36 -050016#include "SkPM4fPriv.h"
mtklein9a5c47f2016-07-22 11:05:04 -070017#include "SkRasterPipeline.h"
18#include "SkShader.h"
Florin Malita4aed1382017-05-25 10:38:07 -040019#include "SkShaderBase.h"
Mike Klein14c8f822016-11-30 19:39:43 -050020#include "SkUtils.h"
Mike Klein581e6982017-05-03 13:05:13 -040021#include "../jumper/SkJumper.h"
mtklein9a5c47f2016-07-22 11:05:04 -070022
Mike Klein4e3bc862017-05-22 20:15:17 +000023class SkRasterPipelineBlitter final : public SkBlitter {
mtklein9a5c47f2016-07-22 11:05:04 -070024public:
Mike Klein3b840e92017-05-23 15:06:17 -040025 // This is our common entrypoint for creating the blitter once we've sorted out shaders.
Mike Kleinb35cb312017-05-19 12:01:01 -040026 static SkBlitter* Create(const SkPixmap&, const SkPaint&, SkArenaAlloc*,
Florin Malita4aed1382017-05-25 10:38:07 -040027 const SkRasterPipeline& shaderPipeline,
Florin Malita47e55a52017-06-06 12:26:54 -040028 SkShaderBase::Context*,
Mike Reedeb7dc792017-06-12 12:48:45 -040029 bool is_opaque, bool is_constant);
Mike Kleinb35cb312017-05-19 12:01:01 -040030
Mike Klein3b840e92017-05-23 15:06:17 -040031 SkRasterPipelineBlitter(SkPixmap dst,
32 SkBlendMode blend,
Florin Malita47e55a52017-06-06 12:26:54 -040033 SkArenaAlloc* alloc,
34 SkShaderBase::Context* burstCtx)
mtklein9a5c47f2016-07-22 11:05:04 -070035 : fDst(dst)
Mike Kleine902f8d2016-10-26 15:32:26 -040036 , fBlend(blend)
Mike Klein0a76b412017-05-22 12:01:59 -040037 , fAlloc(alloc)
Florin Malita47e55a52017-06-06 12:26:54 -040038 , fBurstCtx(burstCtx)
Mike Kleinb24704d2017-05-24 07:53:00 -040039 , fColorPipeline(alloc)
mtklein9a5c47f2016-07-22 11:05:04 -070040 {}
41
Mike Klein34d10d72017-06-05 07:10:01 -040042 void blitH (int x, int y, int w) override;
43 void blitAntiH (int x, int y, const SkAlpha[], const int16_t[]) override;
44 void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override;
45 void blitMask (const SkMask&, const SkIRect& clip) override;
Mike Klein3b59af52017-07-20 16:02:12 -040046 void blitRect (int x, int y, int width, int height) override;
mtklein9a5c47f2016-07-22 11:05:04 -070047
48 // TODO: The default implementations of the other blits look fine,
49 // but some of them like blitV could probably benefit from custom
50 // blits using something like a SkRasterPipeline::runFew() method.
51
52private:
Mike Klein14c8f822016-11-30 19:39:43 -050053 void append_load_d(SkRasterPipeline*) const;
54 void append_blend (SkRasterPipeline*) const;
55 void maybe_clamp (SkRasterPipeline*) const;
56 void append_store (SkRasterPipeline*) const;
mtklein8e4373f2016-07-22 14:20:27 -070057
Florin Malita47e55a52017-06-06 12:26:54 -040058 // If we have an burst context, use it to fill our shader buffer.
Mike Klein45c16fa2017-07-18 18:15:13 -040059 void burst_shade(int x, int y, int w);
Florin Malita47e55a52017-06-06 12:26:54 -040060
Florin Malita4aed1382017-05-25 10:38:07 -040061 SkPixmap fDst;
62 SkBlendMode fBlend;
63 SkArenaAlloc* fAlloc;
Florin Malita47e55a52017-06-06 12:26:54 -040064 SkShaderBase::Context* fBurstCtx;
Florin Malita4aed1382017-05-25 10:38:07 -040065 SkRasterPipeline fColorPipeline;
mtklein9a5c47f2016-07-22 11:05:04 -070066
Mike Klein45c16fa2017-07-18 18:15:13 -040067 SkJumper_MemoryCtx fShaderOutput = {nullptr,0}, // Possibly updated each call to burst_shade().
68 fDstPtr = {nullptr,0}, // Always points to the top-left of fDst.
69 fMaskPtr = {nullptr,0}; // Updated each call to blitMask().
70
Mike Klein3b59af52017-07-20 16:02:12 -040071 // We may be able to specialize blitH() or blitRect() into a memset.
72 bool fCanMemsetInBlitRect = false;
Mike Klein8729e5b2017-02-16 06:51:48 -050073 uint64_t fMemsetColor = 0; // Big enough for largest dst format, F16.
Mike Kleinbd3fe472016-10-25 15:43:46 -040074
Mike Klein8729e5b2017-02-16 06:51:48 -050075 // Built lazily on first use.
Mike Klein3b59af52017-07-20 16:02:12 -040076 std::function<void(size_t, size_t, size_t, size_t)> fBlitRect,
Mike Klein45c16fa2017-07-18 18:15:13 -040077 fBlitAntiH,
78 fBlitMaskA8,
79 fBlitMaskLCD16;
Mike Klein8729e5b2017-02-16 06:51:48 -050080
81 // These values are pointed to by the blit pipelines above,
82 // which allows us to adjust them from call to call.
Mike Klein45c16fa2017-07-18 18:15:13 -040083 float fCurrentCoverage = 0.0f;
84 float fDitherRate = 0.0f;
Mike Kleinbd3fe472016-10-25 15:43:46 -040085
Florin Malita47e55a52017-06-06 12:26:54 -040086 std::vector<SkPM4f> fShaderBuffer;
87
mtklein9a5c47f2016-07-22 11:05:04 -070088 typedef SkBlitter INHERITED;
89};
90
91SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
92 const SkPaint& paint,
Mike Kleinfb191da2016-11-15 13:20:33 -050093 const SkMatrix& ctm,
Matt Sarett25834ff2017-02-15 15:54:35 -050094 SkArenaAlloc* alloc) {
Mike Klein3b840e92017-05-23 15:06:17 -040095 SkColorSpace* dstCS = dst.colorSpace();
Mike Reedc91e3872017-07-05 14:12:37 -040096 SkPM4f paintColor = SkPM4f_from_SkColor(paint.getColor(), dstCS);
Florin Malita4aed1382017-05-25 10:38:07 -040097 auto shader = as_SB(paint.getShader());
Mike Klein3b840e92017-05-23 15:06:17 -040098
99 SkRasterPipeline_<256> shaderPipeline;
100 if (!shader) {
101 // Having no shader makes things nice and easy... just use the paint color.
Mike Klein073073e2017-08-03 09:42:53 -0400102 shaderPipeline.append_constant_color(alloc, paintColor);
Mike Reedc91e3872017-07-05 14:12:37 -0400103 bool is_opaque = paintColor.a() == 1.0f,
Mike Reed98b7a6a2017-05-26 09:32:22 -0400104 is_constant = true;
Mike Klein3b840e92017-05-23 15:06:17 -0400105 return SkRasterPipelineBlitter::Create(dst, paint, alloc,
Florin Malita47e55a52017-06-06 12:26:54 -0400106 shaderPipeline, nullptr,
Mike Reedeb7dc792017-06-12 12:48:45 -0400107 is_opaque, is_constant);
Mike Klein3b840e92017-05-23 15:06:17 -0400108 }
109
Mike Reedc91e3872017-07-05 14:12:37 -0400110 bool is_opaque = shader->isOpaque() && paintColor.a() == 1.0f;
Mike Klein3b840e92017-05-23 15:06:17 -0400111 bool is_constant = shader->isConstant();
Florin Malita47e55a52017-06-06 12:26:54 -0400112
113 // Check whether the shader prefers to run in burst mode.
114 if (auto* burstCtx = shader->makeBurstPipelineContext(
115 SkShaderBase::ContextRec(paint, ctm, nullptr, SkShaderBase::ContextRec::kPM4f_DstType,
116 dstCS), alloc)) {
117 return SkRasterPipelineBlitter::Create(dst, paint, alloc,
118 shaderPipeline, burstCtx,
Mike Reedeb7dc792017-06-12 12:48:45 -0400119 is_opaque, is_constant);
Florin Malita47e55a52017-06-06 12:26:54 -0400120 }
121
Mike Klein3b840e92017-05-23 15:06:17 -0400122 if (shader->appendStages(&shaderPipeline, dstCS, alloc, ctm, paint)) {
Mike Reedc91e3872017-07-05 14:12:37 -0400123 if (paintColor.a() != 1.0f) {
124 shaderPipeline.append(SkRasterPipeline::scale_1_float,
125 alloc->make<float>(paintColor.a()));
Mike Klein3b840e92017-05-23 15:06:17 -0400126 }
Florin Malita47e55a52017-06-06 12:26:54 -0400127 return SkRasterPipelineBlitter::Create(dst, paint, alloc, shaderPipeline, nullptr,
Mike Reedeb7dc792017-06-12 12:48:45 -0400128 is_opaque, is_constant);
Mike Klein3b840e92017-05-23 15:06:17 -0400129 }
130
Florin Malita47e55a52017-06-06 12:26:54 -0400131 // The shader has opted out of drawing anything.
Mike Reed6867eee2017-06-02 13:25:15 -0400132 return alloc->make<SkNullBlitter>();
Mike Reed02640952017-05-19 15:32:13 -0400133}
134
135SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
136 const SkPaint& paint,
Mike Reed02640952017-05-19 15:32:13 -0400137 const SkRasterPipeline& shaderPipeline,
Mike Kleinb35cb312017-05-19 12:01:01 -0400138 bool is_opaque,
Mike Reed02640952017-05-19 15:32:13 -0400139 SkArenaAlloc* alloc) {
Mike Kleinb35cb312017-05-19 12:01:01 -0400140 bool is_constant = false; // If this were the case, it'd be better to just set a paint color.
Florin Malita47e55a52017-06-06 12:26:54 -0400141 return SkRasterPipelineBlitter::Create(dst, paint, alloc, shaderPipeline, nullptr,
Mike Reedeb7dc792017-06-12 12:48:45 -0400142 is_opaque, is_constant);
Mike Reed02640952017-05-19 15:32:13 -0400143}
144
Mike Kleinb35cb312017-05-19 12:01:01 -0400145SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
146 const SkPaint& paint,
147 SkArenaAlloc* alloc,
148 const SkRasterPipeline& shaderPipeline,
Florin Malita47e55a52017-06-06 12:26:54 -0400149 SkShaderBase::Context* burstCtx,
Mike Kleinb35cb312017-05-19 12:01:01 -0400150 bool is_opaque,
Mike Reedeb7dc792017-06-12 12:48:45 -0400151 bool is_constant) {
Mike Klein3b840e92017-05-23 15:06:17 -0400152 auto blitter = alloc->make<SkRasterPipelineBlitter>(dst,
153 paint.getBlendMode(),
Florin Malita47e55a52017-06-06 12:26:54 -0400154 alloc,
155 burstCtx);
Mike Reed02640952017-05-19 15:32:13 -0400156
Mike Kleinb35cb312017-05-19 12:01:01 -0400157 // Our job in this factory is to fill out the blitter's color pipeline.
158 // This is the common front of the full blit pipelines, each constructed lazily on first use.
159 // The full blit pipelines handle reading and writing the dst, blending, coverage, dithering.
160 auto colorPipeline = &blitter->fColorPipeline;
161
Mike Klein3b840e92017-05-23 15:06:17 -0400162 // Let's get the shader in first.
Florin Malita47e55a52017-06-06 12:26:54 -0400163 if (burstCtx) {
164 colorPipeline->append(SkRasterPipeline::load_f32, &blitter->fShaderOutput);
165 } else {
166 colorPipeline->extend(shaderPipeline);
167 }
Mike Reed02640952017-05-19 15:32:13 -0400168
Mike Kleinb35cb312017-05-19 12:01:01 -0400169 // If there's a color filter it comes next.
170 if (auto colorFilter = paint.getColorFilter()) {
171 colorFilter->appendStages(colorPipeline, dst.colorSpace(), alloc, is_opaque);
mtkleina4a44882016-11-04 13:20:07 -0700172 is_opaque = is_opaque && (colorFilter->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
mtklein9a5c47f2016-07-22 11:05:04 -0700173 }
174
Mike Kleinb35cb312017-05-19 12:01:01 -0400175 // Not all formats make sense to dither (think, F16). We set their dither rate to zero.
176 // We need to decide if we're going to dither now to keep is_constant accurate.
Mike Reedeb7dc792017-06-12 12:48:45 -0400177 if (paint.isDither()) {
Mike Kleinb35cb312017-05-19 12:01:01 -0400178 switch (dst.info().colorType()) {
Mike Klein9b10f8f2017-06-01 13:11:16 -0400179 default: blitter->fDitherRate = 0.0f; break;
Mike Klein95d19f32017-06-15 07:40:24 -0700180 case kARGB_4444_SkColorType: blitter->fDitherRate = 1/15.0f; break;
Mike Klein9b10f8f2017-06-01 13:11:16 -0400181 case kRGB_565_SkColorType: blitter->fDitherRate = 1/63.0f; break;
Mike Klein95d19f32017-06-15 07:40:24 -0700182 case kGray_8_SkColorType:
Mike Kleinb35cb312017-05-19 12:01:01 -0400183 case kRGBA_8888_SkColorType:
Mike Klein9b10f8f2017-06-01 13:11:16 -0400184 case kBGRA_8888_SkColorType: blitter->fDitherRate = 1/255.0f; break;
Mike Kleinb35cb312017-05-19 12:01:01 -0400185 }
Mike Reedeb7dc792017-06-12 12:48:45 -0400186 // TODO: for constant colors, we could try to measure the effect of dithering, and if
187 // it has no value (i.e. all variations result in the same 32bit color, then we
188 // could disable it (for speed, by not adding the stage).
Mike Kleinb35cb312017-05-19 12:01:01 -0400189 }
Mike Klein9b10f8f2017-06-01 13:11:16 -0400190 is_constant = is_constant && (blitter->fDitherRate == 0.0f);
Mike Kleinb35cb312017-05-19 12:01:01 -0400191
192 // We're logically done here. The code between here and return blitter is all optimization.
193
194 // A pipeline that's still constant here can collapse back into a constant color.
Mike Klein14c8f822016-11-30 19:39:43 -0500195 if (is_constant) {
Mike Klein45c16fa2017-07-18 18:15:13 -0400196 SkPM4f constantColor;
197 SkJumper_MemoryCtx constantColorPtr = { &constantColor, 0 };
198 colorPipeline->append(SkRasterPipeline::store_f32, &constantColorPtr);
199 colorPipeline->run(0,0,1,1);
Mike Kleinb24704d2017-05-24 07:53:00 -0400200 colorPipeline->reset();
Mike Klein073073e2017-08-03 09:42:53 -0400201 colorPipeline->append_constant_color(alloc, constantColor);
mtkleina4a44882016-11-04 13:20:07 -0700202
Mike Klein45c16fa2017-07-18 18:15:13 -0400203 is_opaque = constantColor.a() == 1.0f;
Mike Klein66866172016-11-03 12:22:01 -0400204 }
mtklein8e4373f2016-07-22 14:20:27 -0700205
Mike Kleinb35cb312017-05-19 12:01:01 -0400206 // We can strength-reduce SrcOver into Src when opaque.
207 if (is_opaque && blitter->fBlend == SkBlendMode::kSrcOver) {
208 blitter->fBlend = SkBlendMode::kSrc;
mtklein8e4373f2016-07-22 14:20:27 -0700209 }
210
Mike Kleinb35cb312017-05-19 12:01:01 -0400211 // When we're drawing a constant color in Src mode, we can sometimes just memset.
212 // (The previous two optimizations help find more opportunities for this one.)
213 if (is_constant && blitter->fBlend == SkBlendMode::kSrc) {
214 // Run our color pipeline all the way through to produce what we'd memset when we can.
215 // Not all blits can memset, so we need to keep colorPipeline too.
Mike Kleinb24704d2017-05-24 07:53:00 -0400216 SkRasterPipeline_<256> p;
Mike Kleinb35cb312017-05-19 12:01:01 -0400217 p.extend(*colorPipeline);
Mike Klein45c16fa2017-07-18 18:15:13 -0400218 blitter->fDstPtr = SkJumper_MemoryCtx{&blitter->fMemsetColor, 0};
Mike Kleinb35cb312017-05-19 12:01:01 -0400219 blitter->append_store(&p);
Mike Klein45c16fa2017-07-18 18:15:13 -0400220 p.run(0,0,1,1);
Mike Klein14c8f822016-11-30 19:39:43 -0500221
Mike Klein3b59af52017-07-20 16:02:12 -0400222 blitter->fCanMemsetInBlitRect = true;
Mike Klein14c8f822016-11-30 19:39:43 -0500223 }
Mike Kleinb35cb312017-05-19 12:01:01 -0400224
Mike Klein45c16fa2017-07-18 18:15:13 -0400225 blitter->fDstPtr = SkJumper_MemoryCtx{
226 blitter->fDst.writable_addr(),
227 blitter->fDst.rowBytesAsPixels(),
228 };
229
Mike Kleinb35cb312017-05-19 12:01:01 -0400230 return blitter;
mtklein9a5c47f2016-07-22 11:05:04 -0700231}
232
Mike Kleine902f8d2016-10-26 15:32:26 -0400233void SkRasterPipelineBlitter::append_load_d(SkRasterPipeline* p) const {
mtklein8e4373f2016-07-22 14:20:27 -0700234 switch (fDst.info().colorType()) {
Mike Reed279091e2017-06-27 16:58:00 -0400235 case kGray_8_SkColorType: p->append(SkRasterPipeline::load_g8_dst, &fDstPtr); break;
236 case kAlpha_8_SkColorType: p->append(SkRasterPipeline::load_a8_dst, &fDstPtr); break;
237 case kRGB_565_SkColorType: p->append(SkRasterPipeline::load_565_dst, &fDstPtr); break;
238 case kARGB_4444_SkColorType: p->append(SkRasterPipeline::load_4444_dst, &fDstPtr); break;
Mike Klein111f8a92017-06-27 15:56:32 -0400239 case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::load_bgra_dst, &fDstPtr); break;
Mike Reed279091e2017-06-27 16:58:00 -0400240 case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::load_8888_dst, &fDstPtr); break;
241 case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::load_f16_dst, &fDstPtr); break;
Mike Klein111f8a92017-06-27 15:56:32 -0400242 default: break;
Mike Kleine03339a2016-11-28 13:24:27 -0500243 }
244 if (fDst.info().gammaCloseToSRGB()) {
Mike Reed279091e2017-06-27 16:58:00 -0400245 p->append_from_srgb_dst(fDst.info().alphaType());
Mike Kleine03339a2016-11-28 13:24:27 -0500246 }
mtklein8e4373f2016-07-22 14:20:27 -0700247}
248
Mike Klein14c8f822016-11-30 19:39:43 -0500249void SkRasterPipelineBlitter::append_store(SkRasterPipeline* p) const {
Matt Sarettf3880932017-03-24 10:06:03 -0400250 if (fDst.info().gammaCloseToSRGB()) {
Mike Kleine03339a2016-11-28 13:24:27 -0500251 p->append(SkRasterPipeline::to_srgb);
252 }
Mike Klein9b10f8f2017-06-01 13:11:16 -0400253 if (fDitherRate > 0.0f) {
Mike Kleindb711c92017-05-03 17:57:48 -0400254 // We dither after any sRGB transfer function to make sure our 1/255.0f is sensible
255 // over the whole range. If we did it before, 1/255.0f is too big a rate near zero.
Mike Klein9b10f8f2017-06-01 13:11:16 -0400256 p->append(SkRasterPipeline::dither, &fDitherRate);
Mike Kleindb711c92017-05-03 17:57:48 -0400257 }
258
Mike Klein159db0a2017-07-25 12:02:13 -0400259 if (fDst.info().colorType() != kRGBA_F16_SkColorType) {
260 p->clamp_if_unclamped(kPremul_SkAlphaType);
261 }
262
mtklein8e4373f2016-07-22 14:20:27 -0700263 switch (fDst.info().colorType()) {
Mike Klein95d19f32017-06-15 07:40:24 -0700264 case kGray_8_SkColorType: p->append(SkRasterPipeline::luminance_to_alpha); // fallthru
Mike Kleine71b1672017-01-13 07:59:23 -0500265 case kAlpha_8_SkColorType: p->append(SkRasterPipeline::store_a8, &fDstPtr); break;
Mike Kleine03339a2016-11-28 13:24:27 -0500266 case kRGB_565_SkColorType: p->append(SkRasterPipeline::store_565, &fDstPtr); break;
Mike Klein95d19f32017-06-15 07:40:24 -0700267 case kARGB_4444_SkColorType: p->append(SkRasterPipeline::store_4444, &fDstPtr); break;
Mike Klein111f8a92017-06-27 15:56:32 -0400268 case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::store_bgra, &fDstPtr); break;
Mike Kleine03339a2016-11-28 13:24:27 -0500269 case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::store_8888, &fDstPtr); break;
270 case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::store_f16, &fDstPtr); break;
mtklein8e4373f2016-07-22 14:20:27 -0700271 default: break;
272 }
273}
274
Mike Kleine902f8d2016-10-26 15:32:26 -0400275void SkRasterPipelineBlitter::append_blend(SkRasterPipeline* p) const {
Mike Reed883c9bc2017-07-19 10:57:53 -0400276 if (fDst.info().alphaType() == kUnpremul_SkAlphaType) {
277 p->append(SkRasterPipeline::premul_dst);
278 }
Mike Kleincb3ceb72017-06-09 15:58:37 -0400279 SkBlendMode_AppendStagesNoClamp(fBlend, p);
Mike Reed883c9bc2017-07-19 10:57:53 -0400280 if (fDst.info().alphaType() == kUnpremul_SkAlphaType) {
281 p->append(SkRasterPipeline::unpremul);
282 }
Mike Kleine902f8d2016-10-26 15:32:26 -0400283}
Mike Kleine9f74b82016-10-25 13:31:21 -0400284
Mike Klein130863e2016-10-27 11:29:36 -0400285void SkRasterPipelineBlitter::maybe_clamp(SkRasterPipeline* p) const {
Mike Kleincb3ceb72017-06-09 15:58:37 -0400286 SkBlendMode_AppendClampIfNeeded(fBlend, p);
Mike Klein130863e2016-10-27 11:29:36 -0400287}
288
Mike Klein45c16fa2017-07-18 18:15:13 -0400289void SkRasterPipelineBlitter::burst_shade(int x, int y, int w) {
290 SkASSERT(fBurstCtx);
291 if (w > SkToInt(fShaderBuffer.size())) {
292 fShaderBuffer.resize(w);
Florin Malita47e55a52017-06-06 12:26:54 -0400293 }
Mike Klein45c16fa2017-07-18 18:15:13 -0400294 fBurstCtx->shadeSpan4f(x,y, fShaderBuffer.data(), w);
295 // We'll be reading from fShaderOutput.pixels + x, so back up by x.
296 fShaderOutput = SkJumper_MemoryCtx{ fShaderBuffer.data() - x, 0 };
Florin Malita47e55a52017-06-06 12:26:54 -0400297}
298
mtklein9a5c47f2016-07-22 11:05:04 -0700299void SkRasterPipelineBlitter::blitH(int x, int y, int w) {
Mike Klein3b59af52017-07-20 16:02:12 -0400300 this->blitRect(x,y,w,1);
301}
302
303void SkRasterPipelineBlitter::blitRect(int x, int y, int w, int h) {
304 if (fCanMemsetInBlitRect) {
305 for (int ylimit = y+h; y < ylimit; y++) {
306 switch (fDst.shiftPerPixel()) {
307 case 0: memset (fDst.writable_addr8 (x,y), fMemsetColor, w); break;
308 case 1: sk_memset16(fDst.writable_addr16(x,y), fMemsetColor, w); break;
309 case 2: sk_memset32(fDst.writable_addr32(x,y), fMemsetColor, w); break;
310 case 3: sk_memset64(fDst.writable_addr64(x,y), fMemsetColor, w); break;
311 default: break;
312 }
Mike Klein8729e5b2017-02-16 06:51:48 -0500313 }
Mike Klein3b59af52017-07-20 16:02:12 -0400314 return;
Mike Klein8729e5b2017-02-16 06:51:48 -0500315 }
316
Mike Klein3b59af52017-07-20 16:02:12 -0400317 if (!fBlitRect) {
Mike Kleinb24704d2017-05-24 07:53:00 -0400318 SkRasterPipeline p(fAlloc);
Mike Kleinb35cb312017-05-19 12:01:01 -0400319 p.extend(fColorPipeline);
Mike Klein50626262017-05-25 13:06:57 -0400320 if (fBlend == SkBlendMode::kSrcOver
321 && fDst.info().colorType() == kRGBA_8888_SkColorType
322 && !fDst.colorSpace()
Mike Reed883c9bc2017-07-19 10:57:53 -0400323 && fDst.info().alphaType() != kUnpremul_SkAlphaType
Mike Klein9b10f8f2017-06-01 13:11:16 -0400324 && fDitherRate == 0.0f) {
Mike Klein159db0a2017-07-25 12:02:13 -0400325 p.clamp_if_unclamped(kPremul_SkAlphaType);
Mike Klein50626262017-05-25 13:06:57 -0400326 p.append(SkRasterPipeline::srcover_rgba_8888, &fDstPtr);
327 } else {
328 if (fBlend != SkBlendMode::kSrc) {
329 this->append_load_d(&p);
330 this->append_blend(&p);
331 this->maybe_clamp(&p);
332 }
333 this->append_store(&p);
Mike Klein66866172016-11-03 12:22:01 -0400334 }
Mike Klein3b59af52017-07-20 16:02:12 -0400335 fBlitRect = p.compile();
Mike Kleinbd3fe472016-10-25 15:43:46 -0400336 }
Mike Klein3b59af52017-07-20 16:02:12 -0400337
Mike Klein45c16fa2017-07-18 18:15:13 -0400338 if (fBurstCtx) {
Mike Klein3b59af52017-07-20 16:02:12 -0400339 // We can only burst shade one row at a time.
340 for (int ylimit = y+h; y < ylimit; y++) {
341 this->burst_shade(x,y,w);
342 fBlitRect(x,y, w,1);
343 }
344 } else {
345 // If not bursting we can blit the entire rect at once.
346 fBlitRect(x,y,w,h);
Mike Klein45c16fa2017-07-18 18:15:13 -0400347 }
mtklein9a5c47f2016-07-22 11:05:04 -0700348}
349
350void SkRasterPipelineBlitter::blitAntiH(int x, int y, const SkAlpha aa[], const int16_t runs[]) {
Mike Klein0a76b412017-05-22 12:01:59 -0400351 if (!fBlitAntiH) {
Mike Kleinb24704d2017-05-24 07:53:00 -0400352 SkRasterPipeline p(fAlloc);
Mike Kleinb35cb312017-05-19 12:01:01 -0400353 p.extend(fColorPipeline);
Mike Klein66866172016-11-03 12:22:01 -0400354 if (fBlend == SkBlendMode::kSrcOver) {
Mike Kleinbabd93e2016-11-30 16:05:10 -0500355 p.append(SkRasterPipeline::scale_1_float, &fCurrentCoverage);
Mike Klein66866172016-11-03 12:22:01 -0400356 this->append_load_d(&p);
357 this->append_blend(&p);
358 } else {
359 this->append_load_d(&p);
360 this->append_blend(&p);
Mike Kleinbabd93e2016-11-30 16:05:10 -0500361 p.append(SkRasterPipeline::lerp_1_float, &fCurrentCoverage);
Mike Klein66866172016-11-03 12:22:01 -0400362 }
Mike Klein130863e2016-10-27 11:29:36 -0400363 this->maybe_clamp(&p);
Mike Kleine902f8d2016-10-26 15:32:26 -0400364 this->append_store(&p);
Mike Kleinb24704d2017-05-24 07:53:00 -0400365 fBlitAntiH = p.compile();
Mike Kleinbd3fe472016-10-25 15:43:46 -0400366 }
mtklein9a5c47f2016-07-22 11:05:04 -0700367
mtklein9a5c47f2016-07-22 11:05:04 -0700368 for (int16_t run = *runs; run > 0; run = *runs) {
Mike Kleinaeb79592016-11-07 09:29:07 -0500369 switch (*aa) {
370 case 0x00: break;
371 case 0xff: this->blitH(x,y,run); break;
372 default:
Mike Kleinbabd93e2016-11-30 16:05:10 -0500373 fCurrentCoverage = *aa * (1/255.0f);
Mike Klein45c16fa2017-07-18 18:15:13 -0400374 if (fBurstCtx) {
375 this->burst_shade(x,y,run);
376 }
377 fBlitAntiH(x,y,run,1);
Mike Kleinaeb79592016-11-07 09:29:07 -0500378 }
mtklein9a5c47f2016-07-22 11:05:04 -0700379 x += run;
380 runs += run;
381 aa += run;
382 }
383}
384
Mike Klein34d10d72017-06-05 07:10:01 -0400385void SkRasterPipelineBlitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
386 SkIRect clip = {x,y, x+2,y+1};
387 uint8_t coverage[] = { (uint8_t)a0, (uint8_t)a1 };
388
389 SkMask mask;
390 mask.fImage = coverage;
391 mask.fBounds = clip;
392 mask.fRowBytes = 2;
393 mask.fFormat = SkMask::kA8_Format;
394
395 this->blitMask(mask, clip);
396}
397
mtklein9a5c47f2016-07-22 11:05:04 -0700398void SkRasterPipelineBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
399 if (mask.fFormat == SkMask::kBW_Format) {
400 // TODO: native BW masks?
401 return INHERITED::blitMask(mask, clip);
402 }
403
Mike Klein45c16fa2017-07-18 18:15:13 -0400404 // Lazily build whichever pipeline we need, specialized for each mask format.
Mike Klein0a76b412017-05-22 12:01:59 -0400405 if (mask.fFormat == SkMask::kA8_Format && !fBlitMaskA8) {
Mike Kleinb24704d2017-05-24 07:53:00 -0400406 SkRasterPipeline p(fAlloc);
Mike Kleinb35cb312017-05-19 12:01:01 -0400407 p.extend(fColorPipeline);
Mike Klein66866172016-11-03 12:22:01 -0400408 if (fBlend == SkBlendMode::kSrcOver) {
409 p.append(SkRasterPipeline::scale_u8, &fMaskPtr);
410 this->append_load_d(&p);
411 this->append_blend(&p);
412 } else {
413 this->append_load_d(&p);
414 this->append_blend(&p);
415 p.append(SkRasterPipeline::lerp_u8, &fMaskPtr);
416 }
Mike Klein130863e2016-10-27 11:29:36 -0400417 this->maybe_clamp(&p);
Mike Kleine902f8d2016-10-26 15:32:26 -0400418 this->append_store(&p);
Mike Kleinb24704d2017-05-24 07:53:00 -0400419 fBlitMaskA8 = p.compile();
Mike Kleinbd3fe472016-10-25 15:43:46 -0400420 }
Mike Klein0a76b412017-05-22 12:01:59 -0400421 if (mask.fFormat == SkMask::kLCD16_Format && !fBlitMaskLCD16) {
Mike Kleinb24704d2017-05-24 07:53:00 -0400422 SkRasterPipeline p(fAlloc);
Mike Kleinb35cb312017-05-19 12:01:01 -0400423 p.extend(fColorPipeline);
Mike Kleine902f8d2016-10-26 15:32:26 -0400424 this->append_load_d(&p);
425 this->append_blend(&p);
Mike Kleinbd3fe472016-10-25 15:43:46 -0400426 p.append(SkRasterPipeline::lerp_565, &fMaskPtr);
Mike Klein130863e2016-10-27 11:29:36 -0400427 this->maybe_clamp(&p);
Mike Kleine902f8d2016-10-26 15:32:26 -0400428 this->append_store(&p);
Mike Kleinb24704d2017-05-24 07:53:00 -0400429 fBlitMaskLCD16 = p.compile();
Mike Kleinbd3fe472016-10-25 15:43:46 -0400430 }
431
Mike Klein45c16fa2017-07-18 18:15:13 -0400432 std::function<void(size_t,size_t,size_t,size_t)>* blitter = nullptr;
433 // Update fMaskPtr to point "into" this current mask, but lined up with fDstPtr at (0,0).
434 switch (mask.fFormat) {
435 case SkMask::kA8_Format:
436 fMaskPtr.stride = mask.fRowBytes;
437 fMaskPtr.pixels = (uint8_t*)mask.fImage - mask.fBounds.left()
438 - mask.fBounds.top() * fMaskPtr.stride;
439 blitter = &fBlitMaskA8;
440 break;
441 case SkMask::kLCD16_Format:
442 fMaskPtr.stride = mask.fRowBytes / 2;
443 fMaskPtr.pixels = (uint16_t*)mask.fImage - mask.fBounds.left()
444 - mask.fBounds.top() * fMaskPtr.stride;
445 blitter = &fBlitMaskLCD16;
446 break;
447 default:
448 return;
449 }
Mike Kleinbd3fe472016-10-25 15:43:46 -0400450
Mike Klein45c16fa2017-07-18 18:15:13 -0400451 SkASSERT(blitter);
452 if (fBurstCtx) {
453 // We can only burst shade one row at a time.
454 int x = clip.left();
455 for (int y = clip.top(); y < clip.bottom(); y++) {
456 this->burst_shade(x,y,clip.width());
457 (*blitter)(x,y, clip.width(),1);
mtklein9a5c47f2016-07-22 11:05:04 -0700458 }
Mike Klein45c16fa2017-07-18 18:15:13 -0400459 } else {
460 // If not bursting we can blit the entire mask at once.
461 (*blitter)(clip.left(),clip.top(), clip.width(),clip.height());
mtklein9a5c47f2016-07-22 11:05:04 -0700462 }
463}