2 * Copyright 2013 Google Inc.
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
8 #include "SkCanvasStateUtils.h"
10 #include "SkBitmapDevice.h"
12 #include "SkCanvasStack.h"
13 #include "SkErrorInternals.h"
14 #include "SkWriter32.h"
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).
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
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.
30 kUnknown_RasterConfig = 0,
31 kRGB_565_RasterConfig = 1,
32 kARGB_8888_RasterConfig = 2
34 typedef int32_t RasterConfig;
37 kUnknown_CanvasBackend = 0,
38 kRaster_CanvasBackend = 1,
39 kGPU_CanvasBackend = 2,
40 kPDF_CanvasBackend = 3
42 typedef int32_t CanvasBackend;
45 int32_t left, top, right, bottom;
50 // NOTE: this only works for non-antialiased clips
51 int32_t clipRectCount;
55 // NOTE: If you add more members, create a new subclass of SkCanvasState with a
56 // new CanvasState::version.
57 struct SkCanvasLayerState {
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.
79 SkCanvasState(int32_t version, SkCanvas* canvas) {
81 this->version = version;
82 width = canvas->getBaseLayerSize().width();
83 height = canvas->getBaseLayerSize().height();
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.
96 int32_t alignmentPadding;
99 class SkCanvasState_v1 : public SkCanvasState {
101 static const int32_t kVersion = 1;
103 SkCanvasState_v1(SkCanvas* canvas)
104 : INHERITED(kVersion, canvas)
108 mcState.clipRectCount = 0;
109 mcState.clipRects = NULL;
110 originalCanvas = SkRef(canvas);
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);
119 sk_free(mcState.clipRects);
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();
130 SkCanvasLayerState* layers;
132 SkCanvas* originalCanvas;
133 typedef SkCanvasState INHERITED;
136 ////////////////////////////////////////////////////////////////////////////////
138 class ClipValidator : public SkCanvas::ClipVisitor {
140 ClipValidator() : fFailed(false) {}
141 bool failed() { return fFailed; }
144 void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
145 fFailed |= antialias;
148 void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
149 fFailed |= antialias;
152 void clipPath(const SkPath&, SkRegion::Op, bool antialias) SK_OVERRIDE {
153 fFailed |= antialias;
160 static void setup_MC_state(SkMCState* state, const SkMatrix& matrix, const SkRegion& clip) {
161 // initialize the struct
162 state->clipRectCount = 0;
164 // capture the matrix
165 for (int i = 0; i < 9; i++) {
166 state->matrix[i] = matrix.get(i);
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.
177 SkSWriter32<4*sizeof(ClipRect)> clipWriter;
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++;
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);
197 SkCanvasState* SkCanvasStateUtils::CaptureCanvasState(SkCanvas* canvas) {
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");
209 SkAutoTDelete<SkCanvasState_v1> canvasState(SkNEW_ARGS(SkCanvasState_v1, (canvas)));
211 // decompose the total matrix and clip
212 setup_MC_state(&canvasState->mcState, canvas->getTotalMatrix(),
213 canvas->internal_private_getTotalClip());
216 * decompose the layers
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.
222 SkSWriter32<3*sizeof(SkCanvasLayerState)> layerWriter;
224 for (SkCanvas::LayerIter layer(canvas, true/*skipEmptyClips*/); !layer.done(); layer.next()) {
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()) {
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();
240 switch (bitmap.colorType()) {
241 case kN32_SkColorType:
242 layerState->raster.config = kARGB_8888_RasterConfig;
244 case kRGB_565_SkColorType:
245 layerState->raster.config = kRGB_565_RasterConfig;
250 layerState->raster.rowBytes = bitmap.rowBytes();
251 layerState->raster.pixels = bitmap.getPixels();
253 setup_MC_state(&layerState->mcState, layer.matrix(), layer.clip());
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);
263 // for now, just ignore any client supplied DrawFilter.
264 if (canvas->getDrawFilter()) {
265 // SkDEBUGF(("CaptureCanvasState will ignore the canvas's draw filter.\n"));
268 return canvasState.detach();
271 ////////////////////////////////////////////////////////////////////////////////
273 static void setup_canvas_from_MC_state(const SkMCState& state, SkCanvas* canvas) {
274 // reconstruct the matrix
276 for (int i = 0; i < 9; i++) {
277 matrix.set(i, state.matrix[i]);
280 // reconstruct the 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);
290 canvas->setMatrix(matrix);
291 canvas->setClipRegion(clip);
294 static SkCanvas* create_canvas_from_canvas_layer(const SkCanvasLayerState& layerState) {
295 SkASSERT(kRaster_CanvasBackend == layerState.type);
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;
303 if (colorType == kUnknown_SkColorType) {
307 bitmap.installPixels(SkImageInfo::Make(layerState.width, layerState.height,
308 colorType, kPremul_SkAlphaType),
309 layerState.raster.pixels, (size_t) layerState.raster.rowBytes);
311 SkASSERT(!bitmap.empty());
312 SkASSERT(!bitmap.isNull());
314 SkAutoTUnref<SkCanvas> canvas(SkNEW_ARGS(SkCanvas, (bitmap)));
316 // setup the matrix and clip
317 setup_canvas_from_MC_state(layerState.mcState, canvas.get());
319 return canvas.detach();
322 SkCanvas* SkCanvasStateUtils::CreateFromCanvasState(const SkCanvasState* state) {
324 // Currently there is only one possible version.
325 SkASSERT(SkCanvasState_v1::kVersion == state->version);
327 const SkCanvasState_v1* state_v1 = static_cast<const SkCanvasState_v1*>(state);
329 if (state_v1->layerCount < 1) {
333 SkAutoTUnref<SkCanvasStack> canvas(SkNEW_ARGS(SkCanvasStack, (state->width, state->height)));
335 // setup the matrix and clip on the n-way canvas
336 setup_canvas_from_MC_state(state_v1->mcState, canvas);
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()) {
344 canvas->pushCanvas(canvasLayer.get(), SkIPoint::Make(state_v1->layers[i].x,
345 state_v1->layers[i].y));
348 return canvas.detach();
351 ////////////////////////////////////////////////////////////////////////////////
353 void 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));