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 "SkArenaAlloc.h"
9#include "SkBlitter.h"
10#include "SkBlendModePriv.h"
11#include "SkColor.h"
12#include "SkColorFilter.h"
13#include "SkColorSpaceXformer.h"
14#include "SkOpts.h"
15#include "SkPM4f.h"
16#include "SkPM4fPriv.h"
17#include "SkRasterPipeline.h"
18#include "SkShader.h"
19#include "SkShaderBase.h"
20#include "SkUtils.h"
21#include "../jumper/SkJumper.h"
22
23class SkRasterPipelineBlitter final : public SkBlitter {
24public:
25    // This is our common entrypoint for creating the blitter once we've sorted out shaders.
26    static SkBlitter* Create(const SkPixmap&, const SkPaint&, SkArenaAlloc*,
27                             const SkRasterPipeline& shaderPipeline,
28                             SkShaderBase::Context*,
29                             bool is_opaque, bool is_constant);
30
31    SkRasterPipelineBlitter(SkPixmap dst,
32                            SkBlendMode blend,
33                            SkArenaAlloc* alloc,
34                            SkShaderBase::Context* burstCtx)
35        : fDst(dst)
36        , fBlend(blend)
37        , fAlloc(alloc)
38        , fBurstCtx(burstCtx)
39        , fColorPipeline(alloc)
40    {}
41
42    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 blitAntiV2(int x, int y, U8CPU a0, U8CPU a1)               override;
46    void blitMask  (const SkMask&, const SkIRect& clip)             override;
47    void blitRect  (int x, int y, int width, int height)            override;
48    void blitV     (int x, int y, int height, SkAlpha alpha)        override;
49
50private:
51    void append_load_dst(SkRasterPipeline*) const;
52    void append_store   (SkRasterPipeline*) const;
53
54    // If we have an burst context, use it to fill our shader buffer.
55    void burst_shade(int x, int y, int w);
56
57    SkPixmap               fDst;
58    SkBlendMode            fBlend;
59    SkArenaAlloc*          fAlloc;
60    SkShaderBase::Context* fBurstCtx;
61    SkRasterPipeline       fColorPipeline;
62
63    SkJumper_MemoryCtx fShaderOutput = {nullptr,0},  // Possibly updated each call to burst_shade().
64                       fDstPtr       = {nullptr,0},  // Always points to the top-left of fDst.
65                       fMaskPtr      = {nullptr,0};  // Updated each call to blitMask().
66
67    // We may be able to specialize blitH() or blitRect() into a memset.
68    bool     fCanMemsetInBlitRect = false;
69    uint64_t fMemsetColor      = 0;     // Big enough for largest dst format, F16.
70
71    // Built lazily on first use.
72    std::function<void(size_t, size_t, size_t, size_t)> fBlitRect,
73                                                        fBlitAntiH,
74                                                        fBlitMaskA8,
75                                                        fBlitMaskLCD16;
76
77    // These values are pointed to by the blit pipelines above,
78    // which allows us to adjust them from call to call.
79    float fCurrentCoverage = 0.0f;
80    float fDitherRate      = 0.0f;
81
82    std::vector<SkPM4f> fShaderBuffer;
83
84    typedef SkBlitter INHERITED;
85};
86
87SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
88                                         const SkPaint& paint,
89                                         const SkMatrix& ctm,
90                                         SkArenaAlloc* alloc) {
91    SkColorSpace* dstCS = dst.colorSpace();
92    SkPM4f paintColor = SkPM4f_from_SkColor(paint.getColor(), dstCS);
93    auto shader = as_SB(paint.getShader());
94
95    SkRasterPipeline_<256> shaderPipeline;
96    if (!shader) {
97        // Having no shader makes things nice and easy... just use the paint color.
98        shaderPipeline.append_constant_color(alloc, paintColor);
99        bool is_opaque    = paintColor.a() == 1.0f,
100             is_constant  = true;
101        return SkRasterPipelineBlitter::Create(dst, paint, alloc,
102                                               shaderPipeline, nullptr,
103                                               is_opaque, is_constant);
104    }
105
106    bool is_opaque    = shader->isOpaque() && paintColor.a() == 1.0f;
107    bool is_constant  = shader->isConstant();
108
109    // Check whether the shader prefers to run in burst mode.
110    if (auto* burstCtx = shader->makeBurstPipelineContext(
111        SkShaderBase::ContextRec(paint, ctm, nullptr, SkShaderBase::ContextRec::kPM4f_DstType,
112                                 dstCS), alloc)) {
113        return SkRasterPipelineBlitter::Create(dst, paint, alloc,
114                                               shaderPipeline, burstCtx,
115                                               is_opaque, is_constant);
116    }
117
118    if (shader->appendStages({&shaderPipeline, alloc, dstCS, paint, nullptr, ctm})) {
119        if (paintColor.a() != 1.0f) {
120            shaderPipeline.append(SkRasterPipeline::scale_1_float,
121                                  alloc->make<float>(paintColor.a()));
122        }
123        return SkRasterPipelineBlitter::Create(dst, paint, alloc, shaderPipeline, nullptr,
124                                               is_opaque, is_constant);
125    }
126
127    // The shader has opted out of drawing anything.
128    return alloc->make<SkNullBlitter>();
129}
130
131SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
132                                         const SkPaint& paint,
133                                         const SkRasterPipeline& shaderPipeline,
134                                         bool is_opaque,
135                                         SkArenaAlloc* alloc) {
136    bool is_constant = false;  // If this were the case, it'd be better to just set a paint color.
137    return SkRasterPipelineBlitter::Create(dst, paint, alloc, shaderPipeline, nullptr,
138                                           is_opaque, is_constant);
139}
140
141SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
142                                           const SkPaint& paint,
143                                           SkArenaAlloc* alloc,
144                                           const SkRasterPipeline& shaderPipeline,
145                                           SkShaderBase::Context* burstCtx,
146                                           bool is_opaque,
147                                           bool is_constant) {
148    auto blitter = alloc->make<SkRasterPipelineBlitter>(dst,
149                                                        paint.getBlendMode(),
150                                                        alloc,
151                                                        burstCtx);
152
153    // Our job in this factory is to fill out the blitter's color pipeline.
154    // This is the common front of the full blit pipelines, each constructed lazily on first use.
155    // The full blit pipelines handle reading and writing the dst, blending, coverage, dithering.
156    auto colorPipeline = &blitter->fColorPipeline;
157
158    // Let's get the shader in first.
159    if (burstCtx) {
160        colorPipeline->append(SkRasterPipeline::load_f32, &blitter->fShaderOutput);
161    } else {
162        colorPipeline->extend(shaderPipeline);
163    }
164
165    // If there's a color filter it comes next.
166    if (auto colorFilter = paint.getColorFilter()) {
167        colorFilter->appendStages(colorPipeline, dst.colorSpace(), alloc, is_opaque);
168        is_opaque = is_opaque && (colorFilter->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
169    }
170
171    // Not all formats make sense to dither (think, F16).  We set their dither rate
172    // to zero.  We need to decide if we're going to dither now to keep is_constant accurate.
173    if (paint.isDither()) {
174        switch (dst.info().colorType()) {
175            default:                        blitter->fDitherRate =      0.0f; break;
176            case kARGB_4444_SkColorType:    blitter->fDitherRate =   1/15.0f; break;
177            case   kRGB_565_SkColorType:    blitter->fDitherRate =   1/63.0f; break;
178            case    kGray_8_SkColorType:
179            case  kRGB_888x_SkColorType:
180            case kRGBA_8888_SkColorType:
181            case kBGRA_8888_SkColorType:    blitter->fDitherRate =  1/255.0f; break;
182            case kRGB_101010x_SkColorType:
183            case kRGBA_1010102_SkColorType: blitter->fDitherRate = 1/1023.0f; break;
184        }
185        // TODO: for constant colors, we could try to measure the effect of dithering, and if
186        //       it has no value (i.e. all variations result in the same 32bit color, then we
187        //       could disable it (for speed, by not adding the stage).
188    }
189    is_constant = is_constant && (blitter->fDitherRate == 0.0f);
190
191    // We're logically done here.  The code between here and return blitter is all optimization.
192
193    // A pipeline that's still constant here can collapse back into a constant color.
194    if (is_constant) {
195        SkPM4f constantColor;
196        SkJumper_MemoryCtx constantColorPtr = { &constantColor, 0 };
197        colorPipeline->append(SkRasterPipeline::store_f32, &constantColorPtr);
198        colorPipeline->run(0,0,1,1);
199        colorPipeline->reset();
200        colorPipeline->append_constant_color(alloc, constantColor);
201
202        is_opaque = constantColor.a() == 1.0f;
203    }
204
205    // We can strength-reduce SrcOver into Src when opaque.
206    if (is_opaque && blitter->fBlend == SkBlendMode::kSrcOver) {
207        blitter->fBlend = SkBlendMode::kSrc;
208    }
209
210    // When we're drawing a constant color in Src mode, we can sometimes just memset.
211    // (The previous two optimizations help find more opportunities for this one.)
212    if (is_constant && blitter->fBlend == SkBlendMode::kSrc) {
213        // Run our color pipeline all the way through to produce what we'd memset when we can.
214        // Not all blits can memset, so we need to keep colorPipeline too.
215        SkRasterPipeline_<256> p;
216        p.extend(*colorPipeline);
217        blitter->fDstPtr = SkJumper_MemoryCtx{&blitter->fMemsetColor, 0};
218        blitter->append_store(&p);
219        p.run(0,0,1,1);
220
221        blitter->fCanMemsetInBlitRect = true;
222    }
223
224    blitter->fDstPtr = SkJumper_MemoryCtx{
225        blitter->fDst.writable_addr(),
226        blitter->fDst.rowBytesAsPixels(),
227    };
228
229    return blitter;
230}
231
232void SkRasterPipelineBlitter::append_load_dst(SkRasterPipeline* p) const {
233    const void* ctx = &fDstPtr;
234    switch (fDst.info().colorType()) {
235        default: break;
236
237        case kGray_8_SkColorType:       p->append(SkRasterPipeline::load_g8_dst,      ctx); break;
238        case kAlpha_8_SkColorType:      p->append(SkRasterPipeline::load_a8_dst,      ctx); break;
239        case kRGB_565_SkColorType:      p->append(SkRasterPipeline::load_565_dst,     ctx); break;
240        case kARGB_4444_SkColorType:    p->append(SkRasterPipeline::load_4444_dst,    ctx); break;
241        case kBGRA_8888_SkColorType:    p->append(SkRasterPipeline::load_bgra_dst,    ctx); break;
242        case kRGBA_8888_SkColorType:    p->append(SkRasterPipeline::load_8888_dst,    ctx); break;
243        case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::load_1010102_dst, ctx); break;
244        case kRGBA_F16_SkColorType:     p->append(SkRasterPipeline::load_f16_dst,     ctx); break;
245
246        case kRGB_888x_SkColorType:     p->append(SkRasterPipeline::load_8888_dst,    ctx);
247                                        p->append(SkRasterPipeline::force_opaque_dst     ); break;
248        case kRGB_101010x_SkColorType:  p->append(SkRasterPipeline::load_1010102_dst, ctx);
249                                        p->append(SkRasterPipeline::force_opaque_dst     ); break;
250    }
251    if (fDst.info().gammaCloseToSRGB()) {
252        p->append(SkRasterPipeline::from_srgb_dst);
253    }
254    if (fDst.info().alphaType() == kUnpremul_SkAlphaType) {
255        p->append(SkRasterPipeline::premul_dst);
256    }
257}
258
259void SkRasterPipelineBlitter::append_store(SkRasterPipeline* p) const {
260    if (fDst.info().alphaType() == kUnpremul_SkAlphaType) {
261        p->append(SkRasterPipeline::unpremul);
262    }
263    if (fDst.info().gammaCloseToSRGB()) {
264        p->append(SkRasterPipeline::to_srgb);
265    }
266    if (fDitherRate > 0.0f) {
267        // We dither after any sRGB transfer function to make sure our 1/255.0f is sensible
268        // over the whole range.  If we did it before, 1/255.0f is too big a rate near zero.
269        p->append(SkRasterPipeline::dither, &fDitherRate);
270    }
271
272    const void* ctx = &fDstPtr;
273    switch (fDst.info().colorType()) {
274        default: break;
275
276        case kGray_8_SkColorType:       p->append(SkRasterPipeline::luminance_to_alpha);
277                                        p->append(SkRasterPipeline::store_a8,      ctx); break;
278        case kAlpha_8_SkColorType:      p->append(SkRasterPipeline::store_a8,      ctx); break;
279        case kRGB_565_SkColorType:      p->append(SkRasterPipeline::store_565,     ctx); break;
280        case kARGB_4444_SkColorType:    p->append(SkRasterPipeline::store_4444,    ctx); break;
281        case kBGRA_8888_SkColorType:    p->append(SkRasterPipeline::store_bgra,    ctx); break;
282        case kRGBA_8888_SkColorType:    p->append(SkRasterPipeline::store_8888,    ctx); break;
283        case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::store_1010102, ctx); break;
284        case kRGBA_F16_SkColorType:     p->append(SkRasterPipeline::store_f16,     ctx); break;
285
286        case kRGB_888x_SkColorType:     p->append(SkRasterPipeline::force_opaque         );
287                                        p->append(SkRasterPipeline::store_8888,       ctx); break;
288        case kRGB_101010x_SkColorType:  p->append(SkRasterPipeline::force_opaque         );
289                                        p->append(SkRasterPipeline::store_1010102,    ctx); break;
290    }
291}
292
293void SkRasterPipelineBlitter::burst_shade(int x, int y, int w) {
294    SkASSERT(fBurstCtx);
295    if (w > SkToInt(fShaderBuffer.size())) {
296        fShaderBuffer.resize(w);
297    }
298    fBurstCtx->shadeSpan4f(x,y, fShaderBuffer.data(), w);
299    // We'll be reading from fShaderOutput.pixels + x, so back up by x.
300    fShaderOutput = SkJumper_MemoryCtx{ fShaderBuffer.data() - x, 0 };
301}
302
303void SkRasterPipelineBlitter::blitH(int x, int y, int w) {
304    this->blitRect(x,y,w,1);
305}
306
307void SkRasterPipelineBlitter::blitRect(int x, int y, int w, int h) {
308    if (fCanMemsetInBlitRect) {
309        for (int ylimit = y+h; y < ylimit; y++) {
310            switch (fDst.shiftPerPixel()) {
311                case 0:    memset  (fDst.writable_addr8 (x,y), fMemsetColor, w); break;
312                case 1: sk_memset16(fDst.writable_addr16(x,y), fMemsetColor, w); break;
313                case 2: sk_memset32(fDst.writable_addr32(x,y), fMemsetColor, w); break;
314                case 3: sk_memset64(fDst.writable_addr64(x,y), fMemsetColor, w); break;
315                default: break;
316            }
317        }
318        return;
319    }
320
321    if (!fBlitRect) {
322        SkRasterPipeline p(fAlloc);
323        p.extend(fColorPipeline);
324        if (fBlend == SkBlendMode::kSrcOver
325                && (fDst.info().colorType() == kRGBA_8888_SkColorType ||
326                    fDst.info().colorType() == kBGRA_8888_SkColorType)
327                && !fDst.colorSpace()
328                && fDst.info().alphaType() != kUnpremul_SkAlphaType
329                && fDitherRate == 0.0f) {
330            auto stage = fDst.info().colorType() == kRGBA_8888_SkColorType
331                       ? SkRasterPipeline::srcover_rgba_8888
332                       : SkRasterPipeline::srcover_bgra_8888;
333            p.append(stage, &fDstPtr);
334        } else {
335            if (fBlend != SkBlendMode::kSrc) {
336                this->append_load_dst(&p);
337                SkBlendMode_AppendStages(fBlend, &p);
338            }
339            this->append_store(&p);
340        }
341        fBlitRect = p.compile();
342    }
343
344    if (fBurstCtx) {
345        // We can only burst shade one row at a time.
346        for (int ylimit = y+h; y < ylimit; y++) {
347            this->burst_shade(x,y,w);
348            fBlitRect(x,y, w,1);
349        }
350    } else {
351        // If not bursting we can blit the entire rect at once.
352        fBlitRect(x,y,w,h);
353    }
354}
355
356void SkRasterPipelineBlitter::blitAntiH(int x, int y, const SkAlpha aa[], const int16_t runs[]) {
357    if (!fBlitAntiH) {
358        SkRasterPipeline p(fAlloc);
359        p.extend(fColorPipeline);
360        if (SkBlendMode_ShouldPreScaleCoverage(fBlend, /*rgb_coverage=*/false)) {
361            p.append(SkRasterPipeline::scale_1_float, &fCurrentCoverage);
362            this->append_load_dst(&p);
363            SkBlendMode_AppendStages(fBlend, &p);
364        } else {
365            this->append_load_dst(&p);
366            SkBlendMode_AppendStages(fBlend, &p);
367            p.append(SkRasterPipeline::lerp_1_float, &fCurrentCoverage);
368        }
369
370        this->append_store(&p);
371        fBlitAntiH = p.compile();
372    }
373
374    for (int16_t run = *runs; run > 0; run = *runs) {
375        switch (*aa) {
376            case 0x00:                       break;
377            case 0xff: this->blitH(x,y,run); break;
378            default:
379                fCurrentCoverage = *aa * (1/255.0f);
380                if (fBurstCtx) {
381                    this->burst_shade(x,y,run);
382                }
383                fBlitAntiH(x,y,run,1);
384        }
385        x    += run;
386        runs += run;
387        aa   += run;
388    }
389}
390
391void SkRasterPipelineBlitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
392    SkIRect clip = {x,y, x+2,y+1};
393    uint8_t coverage[] = { (uint8_t)a0, (uint8_t)a1 };
394
395    SkMask mask;
396    mask.fImage    = coverage;
397    mask.fBounds   = clip;
398    mask.fRowBytes = 2;
399    mask.fFormat   = SkMask::kA8_Format;
400
401    this->blitMask(mask, clip);
402}
403
404void SkRasterPipelineBlitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
405    SkIRect clip = {x,y, x+1,y+2};
406    uint8_t coverage[] = { (uint8_t)a0, (uint8_t)a1 };
407
408    SkMask mask;
409    mask.fImage    = coverage;
410    mask.fBounds   = clip;
411    mask.fRowBytes = 1;
412    mask.fFormat   = SkMask::kA8_Format;
413
414    this->blitMask(mask, clip);
415}
416
417void SkRasterPipelineBlitter::blitV(int x, int y, int height, SkAlpha alpha) {
418    SkIRect clip = {x,y, x+1,y+height};
419
420    SkMask mask;
421    mask.fImage    = &alpha;
422    mask.fBounds   = clip;
423    mask.fRowBytes = 0;     // so we reuse the 1 "row" for all of height
424    mask.fFormat   = SkMask::kA8_Format;
425
426    this->blitMask(mask, clip);
427}
428
429void SkRasterPipelineBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
430    if (mask.fFormat == SkMask::kBW_Format) {
431        // TODO: native BW masks?
432        return INHERITED::blitMask(mask, clip);
433    }
434
435    // We'll use the first (A8) plane of any mask and ignore the other two, just like Ganesh.
436    SkMask::Format effectiveMaskFormat = mask.fFormat == SkMask::k3D_Format ? SkMask::kA8_Format
437                                                                            : mask.fFormat;
438
439
440    // Lazily build whichever pipeline we need, specialized for each mask format.
441    if (effectiveMaskFormat == SkMask::kA8_Format && !fBlitMaskA8) {
442        SkRasterPipeline p(fAlloc);
443        p.extend(fColorPipeline);
444        if (SkBlendMode_ShouldPreScaleCoverage(fBlend, /*rgb_coverage=*/false)) {
445            p.append(SkRasterPipeline::scale_u8, &fMaskPtr);
446            this->append_load_dst(&p);
447            SkBlendMode_AppendStages(fBlend, &p);
448        } else {
449            this->append_load_dst(&p);
450            SkBlendMode_AppendStages(fBlend, &p);
451            p.append(SkRasterPipeline::lerp_u8, &fMaskPtr);
452        }
453        this->append_store(&p);
454        fBlitMaskA8 = p.compile();
455    }
456    if (effectiveMaskFormat == SkMask::kLCD16_Format && !fBlitMaskLCD16) {
457        SkRasterPipeline p(fAlloc);
458        p.extend(fColorPipeline);
459        if (SkBlendMode_ShouldPreScaleCoverage(fBlend, /*rgb_coverage=*/true)) {
460            // Somewhat unusually, scale_565 needs dst loaded first.
461            this->append_load_dst(&p);
462            p.append(SkRasterPipeline::scale_565, &fMaskPtr);
463            SkBlendMode_AppendStages(fBlend, &p);
464        } else {
465            this->append_load_dst(&p);
466            SkBlendMode_AppendStages(fBlend, &p);
467            p.append(SkRasterPipeline::lerp_565, &fMaskPtr);
468        }
469        this->append_store(&p);
470        fBlitMaskLCD16 = p.compile();
471    }
472
473    std::function<void(size_t,size_t,size_t,size_t)>* blitter = nullptr;
474    // Update fMaskPtr to point "into" this current mask, but lined up with fDstPtr at (0,0).
475    // mask.fRowBytes is a uint32_t, which would break our addressing math on 64-bit builds.
476    size_t rowBytes = mask.fRowBytes;
477    switch (effectiveMaskFormat) {
478        case SkMask::kA8_Format:
479            fMaskPtr.stride = rowBytes;
480            fMaskPtr.pixels = (uint8_t*)(mask.fImage - mask.fBounds.left() * (size_t)1
481                                                     - mask.fBounds.top()  * rowBytes);
482            blitter = &fBlitMaskA8;
483            break;
484        case SkMask::kLCD16_Format:
485            fMaskPtr.stride = rowBytes / 2;
486            fMaskPtr.pixels = (uint16_t*)(mask.fImage - mask.fBounds.left() * (size_t)2
487                                                      - mask.fBounds.top()  * rowBytes);
488            blitter = &fBlitMaskLCD16;
489            break;
490        default:
491            return;
492    }
493
494    SkASSERT(blitter);
495    if (fBurstCtx) {
496        // We can only burst shade one row at a time.
497        int x = clip.left();
498        for (int y = clip.top(); y < clip.bottom(); y++) {
499            this->burst_shade(x,y,clip.width());
500            (*blitter)(x,y, clip.width(),1);
501        }
502    } else {
503        // If not bursting we can blit the entire mask at once.
504        (*blitter)(clip.left(),clip.top(), clip.width(),clip.height());
505    }
506}
507