1
2 /*
3 * Copyright 2010 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10
11 #include "SkGrPixelRef.h"
12 #include "GrContext.h"
13 #include "GrTexture.h"
14 #include "SkGr.h"
15 #include "SkRect.h"
16
17 // since we call lockPixels recursively on fBitmap, we need a distinct mutex,
18 // to avoid deadlock with the default one provided by SkPixelRef.
19 SK_DECLARE_STATIC_MUTEX(gROLockPixelsPixelRefMutex);
20
SkROLockPixelsPixelRef()21 SkROLockPixelsPixelRef::SkROLockPixelsPixelRef() : INHERITED(&gROLockPixelsPixelRefMutex) {
22 }
23
~SkROLockPixelsPixelRef()24 SkROLockPixelsPixelRef::~SkROLockPixelsPixelRef() {
25 }
26
onLockPixels(SkColorTable ** ctable)27 void* SkROLockPixelsPixelRef::onLockPixels(SkColorTable** ctable) {
28 if (ctable) {
29 *ctable = NULL;
30 }
31 fBitmap.reset();
32 // SkDebugf("---------- calling readpixels in support of lockpixels\n");
33 if (!this->onReadPixels(&fBitmap, NULL)) {
34 SkDebugf("SkROLockPixelsPixelRef::onLockPixels failed!\n");
35 return NULL;
36 }
37 fBitmap.lockPixels();
38 return fBitmap.getPixels();
39 }
40
onUnlockPixels()41 void SkROLockPixelsPixelRef::onUnlockPixels() {
42 fBitmap.unlockPixels();
43 }
44
onLockPixelsAreWritable() const45 bool SkROLockPixelsPixelRef::onLockPixelsAreWritable() const {
46 return false;
47 }
48
49 ///////////////////////////////////////////////////////////////////////////////
50
copyToTexturePixelRef(GrTexture * texture,SkBitmap::Config dstConfig,const SkIRect * subset)51 static SkGrPixelRef* copyToTexturePixelRef(GrTexture* texture, SkBitmap::Config dstConfig,
52 const SkIRect* subset) {
53 if (NULL == texture) {
54 return NULL;
55 }
56 GrContext* context = texture->getContext();
57 if (NULL == context) {
58 return NULL;
59 }
60 GrTextureDesc desc;
61
62 SkIPoint pointStorage;
63 SkIPoint* topLeft;
64 if (subset != NULL) {
65 SkASSERT(SkIRect::MakeWH(texture->width(), texture->height()).contains(*subset));
66 // Create a new texture that is the size of subset.
67 desc.fWidth = subset->width();
68 desc.fHeight = subset->height();
69 pointStorage.set(subset->x(), subset->y());
70 topLeft = &pointStorage;
71 } else {
72 desc.fWidth = texture->width();
73 desc.fHeight = texture->height();
74 topLeft = NULL;
75 }
76 desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
77 desc.fConfig = SkBitmapConfig2GrPixelConfig(dstConfig);
78
79 GrTexture* dst = context->createUncachedTexture(desc, NULL, 0);
80 if (NULL == dst) {
81 return NULL;
82 }
83
84 context->copyTexture(texture, dst->asRenderTarget(), topLeft);
85
86 // TODO: figure out if this is responsible for Chrome canvas errors
87 #if 0
88 // The render texture we have created (to perform the copy) isn't fully
89 // functional (since it doesn't have a stencil buffer). Release it here
90 // so the caller doesn't try to render to it.
91 // TODO: we can undo this release when dynamic stencil buffer attach/
92 // detach has been implemented
93 dst->releaseRenderTarget();
94 #endif
95
96 SkGrPixelRef* pixelRef = SkNEW_ARGS(SkGrPixelRef, (dst));
97 GrSafeUnref(dst);
98 return pixelRef;
99 }
100
101 ///////////////////////////////////////////////////////////////////////////////
102
SkGrPixelRef(GrSurface * surface,bool transferCacheLock)103 SkGrPixelRef::SkGrPixelRef(GrSurface* surface, bool transferCacheLock) {
104 // TODO: figure out if this is responsible for Chrome canvas errors
105 #if 0
106 // The GrTexture has a ref to the GrRenderTarget but not vice versa.
107 // If the GrTexture exists take a ref to that (rather than the render
108 // target)
109 fSurface = surface->asTexture();
110 #else
111 fSurface = NULL;
112 #endif
113 if (NULL == fSurface) {
114 fSurface = surface;
115 }
116 fUnlock = transferCacheLock;
117 GrSafeRef(surface);
118 }
119
~SkGrPixelRef()120 SkGrPixelRef::~SkGrPixelRef() {
121 if (fUnlock) {
122 GrContext* context = fSurface->getContext();
123 GrTexture* texture = fSurface->asTexture();
124 if (NULL != context && NULL != texture) {
125 context->unlockScratchTexture(texture);
126 }
127 }
128 GrSafeUnref(fSurface);
129 }
130
getTexture()131 SkGpuTexture* SkGrPixelRef::getTexture() {
132 if (NULL != fSurface) {
133 return (SkGpuTexture*) fSurface->asTexture();
134 }
135 return NULL;
136 }
137
deepCopy(SkBitmap::Config dstConfig,const SkIRect * subset)138 SkPixelRef* SkGrPixelRef::deepCopy(SkBitmap::Config dstConfig, const SkIRect* subset) {
139 if (NULL == fSurface) {
140 return NULL;
141 }
142
143 // Note that when copying a render-target-backed pixel ref, we
144 // return a texture-backed pixel ref instead. This is because
145 // render-target pixel refs are usually created in conjunction with
146 // a GrTexture owned elsewhere (e.g., SkGpuDevice), and cannot live
147 // independently of that texture. Texture-backed pixel refs, on the other
148 // hand, own their GrTextures, and are thus self-contained.
149 return copyToTexturePixelRef(fSurface->asTexture(), dstConfig, subset);
150 }
151
onReadPixels(SkBitmap * dst,const SkIRect * subset)152 bool SkGrPixelRef::onReadPixels(SkBitmap* dst, const SkIRect* subset) {
153 if (NULL == fSurface || !fSurface->isValid()) {
154 return false;
155 }
156
157 int left, top, width, height;
158 if (NULL != subset) {
159 left = subset->fLeft;
160 width = subset->width();
161 top = subset->fTop;
162 height = subset->height();
163 } else {
164 left = 0;
165 width = fSurface->width();
166 top = 0;
167 height = fSurface->height();
168 }
169 dst->setConfig(SkBitmap::kARGB_8888_Config, width, height);
170 if (!dst->allocPixels()) {
171 SkDebugf("SkGrPixelRef::onReadPixels failed to alloc bitmap for result!\n");
172 return false;
173 }
174 SkAutoLockPixels al(*dst);
175 void* buffer = dst->getPixels();
176 return fSurface->readPixels(left, top, width, height,
177 kSkia8888_PM_GrPixelConfig,
178 buffer, dst->rowBytes());
179 }
180