SkPictureUtils.cpp revision 4585144956e6d383115704181470d8436fc9829d
1/* 2 * Copyright 2012 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 "SkBitmapDevice.h" 9#include "SkCanvas.h" 10#include "SkData.h" 11#include "SkNoSaveLayerCanvas.h" 12#include "SkPictureUtils.h" 13#include "SkPixelRef.h" 14#include "SkRRect.h" 15#include "SkShader.h" 16 17class PixelRefSet { 18public: 19 PixelRefSet(SkTDArray<SkPixelRef*>* array) : fArray(array) {} 20 21 // This does a linear search on existing pixelrefs, so if this list gets big 22 // we should use a more complex sorted/hashy thing. 23 // 24 void add(SkPixelRef* pr) { 25 uint32_t genID = pr->getGenerationID(); 26 if (fGenID.find(genID) < 0) { 27 *fArray->append() = pr; 28 *fGenID.append() = genID; 29// SkDebugf("--- adding [%d] %x %d\n", fArray->count() - 1, pr, genID); 30 } else { 31// SkDebugf("--- already have %x %d\n", pr, genID); 32 } 33 } 34 35private: 36 SkTDArray<SkPixelRef*>* fArray; 37 SkTDArray<uint32_t> fGenID; 38}; 39 40static void not_supported() { 41 SkDEBUGFAIL("this method should never be called"); 42} 43 44static void nothing_to_do() {} 45 46/** 47 * This device will route all bitmaps (primitives and in shaders) to its PRSet. 48 * It should never actually draw anything, so there need not be any pixels 49 * behind its device. 50 */ 51class GatherPixelRefDevice : public SkBaseDevice { 52public: 53 SK_DECLARE_INST_COUNT(GatherPixelRefDevice) 54 55 GatherPixelRefDevice(int width, int height, PixelRefSet* prset) { 56 fSize.set(width, height); 57 fEmptyBitmap.setInfo(SkImageInfo::MakeUnknown(width, height)); 58 fPRSet = prset; 59 } 60 61 virtual int width() const SK_OVERRIDE { return fSize.width(); } 62 virtual int height() const SK_OVERRIDE { return fSize.height(); } 63 virtual bool isOpaque() const SK_OVERRIDE { return false; } 64 virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE { return NULL; } 65 virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE { 66 return false; 67 } 68 // TODO: allow this call to return failure, or move to SkBitmapDevice only. 69 virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE { 70 return fEmptyBitmap; 71 } 72 virtual void lockPixels() SK_OVERRIDE { nothing_to_do(); } 73 virtual void unlockPixels() SK_OVERRIDE { nothing_to_do(); } 74 virtual bool allowImageFilter(const SkImageFilter*) SK_OVERRIDE { return false; } 75 virtual bool canHandleImageFilter(const SkImageFilter*) SK_OVERRIDE { return false; } 76 virtual bool filterImage(const SkImageFilter*, const SkBitmap&, const SkImageFilter::Context&, 77 SkBitmap* result, SkIPoint* offset) SK_OVERRIDE { 78 return false; 79 } 80 81 virtual void clear(SkColor color) SK_OVERRIDE { 82 nothing_to_do(); 83 } 84 85 virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE { 86 this->addBitmapFromPaint(paint); 87 } 88 virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count, 89 const SkPoint[], const SkPaint& paint) SK_OVERRIDE { 90 this->addBitmapFromPaint(paint); 91 } 92 virtual void drawRect(const SkDraw&, const SkRect&, 93 const SkPaint& paint) SK_OVERRIDE { 94 this->addBitmapFromPaint(paint); 95 } 96 virtual void drawRRect(const SkDraw&, const SkRRect&, 97 const SkPaint& paint) SK_OVERRIDE { 98 this->addBitmapFromPaint(paint); 99 } 100 virtual void drawOval(const SkDraw&, const SkRect&, 101 const SkPaint& paint) SK_OVERRIDE { 102 this->addBitmapFromPaint(paint); 103 } 104 virtual void drawPath(const SkDraw&, const SkPath& path, 105 const SkPaint& paint, const SkMatrix* prePathMatrix, 106 bool pathIsMutable) SK_OVERRIDE { 107 this->addBitmapFromPaint(paint); 108 } 109 virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap, 110 const SkMatrix&, const SkPaint& paint) SK_OVERRIDE { 111 this->addBitmap(bitmap); 112 if (kAlpha_8_SkColorType == bitmap.colorType()) { 113 this->addBitmapFromPaint(paint); 114 } 115 } 116 virtual void drawBitmapRect(const SkDraw&, const SkBitmap& bitmap, 117 const SkRect* srcOrNull, const SkRect& dst, 118 const SkPaint& paint, 119 SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE { 120 this->addBitmap(bitmap); 121 if (kAlpha_8_SkColorType == bitmap.colorType()) { 122 this->addBitmapFromPaint(paint); 123 } 124 } 125 virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap, 126 int x, int y, const SkPaint& paint) SK_OVERRIDE { 127 this->addBitmap(bitmap); 128 } 129 virtual void drawText(const SkDraw&, const void* text, size_t len, 130 SkScalar x, SkScalar y, 131 const SkPaint& paint) SK_OVERRIDE { 132 this->addBitmapFromPaint(paint); 133 } 134 virtual void drawPosText(const SkDraw&, const void* text, size_t len, 135 const SkScalar pos[], SkScalar constY, 136 int, const SkPaint& paint) SK_OVERRIDE { 137 this->addBitmapFromPaint(paint); 138 } 139 virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len, 140 const SkPath& path, const SkMatrix* matrix, 141 const SkPaint& paint) SK_OVERRIDE { 142 this->addBitmapFromPaint(paint); 143 } 144 virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount, 145 const SkPoint verts[], const SkPoint texs[], 146 const SkColor colors[], SkXfermode* xmode, 147 const uint16_t indices[], int indexCount, 148 const SkPaint& paint) SK_OVERRIDE { 149 this->addBitmapFromPaint(paint); 150 } 151 virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, 152 const SkPaint&) SK_OVERRIDE { 153 nothing_to_do(); 154 } 155 156protected: 157 virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE { 158 not_supported(); 159 } 160 virtual SkBaseDevice* onCreateDevice(const SkImageInfo& info, Usage usage) SK_OVERRIDE { 161 // we expect to only get called via savelayer, in which case it is fine. 162 SkASSERT(kSaveLayer_Usage == usage); 163 return SkNEW_ARGS(GatherPixelRefDevice, (info.width(), info.height(), fPRSet)); 164 } 165 virtual void flush() SK_OVERRIDE {} 166 167private: 168 PixelRefSet* fPRSet; 169 SkBitmap fEmptyBitmap; // legacy -- need to remove the need for this guy 170 SkISize fSize; 171 172 void addBitmap(const SkBitmap& bm) { 173 fPRSet->add(bm.pixelRef()); 174 } 175 176 void addBitmapFromPaint(const SkPaint& paint) { 177 SkShader* shader = paint.getShader(); 178 if (shader) { 179 SkBitmap bm; 180 // Check whether the shader is a gradient in order to short-circuit 181 // call to asABitmap to prevent generation of bitmaps from 182 // gradient shaders, which implement asABitmap. 183 if (SkShader::kNone_GradientType == shader->asAGradient(NULL) && 184 shader->asABitmap(&bm, NULL, NULL)) { 185 fPRSet->add(bm.pixelRef()); 186 } 187 } 188 } 189 190 typedef SkBaseDevice INHERITED; 191}; 192 193SkData* SkPictureUtils::GatherPixelRefs(SkPicture* pict, const SkRect& area) { 194 if (NULL == pict) { 195 return NULL; 196 } 197 198 // this test also handles if either area or pict's width/height are empty 199 if (!SkRect::Intersects(area, 200 SkRect::MakeWH(SkIntToScalar(pict->width()), 201 SkIntToScalar(pict->height())))) { 202 return NULL; 203 } 204 205 SkTDArray<SkPixelRef*> array; 206 PixelRefSet prset(&array); 207 208 GatherPixelRefDevice device(pict->width(), pict->height(), &prset); 209 SkNoSaveLayerCanvas canvas(&device); 210 211 canvas.clipRect(area, SkRegion::kIntersect_Op, false); 212 canvas.drawPicture(pict); 213 214 SkData* data = NULL; 215 int count = array.count(); 216 if (count > 0) { 217 data = SkData::NewFromMalloc(array.detach(), count * sizeof(SkPixelRef*)); 218 } 219 return data; 220} 221