| /* | |
| * Copyright 2013 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "SkCanvasStateUtils.h" | |
| #include "SkBitmapDevice.h" | |
| #include "SkCanvas.h" | |
| #include "SkCanvasStack.h" | |
| #include "SkErrorInternals.h" | |
| #include "SkWriter32.h" | |
| /* | |
| * WARNING: The structs below are part of a stable ABI and as such we explicitly | |
| * use unambigious primitives (e.g. int32_t instead of an enum). | |
| * | |
| * ANY CHANGES TO THE STRUCTS BELOW THAT IMPACT THE ABI SHOULD RESULT IN A NEW | |
| * NEW SUBCLASS OF SkCanvasState. SUCH CHANGES SHOULD ONLY BE MADE IF ABSOLUTELY | |
| * NECESSARY! | |
| * | |
| * In order to test changes, run the CanvasState tests. gyp/canvas_state_lib.gyp | |
| * describes how to create a library to pass to the CanvasState tests. The tests | |
| * should succeed when building the library with your changes and passing that to | |
| * the tests running in the unchanged Skia. | |
| */ | |
| enum RasterConfigs { | |
| kUnknown_RasterConfig = 0, | |
| kRGB_565_RasterConfig = 1, | |
| kARGB_8888_RasterConfig = 2 | |
| }; | |
| typedef int32_t RasterConfig; | |
| enum CanvasBackends { | |
| kUnknown_CanvasBackend = 0, | |
| kRaster_CanvasBackend = 1, | |
| kGPU_CanvasBackend = 2, | |
| kPDF_CanvasBackend = 3 | |
| }; | |
| typedef int32_t CanvasBackend; | |
| struct ClipRect { | |
| int32_t left, top, right, bottom; | |
| }; | |
| struct SkMCState { | |
| float matrix[9]; | |
| // NOTE: this only works for non-antialiased clips | |
| int32_t clipRectCount; | |
| ClipRect* clipRects; | |
| }; | |
| // NOTE: If you add more members, create a new subclass of SkCanvasState with a | |
| // new CanvasState::version. | |
| struct SkCanvasLayerState { | |
| CanvasBackend type; | |
| int32_t x, y; | |
| int32_t width; | |
| int32_t height; | |
| SkMCState mcState; | |
| union { | |
| struct { | |
| RasterConfig config; // pixel format: a value from RasterConfigs. | |
| uint64_t rowBytes; // Number of bytes from start of one line to next. | |
| void* pixels; // The pixels, all (height * rowBytes) of them. | |
| } raster; | |
| struct { | |
| int32_t textureID; | |
| } gpu; | |
| }; | |
| }; | |
| class SkCanvasState { | |
| public: | |
| SkCanvasState(int32_t version, SkCanvas* canvas) { | |
| SkASSERT(canvas); | |
| this->version = version; | |
| width = canvas->getBaseLayerSize().width(); | |
| height = canvas->getBaseLayerSize().height(); | |
| } | |
| /** | |
| * The version this struct was built with. This field must always appear | |
| * first in the struct so that when the versions don't match (and the | |
| * remaining contents and size are potentially different) we can still | |
| * compare the version numbers. | |
| */ | |
| int32_t version; | |
| int32_t width; | |
| int32_t height; | |
| int32_t alignmentPadding; | |
| }; | |
| class SkCanvasState_v1 : public SkCanvasState { | |
| public: | |
| static const int32_t kVersion = 1; | |
| SkCanvasState_v1(SkCanvas* canvas) | |
| : INHERITED(kVersion, canvas) | |
| { | |
| layerCount = 0; | |
| layers = NULL; | |
| mcState.clipRectCount = 0; | |
| mcState.clipRects = NULL; | |
| originalCanvas = SkRef(canvas); | |
| } | |
| ~SkCanvasState_v1() { | |
| // loop through the layers and free the data allocated to the clipRects | |
| for (int i = 0; i < layerCount; ++i) { | |
| sk_free(layers[i].mcState.clipRects); | |
| } | |
| sk_free(mcState.clipRects); | |
| sk_free(layers); | |
| // it is now safe to free the canvas since there should be no remaining | |
| // references to the content that is referenced by this canvas (e.g. pixels) | |
| originalCanvas->unref(); | |
| } | |
| SkMCState mcState; | |
| int32_t layerCount; | |
| SkCanvasLayerState* layers; | |
| private: | |
| SkCanvas* originalCanvas; | |
| typedef SkCanvasState INHERITED; | |
| }; | |
| //////////////////////////////////////////////////////////////////////////////// | |
| class ClipValidator : public SkCanvas::ClipVisitor { | |
| public: | |
| ClipValidator() : fFailed(false) {} | |
| bool failed() { return fFailed; } | |
| // ClipVisitor | |
| virtual void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) SK_OVERRIDE { | |
| fFailed |= antialias; | |
| } | |
| virtual void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) SK_OVERRIDE { | |
| fFailed |= antialias; | |
| } | |
| virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) SK_OVERRIDE { | |
| fFailed |= antialias; | |
| } | |
| private: | |
| bool fFailed; | |
| }; | |
| static void setup_MC_state(SkMCState* state, const SkMatrix& matrix, const SkRegion& clip) { | |
| // initialize the struct | |
| state->clipRectCount = 0; | |
| // capture the matrix | |
| for (int i = 0; i < 9; i++) { | |
| state->matrix[i] = matrix.get(i); | |
| } | |
| /* | |
| * capture the clip | |
| * | |
| * storage is allocated on the stack for the first 4 rects. This value was | |
| * chosen somewhat arbitrarily, but does allow us to represent simple clips | |
| * and some more common complex clips (e.g. a clipRect with a sub-rect | |
| * clipped out of its interior) without needing to malloc any additional memory. | |
| */ | |
| SkSWriter32<4*sizeof(ClipRect)> clipWriter; | |
| if (!clip.isEmpty()) { | |
| // only returns the b/w clip so aa clips fail | |
| SkRegion::Iterator clip_iterator(clip); | |
| for (; !clip_iterator.done(); clip_iterator.next()) { | |
| // this assumes the SkIRect is stored in l,t,r,b ordering which | |
| // matches the ordering of our ClipRect struct | |
| clipWriter.writeIRect(clip_iterator.rect()); | |
| state->clipRectCount++; | |
| } | |
| } | |
| // allocate memory for the clip then and copy them to the struct | |
| state->clipRects = (ClipRect*) sk_malloc_throw(clipWriter.bytesWritten()); | |
| clipWriter.flatten(state->clipRects); | |
| } | |
| SkCanvasState* SkCanvasStateUtils::CaptureCanvasState(SkCanvas* canvas) { | |
| SkASSERT(canvas); | |
| // Check the clip can be decomposed into rectangles (i.e. no soft clips). | |
| ClipValidator validator; | |
| canvas->replayClips(&validator); | |
| if (validator.failed()) { | |
| SkErrorInternals::SetError(kInvalidOperation_SkError, | |
| "CaptureCanvasState does not support canvases with antialiased clips.\n"); | |
| return NULL; | |
| } | |
| SkAutoTDelete<SkCanvasState_v1> canvasState(SkNEW_ARGS(SkCanvasState_v1, (canvas))); | |
| // decompose the total matrix and clip | |
| setup_MC_state(&canvasState->mcState, canvas->getTotalMatrix(), | |
| canvas->internal_private_getTotalClip()); | |
| /* | |
| * decompose the layers | |
| * | |
| * storage is allocated on the stack for the first 3 layers. It is common in | |
| * some view systems (e.g. Android) that a few non-clipped layers are present | |
| * and we will not need to malloc any additional memory in those cases. | |
| */ | |
| SkSWriter32<3*sizeof(SkCanvasLayerState)> layerWriter; | |
| int layerCount = 0; | |
| for (SkCanvas::LayerIter layer(canvas, true/*skipEmptyClips*/); !layer.done(); layer.next()) { | |
| // we currently only work for bitmap backed devices | |
| const SkBitmap& bitmap = layer.device()->accessBitmap(true/*changePixels*/); | |
| if (bitmap.empty() || bitmap.isNull() || !bitmap.lockPixelsAreWritable()) { | |
| return NULL; | |
| } | |
| SkCanvasLayerState* layerState = | |
| (SkCanvasLayerState*) layerWriter.reserve(sizeof(SkCanvasLayerState)); | |
| layerState->type = kRaster_CanvasBackend; | |
| layerState->x = layer.x(); | |
| layerState->y = layer.y(); | |
| layerState->width = bitmap.width(); | |
| layerState->height = bitmap.height(); | |
| switch (bitmap.colorType()) { | |
| case kN32_SkColorType: | |
| layerState->raster.config = kARGB_8888_RasterConfig; | |
| break; | |
| case kRGB_565_SkColorType: | |
| layerState->raster.config = kRGB_565_RasterConfig; | |
| break; | |
| default: | |
| return NULL; | |
| } | |
| layerState->raster.rowBytes = bitmap.rowBytes(); | |
| layerState->raster.pixels = bitmap.getPixels(); | |
| setup_MC_state(&layerState->mcState, layer.matrix(), layer.clip()); | |
| layerCount++; | |
| } | |
| // allocate memory for the layers and then and copy them to the struct | |
| SkASSERT(layerWriter.bytesWritten() == layerCount * sizeof(SkCanvasLayerState)); | |
| canvasState->layerCount = layerCount; | |
| canvasState->layers = (SkCanvasLayerState*) sk_malloc_throw(layerWriter.bytesWritten()); | |
| layerWriter.flatten(canvasState->layers); | |
| // for now, just ignore any client supplied DrawFilter. | |
| if (canvas->getDrawFilter()) { | |
| // SkDEBUGF(("CaptureCanvasState will ignore the canvas's draw filter.\n")); | |
| } | |
| return canvasState.detach(); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| static void setup_canvas_from_MC_state(const SkMCState& state, SkCanvas* canvas) { | |
| // reconstruct the matrix | |
| SkMatrix matrix; | |
| for (int i = 0; i < 9; i++) { | |
| matrix.set(i, state.matrix[i]); | |
| } | |
| // reconstruct the clip | |
| SkRegion clip; | |
| for (int i = 0; i < state.clipRectCount; ++i) { | |
| clip.op(SkIRect::MakeLTRB(state.clipRects[i].left, | |
| state.clipRects[i].top, | |
| state.clipRects[i].right, | |
| state.clipRects[i].bottom), | |
| SkRegion::kUnion_Op); | |
| } | |
| canvas->setMatrix(matrix); | |
| canvas->setClipRegion(clip); | |
| } | |
| static SkCanvas* create_canvas_from_canvas_layer(const SkCanvasLayerState& layerState) { | |
| SkASSERT(kRaster_CanvasBackend == layerState.type); | |
| SkBitmap bitmap; | |
| SkColorType colorType = | |
| layerState.raster.config == kARGB_8888_RasterConfig ? kN32_SkColorType : | |
| layerState.raster.config == kRGB_565_RasterConfig ? kRGB_565_SkColorType : | |
| kUnknown_SkColorType; | |
| if (colorType == kUnknown_SkColorType) { | |
| return NULL; | |
| } | |
| bitmap.installPixels(SkImageInfo::Make(layerState.width, layerState.height, | |
| colorType, kPremul_SkAlphaType), | |
| layerState.raster.pixels, (size_t) layerState.raster.rowBytes); | |
| SkASSERT(!bitmap.empty()); | |
| SkASSERT(!bitmap.isNull()); | |
| SkAutoTUnref<SkCanvas> canvas(SkNEW_ARGS(SkCanvas, (bitmap))); | |
| // setup the matrix and clip | |
| setup_canvas_from_MC_state(layerState.mcState, canvas.get()); | |
| return canvas.detach(); | |
| } | |
| SkCanvas* SkCanvasStateUtils::CreateFromCanvasState(const SkCanvasState* state) { | |
| SkASSERT(state); | |
| // Currently there is only one possible version. | |
| SkASSERT(SkCanvasState_v1::kVersion == state->version); | |
| const SkCanvasState_v1* state_v1 = static_cast<const SkCanvasState_v1*>(state); | |
| if (state_v1->layerCount < 1) { | |
| return NULL; | |
| } | |
| SkAutoTUnref<SkCanvasStack> canvas(SkNEW_ARGS(SkCanvasStack, (state->width, state->height))); | |
| // setup the matrix and clip on the n-way canvas | |
| setup_canvas_from_MC_state(state_v1->mcState, canvas); | |
| // Iterate over the layers and add them to the n-way canvas | |
| for (int i = state_v1->layerCount - 1; i >= 0; --i) { | |
| SkAutoTUnref<SkCanvas> canvasLayer(create_canvas_from_canvas_layer(state_v1->layers[i])); | |
| if (!canvasLayer.get()) { | |
| return NULL; | |
| } | |
| canvas->pushCanvas(canvasLayer.get(), SkIPoint::Make(state_v1->layers[i].x, | |
| state_v1->layers[i].y)); | |
| } | |
| return canvas.detach(); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| void SkCanvasStateUtils::ReleaseCanvasState(SkCanvasState* state) { | |
| SkASSERT(!state || SkCanvasState_v1::kVersion == state->version); | |
| // Upcast to the correct version of SkCanvasState. This avoids having a virtual destructor on | |
| // SkCanvasState. That would be strange since SkCanvasState has no other virtual functions, and | |
| // instead uses the field "version" to determine how to behave. | |
| SkDELETE(static_cast<SkCanvasState_v1*>(state)); | |
| } |