1/*
2 * Copyright 2013 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 "SkCanvasStateUtils.h"
9
10#include "SkBitmapDevice.h"
11#include "SkCanvas.h"
12#include "SkCanvasStack.h"
13#include "SkErrorInternals.h"
14#include "SkWriter32.h"
15
16/*
17 * WARNING: The structs below are part of a stable ABI and as such we explicitly
18 * use unambigious primitives (e.g. int32_t instead of an enum).
19 *
20 * ANY CHANGES TO THE STRUCTS BELOW THAT IMPACT THE ABI SHOULD RESULT IN A NEW
21 * NEW SUBCLASS OF SkCanvasState. SUCH CHANGES SHOULD ONLY BE MADE IF ABSOLUTELY
22 * NECESSARY!
23 *
24 * In order to test changes, run the CanvasState tests. gyp/canvas_state_lib.gyp
25 * describes how to create a library to pass to the CanvasState tests. The tests
26 * should succeed when building the library with your changes and passing that to
27 * the tests running in the unchanged Skia.
28 */
29enum RasterConfigs {
30  kUnknown_RasterConfig   = 0,
31  kRGB_565_RasterConfig   = 1,
32  kARGB_8888_RasterConfig = 2
33};
34typedef int32_t RasterConfig;
35
36enum CanvasBackends {
37    kUnknown_CanvasBackend = 0,
38    kRaster_CanvasBackend  = 1,
39    kGPU_CanvasBackend     = 2,
40    kPDF_CanvasBackend     = 3
41};
42typedef int32_t CanvasBackend;
43
44struct ClipRect {
45    int32_t left, top, right, bottom;
46};
47
48struct SkMCState {
49    float matrix[9];
50    // NOTE: this only works for non-antialiased clips
51    int32_t clipRectCount;
52    ClipRect* clipRects;
53};
54
55// NOTE: If you add more members, create a new subclass of SkCanvasState with a
56// new CanvasState::version.
57struct SkCanvasLayerState {
58    CanvasBackend type;
59    int32_t x, y;
60    int32_t width;
61    int32_t height;
62
63    SkMCState mcState;
64
65    union {
66        struct {
67            RasterConfig config; // pixel format: a value from RasterConfigs.
68            uint64_t rowBytes;   // Number of bytes from start of one line to next.
69            void* pixels;        // The pixels, all (height * rowBytes) of them.
70        } raster;
71        struct {
72            int32_t textureID;
73        } gpu;
74    };
75};
76
77class SkCanvasState {
78public:
79    SkCanvasState(int32_t version, SkCanvas* canvas) {
80        SkASSERT(canvas);
81        this->version = version;
82        width = canvas->getBaseLayerSize().width();
83        height = canvas->getBaseLayerSize().height();
84
85    }
86
87    /**
88     * The version this struct was built with.  This field must always appear
89     * first in the struct so that when the versions don't match (and the
90     * remaining contents and size are potentially different) we can still
91     * compare the version numbers.
92     */
93    int32_t version;
94    int32_t width;
95    int32_t height;
96    int32_t alignmentPadding;
97};
98
99class SkCanvasState_v1 : public SkCanvasState {
100public:
101    static const int32_t kVersion = 1;
102
103    SkCanvasState_v1(SkCanvas* canvas)
104    : INHERITED(kVersion, canvas)
105    {
106        layerCount = 0;
107        layers = NULL;
108        mcState.clipRectCount = 0;
109        mcState.clipRects = NULL;
110        originalCanvas = SkRef(canvas);
111    }
112
113    ~SkCanvasState_v1() {
114        // loop through the layers and free the data allocated to the clipRects
115        for (int i = 0; i < layerCount; ++i) {
116            sk_free(layers[i].mcState.clipRects);
117        }
118
119        sk_free(mcState.clipRects);
120        sk_free(layers);
121
122        // it is now safe to free the canvas since there should be no remaining
123        // references to the content that is referenced by this canvas (e.g. pixels)
124        originalCanvas->unref();
125    }
126
127    SkMCState mcState;
128
129    int32_t layerCount;
130    SkCanvasLayerState* layers;
131private:
132    SkCanvas* originalCanvas;
133    typedef SkCanvasState INHERITED;
134};
135
136////////////////////////////////////////////////////////////////////////////////
137
138class ClipValidator : public SkCanvas::ClipVisitor {
139public:
140    ClipValidator() : fFailed(false) {}
141    bool failed() { return fFailed; }
142
143    // ClipVisitor
144    virtual void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
145        fFailed |= antialias;
146    }
147
148    virtual void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
149        fFailed |= antialias;
150    }
151
152    virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) SK_OVERRIDE {
153        fFailed |= antialias;
154    }
155
156private:
157    bool fFailed;
158};
159
160static void setup_MC_state(SkMCState* state, const SkMatrix& matrix, const SkRegion& clip) {
161    // initialize the struct
162    state->clipRectCount = 0;
163
164    // capture the matrix
165    for (int i = 0; i < 9; i++) {
166        state->matrix[i] = matrix.get(i);
167    }
168
169    /*
170     * capture the clip
171     *
172     * storage is allocated on the stack for the first 4 rects. This value was
173     * chosen somewhat arbitrarily, but does allow us to represent simple clips
174     * and some more common complex clips (e.g. a clipRect with a sub-rect
175     * clipped out of its interior) without needing to malloc any additional memory.
176     */
177    SkSWriter32<4*sizeof(ClipRect)> clipWriter;
178
179    if (!clip.isEmpty()) {
180        // only returns the b/w clip so aa clips fail
181        SkRegion::Iterator clip_iterator(clip);
182        for (; !clip_iterator.done(); clip_iterator.next()) {
183            // this assumes the SkIRect is stored in l,t,r,b ordering which
184            // matches the ordering of our ClipRect struct
185            clipWriter.writeIRect(clip_iterator.rect());
186            state->clipRectCount++;
187        }
188    }
189
190    // allocate memory for the clip then and copy them to the struct
191    state->clipRects = (ClipRect*) sk_malloc_throw(clipWriter.bytesWritten());
192    clipWriter.flatten(state->clipRects);
193}
194
195
196
197SkCanvasState* SkCanvasStateUtils::CaptureCanvasState(SkCanvas* canvas) {
198    SkASSERT(canvas);
199
200    // Check the clip can be decomposed into rectangles (i.e. no soft clips).
201    ClipValidator validator;
202    canvas->replayClips(&validator);
203    if (validator.failed()) {
204        SkErrorInternals::SetError(kInvalidOperation_SkError,
205                "CaptureCanvasState does not support canvases with antialiased clips.\n");
206        return NULL;
207    }
208
209    SkAutoTDelete<SkCanvasState_v1> canvasState(SkNEW_ARGS(SkCanvasState_v1, (canvas)));
210
211    // decompose the total matrix and clip
212    setup_MC_state(&canvasState->mcState, canvas->getTotalMatrix(),
213                   canvas->internal_private_getTotalClip());
214
215    /*
216     * decompose the layers
217     *
218     * storage is allocated on the stack for the first 3 layers. It is common in
219     * some view systems (e.g. Android) that a few non-clipped layers are present
220     * and we will not need to malloc any additional memory in those cases.
221     */
222    SkSWriter32<3*sizeof(SkCanvasLayerState)> layerWriter;
223    int layerCount = 0;
224    for (SkCanvas::LayerIter layer(canvas, true/*skipEmptyClips*/); !layer.done(); layer.next()) {
225
226        // we currently only work for bitmap backed devices
227        const SkBitmap& bitmap = layer.device()->accessBitmap(true/*changePixels*/);
228        if (bitmap.empty() || bitmap.isNull() || !bitmap.lockPixelsAreWritable()) {
229            return NULL;
230        }
231
232        SkCanvasLayerState* layerState =
233                (SkCanvasLayerState*) layerWriter.reserve(sizeof(SkCanvasLayerState));
234        layerState->type = kRaster_CanvasBackend;
235        layerState->x = layer.x();
236        layerState->y = layer.y();
237        layerState->width = bitmap.width();
238        layerState->height = bitmap.height();
239
240        switch (bitmap.colorType()) {
241            case kN32_SkColorType:
242                layerState->raster.config = kARGB_8888_RasterConfig;
243                break;
244            case kRGB_565_SkColorType:
245                layerState->raster.config = kRGB_565_RasterConfig;
246                break;
247            default:
248                return NULL;
249        }
250        layerState->raster.rowBytes = bitmap.rowBytes();
251        layerState->raster.pixels = bitmap.getPixels();
252
253        setup_MC_state(&layerState->mcState, layer.matrix(), layer.clip());
254        layerCount++;
255    }
256
257    // allocate memory for the layers and then and copy them to the struct
258    SkASSERT(layerWriter.bytesWritten() == layerCount * sizeof(SkCanvasLayerState));
259    canvasState->layerCount = layerCount;
260    canvasState->layers = (SkCanvasLayerState*) sk_malloc_throw(layerWriter.bytesWritten());
261    layerWriter.flatten(canvasState->layers);
262
263    // for now, just ignore any client supplied DrawFilter.
264    if (canvas->getDrawFilter()) {
265//        SkDEBUGF(("CaptureCanvasState will ignore the canvas's draw filter.\n"));
266    }
267
268    return canvasState.detach();
269}
270
271////////////////////////////////////////////////////////////////////////////////
272
273static void setup_canvas_from_MC_state(const SkMCState& state, SkCanvas* canvas) {
274    // reconstruct the matrix
275    SkMatrix matrix;
276    for (int i = 0; i < 9; i++) {
277        matrix.set(i, state.matrix[i]);
278    }
279
280    // reconstruct the clip
281    SkRegion clip;
282    for (int i = 0; i < state.clipRectCount; ++i) {
283        clip.op(SkIRect::MakeLTRB(state.clipRects[i].left,
284                                  state.clipRects[i].top,
285                                  state.clipRects[i].right,
286                                  state.clipRects[i].bottom),
287                SkRegion::kUnion_Op);
288    }
289
290    canvas->setMatrix(matrix);
291    canvas->setClipRegion(clip);
292}
293
294static SkCanvas* create_canvas_from_canvas_layer(const SkCanvasLayerState& layerState) {
295    SkASSERT(kRaster_CanvasBackend == layerState.type);
296
297    SkBitmap bitmap;
298    SkColorType colorType =
299        layerState.raster.config == kARGB_8888_RasterConfig ? kN32_SkColorType :
300        layerState.raster.config == kRGB_565_RasterConfig ? kRGB_565_SkColorType :
301        kUnknown_SkColorType;
302
303    if (colorType == kUnknown_SkColorType) {
304        return NULL;
305    }
306
307    bitmap.installPixels(SkImageInfo::Make(layerState.width, layerState.height,
308                                           colorType, kPremul_SkAlphaType),
309                         layerState.raster.pixels, (size_t) layerState.raster.rowBytes);
310
311    SkASSERT(!bitmap.empty());
312    SkASSERT(!bitmap.isNull());
313
314    SkAutoTUnref<SkCanvas> canvas(SkNEW_ARGS(SkCanvas, (bitmap)));
315
316    // setup the matrix and clip
317    setup_canvas_from_MC_state(layerState.mcState, canvas.get());
318
319    return canvas.detach();
320}
321
322SkCanvas* SkCanvasStateUtils::CreateFromCanvasState(const SkCanvasState* state) {
323    SkASSERT(state);
324    // Currently there is only one possible version.
325    SkASSERT(SkCanvasState_v1::kVersion == state->version);
326
327    const SkCanvasState_v1* state_v1 = static_cast<const SkCanvasState_v1*>(state);
328
329    if (state_v1->layerCount < 1) {
330        return NULL;
331    }
332
333    SkAutoTUnref<SkCanvasStack> canvas(SkNEW_ARGS(SkCanvasStack, (state->width, state->height)));
334
335    // setup the matrix and clip on the n-way canvas
336    setup_canvas_from_MC_state(state_v1->mcState, canvas);
337
338    // Iterate over the layers and add them to the n-way canvas
339    for (int i = state_v1->layerCount - 1; i >= 0; --i) {
340        SkAutoTUnref<SkCanvas> canvasLayer(create_canvas_from_canvas_layer(state_v1->layers[i]));
341        if (!canvasLayer.get()) {
342            return NULL;
343        }
344        canvas->pushCanvas(canvasLayer.get(), SkIPoint::Make(state_v1->layers[i].x,
345                                                             state_v1->layers[i].y));
346    }
347
348    return canvas.detach();
349}
350
351////////////////////////////////////////////////////////////////////////////////
352
353void SkCanvasStateUtils::ReleaseCanvasState(SkCanvasState* state) {
354    SkASSERT(!state || SkCanvasState_v1::kVersion == state->version);
355    // Upcast to the correct version of SkCanvasState. This avoids having a virtual destructor on
356    // SkCanvasState. That would be strange since SkCanvasState has no other virtual functions, and
357    // instead uses the field "version" to determine how to behave.
358    SkDELETE(static_cast<SkCanvasState_v1*>(state));
359}
360