OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkImage_Base.h" | 8 #include "SkImage_Base.h" |
9 #include "SkBitmap.h" | 9 #include "SkBitmap.h" |
10 #include "SkCanvas.h" | 10 #include "SkCanvas.h" |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
56 if (0 == size) { | 56 if (0 == size) { |
57 return false; | 57 return false; |
58 } | 58 } |
59 | 59 |
60 if (minSize) { | 60 if (minSize) { |
61 *minSize = size; | 61 *minSize = size; |
62 } | 62 } |
63 return true; | 63 return true; |
64 } | 64 } |
65 | 65 |
66 SkImage_Raster(const SkImageInfo&, sk_sp<SkData>, size_t rb, SkColorTable*); | 66 SkImage_Raster(const SkImageInfo&, SkData*, size_t rb, SkColorTable*); |
67 virtual ~SkImage_Raster(); | 67 virtual ~SkImage_Raster(); |
68 | 68 |
69 bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY, Cac
hingHint) const override; | 69 bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY, Cac
hingHint) const override; |
70 bool onPeekPixels(SkPixmap*) const override; | 70 bool onPeekPixels(SkPixmap*) const override; |
71 SkData* onRefEncoded(GrContext*) const override; | 71 SkData* onRefEncoded(GrContext*) const override; |
72 bool getROPixels(SkBitmap*, CachingHint) const override; | 72 bool getROPixels(SkBitmap*, CachingHint) const override; |
73 GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const override; | 73 GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const override; |
74 sk_sp<SkImage> onMakeSubset(const SkIRect&) const override; | 74 SkImage* onNewSubset(const SkIRect&) const override; |
75 | 75 |
76 // exposed for SkSurface_Raster via SkNewImageFromPixelRef | 76 // exposed for SkSurface_Raster via SkNewImageFromPixelRef |
77 SkImage_Raster(const SkImageInfo&, SkPixelRef*, const SkIPoint& origin, size
_t rowBytes); | 77 SkImage_Raster(const SkImageInfo&, SkPixelRef*, const SkIPoint& origin, size
_t rowBytes); |
78 | 78 |
79 SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); } | 79 SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); } |
80 | 80 |
81 bool isOpaque() const override; | 81 bool isOpaque() const override; |
82 bool onAsLegacyBitmap(SkBitmap*, LegacyBitmapMode) const override; | 82 bool onAsLegacyBitmap(SkBitmap*, LegacyBitmapMode) const override; |
83 | 83 |
84 SkImage_Raster(const SkBitmap& bm) | 84 SkImage_Raster(const SkBitmap& bm) |
(...skipping 18 matching lines...) Expand all Loading... |
103 typedef SkImage_Base INHERITED; | 103 typedef SkImage_Base INHERITED; |
104 }; | 104 }; |
105 | 105 |
106 /////////////////////////////////////////////////////////////////////////////// | 106 /////////////////////////////////////////////////////////////////////////////// |
107 | 107 |
108 static void release_data(void* addr, void* context) { | 108 static void release_data(void* addr, void* context) { |
109 SkData* data = static_cast<SkData*>(context); | 109 SkData* data = static_cast<SkData*>(context); |
110 data->unref(); | 110 data->unref(); |
111 } | 111 } |
112 | 112 |
113 SkImage_Raster::SkImage_Raster(const Info& info, sk_sp<SkData> data, size_t rowB
ytes, | 113 SkImage_Raster::SkImage_Raster(const Info& info, SkData* data, size_t rowBytes, |
114 SkColorTable* ctable) | 114 SkColorTable* ctable) |
115 : INHERITED(info.width(), info.height(), kNeedNewImageUniqueID) | 115 : INHERITED(info.width(), info.height(), kNeedNewImageUniqueID) |
116 { | 116 { |
| 117 data->ref(); |
117 void* addr = const_cast<void*>(data->data()); | 118 void* addr = const_cast<void*>(data->data()); |
118 | 119 |
119 fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data.relea
se()); | 120 fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data); |
120 fBitmap.setImmutable(); | 121 fBitmap.setImmutable(); |
121 fBitmap.lockPixels(); | 122 fBitmap.lockPixels(); |
122 } | 123 } |
123 | 124 |
124 SkImage_Raster::SkImage_Raster(const Info& info, SkPixelRef* pr, const SkIPoint&
pixelRefOrigin, | 125 SkImage_Raster::SkImage_Raster(const Info& info, SkPixelRef* pr, const SkIPoint&
pixelRefOrigin, |
125 size_t rowBytes) | 126 size_t rowBytes) |
126 : INHERITED(info.width(), info.height(), pr->getGenerationID()) | 127 : INHERITED(info.width(), info.height(), pr->getGenerationID()) |
127 { | 128 { |
128 fBitmap.setInfo(info, rowBytes); | 129 fBitmap.setInfo(info, rowBytes); |
129 fBitmap.setPixelRef(pr, pixelRefOrigin); | 130 fBitmap.setPixelRef(pr, pixelRefOrigin); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
165 if (!ctx) { | 166 if (!ctx) { |
166 return nullptr; | 167 return nullptr; |
167 } | 168 } |
168 | 169 |
169 return GrRefCachedBitmapTexture(ctx, fBitmap, params); | 170 return GrRefCachedBitmapTexture(ctx, fBitmap, params); |
170 #endif | 171 #endif |
171 | 172 |
172 return nullptr; | 173 return nullptr; |
173 } | 174 } |
174 | 175 |
175 sk_sp<SkImage> SkImage_Raster::onMakeSubset(const SkIRect& subset) const { | 176 SkImage* SkImage_Raster::onNewSubset(const SkIRect& subset) const { |
176 // TODO : could consider heurist of sharing pixels, if subset is pretty clos
e to complete | 177 // TODO : could consider heurist of sharing pixels, if subset is pretty clos
e to complete |
177 | 178 |
178 SkImageInfo info = SkImageInfo::MakeN32(subset.width(), subset.height(), fBi
tmap.alphaType()); | 179 SkImageInfo info = SkImageInfo::MakeN32(subset.width(), subset.height(), fBi
tmap.alphaType()); |
179 SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); | 180 SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); |
180 if (!surface) { | 181 if (!surface) { |
181 return nullptr; | 182 return nullptr; |
182 } | 183 } |
183 surface->getCanvas()->clear(0); | 184 surface->getCanvas()->clear(0); |
184 surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToSca
lar(-subset.y()), | 185 surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToSca
lar(-subset.y()), |
185 nullptr); | 186 nullptr); |
186 return sk_sp<SkImage>(surface->newImageSnapshot()); | 187 return surface->newImageSnapshot(); |
187 } | 188 } |
188 | 189 |
189 /////////////////////////////////////////////////////////////////////////////// | 190 /////////////////////////////////////////////////////////////////////////////// |
190 | 191 |
191 sk_sp<SkImage> SkImage::MakeRasterCopy(const SkPixmap& pmap) { | 192 SkImage* SkImage::NewRasterCopy(const SkImageInfo& info, const void* pixels, siz
e_t rowBytes, |
| 193 SkColorTable* ctable) { |
192 size_t size; | 194 size_t size; |
193 if (!SkImage_Raster::ValidArgs(pmap.info(), pmap.rowBytes(), | 195 if (!SkImage_Raster::ValidArgs(info, rowBytes, ctable != nullptr, &size) ||
!pixels) { |
194 pmap.ctable() != nullptr, &size) || !pmap.add
r()) { | |
195 return nullptr; | 196 return nullptr; |
196 } | 197 } |
197 | 198 |
198 // Here we actually make a copy of the caller's pixel data | 199 // Here we actually make a copy of the caller's pixel data |
199 sk_sp<SkData> data(SkData::NewWithCopy(pmap.addr(), size)); | 200 SkAutoDataUnref data(SkData::NewWithCopy(pixels, size)); |
200 return sk_make_sp<SkImage_Raster>(pmap.info(), std::move(data), pmap.rowByte
s(), pmap.ctable()); | 201 return new SkImage_Raster(info, data, rowBytes, ctable); |
201 } | 202 } |
202 | 203 |
203 | 204 |
204 sk_sp<SkImage> SkImage::MakeRasterData(const SkImageInfo& info, sk_sp<SkData> da
ta, | 205 SkImage* SkImage::NewRasterData(const SkImageInfo& info, SkData* data, size_t ro
wBytes) { |
205 size_t rowBytes) { | |
206 size_t size; | 206 size_t size; |
207 if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !data) { | 207 if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !data) { |
208 return nullptr; | 208 return nullptr; |
209 } | 209 } |
210 | 210 |
211 // did they give us enough data? | 211 // did they give us enough data? |
212 if (data->size() < size) { | 212 if (data->size() < size) { |
213 return nullptr; | 213 return nullptr; |
214 } | 214 } |
215 | 215 |
216 SkColorTable* ctable = nullptr; | 216 SkColorTable* ctable = nullptr; |
217 return sk_make_sp<SkImage_Raster>(info, std::move(data), rowBytes, ctable); | 217 return new SkImage_Raster(info, data, rowBytes, ctable); |
218 } | 218 } |
219 | 219 |
220 sk_sp<SkImage> SkImage::MakeFromRaster(const SkPixmap& pmap, RasterReleaseProc p
roc, | 220 SkImage* SkImage::NewFromRaster(const SkImageInfo& info, const void* pixels, siz
e_t rowBytes, |
221 ReleaseContext ctx) { | 221 RasterReleaseProc proc, ReleaseContext ctx) { |
222 size_t size; | 222 size_t size; |
223 if (!SkImage_Raster::ValidArgs(pmap.info(), pmap.rowBytes(), false, &size) |
| !pmap.addr()) { | 223 if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !pixels) { |
224 return nullptr; | 224 return nullptr; |
225 } | 225 } |
226 | 226 |
227 sk_sp<SkData> data(SkData::NewWithProc(pmap.addr(), size, proc, ctx)); | 227 SkColorTable* ctable = nullptr; |
228 return sk_make_sp<SkImage_Raster>(pmap.info(), std::move(data), pmap.rowByte
s(), pmap.ctable()); | 228 SkAutoDataUnref data(SkData::NewWithProc(pixels, size, proc, ctx)); |
| 229 return new SkImage_Raster(info, data, rowBytes, ctable); |
229 } | 230 } |
230 | 231 |
231 sk_sp<SkImage> SkMakeImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr, | 232 SkImage* SkNewImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr, |
232 const SkIPoint& pixelRefOrigin, size_t ro
wBytes) { | 233 const SkIPoint& pixelRefOrigin, size_t rowBytes)
{ |
233 if (!SkImage_Raster::ValidArgs(info, rowBytes, false, nullptr)) { | 234 if (!SkImage_Raster::ValidArgs(info, rowBytes, false, nullptr)) { |
234 return nullptr; | 235 return nullptr; |
235 } | 236 } |
236 return sk_make_sp<SkImage_Raster>(info, pr, pixelRefOrigin, rowBytes); | 237 return new SkImage_Raster(info, pr, pixelRefOrigin, rowBytes); |
237 } | 238 } |
238 | 239 |
239 sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode for
ceCopy) { | 240 SkImage* SkNewImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy)
{ |
240 SkASSERT(nullptr == bm.getTexture()); | 241 SkASSERT(nullptr == bm.getTexture()); |
241 | 242 |
242 bool hasColorTable = false; | 243 bool hasColorTable = false; |
243 if (kIndex_8_SkColorType == bm.colorType()) { | 244 if (kIndex_8_SkColorType == bm.colorType()) { |
244 SkAutoLockPixels autoLockPixels(bm); | 245 SkAutoLockPixels autoLockPixels(bm); |
245 hasColorTable = bm.getColorTable() != nullptr; | 246 hasColorTable = bm.getColorTable() != nullptr; |
246 } | 247 } |
247 | 248 |
248 if (!SkImage_Raster::ValidArgs(bm.info(), bm.rowBytes(), hasColorTable, null
ptr)) { | 249 if (!SkImage_Raster::ValidArgs(bm.info(), bm.rowBytes(), hasColorTable, null
ptr)) { |
249 return nullptr; | 250 return nullptr; |
250 } | 251 } |
251 | 252 |
252 sk_sp<SkImage> image; | 253 SkImage* image = nullptr; |
253 if (kYes_ForceCopyMode == forceCopy || !bm.isImmutable()) { | 254 if (kYes_ForceCopyMode == forceCopy || !bm.isImmutable()) { |
254 SkBitmap tmp(bm); | 255 SkBitmap tmp(bm); |
255 tmp.lockPixels(); | 256 tmp.lockPixels(); |
256 SkPixmap pmap; | 257 if (tmp.getPixels()) { |
257 if (tmp.getPixels() && tmp.peekPixels(&pmap)) { | 258 image = SkImage::NewRasterCopy(tmp.info(), tmp.getPixels(), tmp.rowB
ytes(), |
258 image = SkImage::MakeRasterCopy(pmap); | 259 tmp.getColorTable()); |
259 } | 260 } |
260 } else { | 261 } else { |
261 image = sk_make_sp<SkImage_Raster>(bm); | 262 image = new SkImage_Raster(bm); |
262 } | 263 } |
263 return image; | 264 return image; |
264 } | 265 } |
265 | 266 |
266 const SkPixelRef* SkBitmapImageGetPixelRef(const SkImage* image) { | 267 const SkPixelRef* SkBitmapImageGetPixelRef(const SkImage* image) { |
267 return ((const SkImage_Raster*)image)->getPixelRef(); | 268 return ((const SkImage_Raster*)image)->getPixelRef(); |
268 } | 269 } |
269 | 270 |
270 bool SkImage_Raster::isOpaque() const { | 271 bool SkImage_Raster::isOpaque() const { |
271 return fBitmap.isOpaque(); | 272 return fBitmap.isOpaque(); |
272 } | 273 } |
273 | 274 |
274 bool SkImage_Raster::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) c
onst { | 275 bool SkImage_Raster::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) c
onst { |
275 if (kRO_LegacyBitmapMode == mode) { | 276 if (kRO_LegacyBitmapMode == mode) { |
276 // When we're a snapshot from a surface, our bitmap may not be marked im
mutable | 277 // When we're a snapshot from a surface, our bitmap may not be marked im
mutable |
277 // even though logically always we are, but in that case we can't physic
ally share our | 278 // even though logically always we are, but in that case we can't physic
ally share our |
278 // pixelref since the caller might call setImmutable() themselves | 279 // pixelref since the caller might call setImmutable() themselves |
279 // (thus changing our state). | 280 // (thus changing our state). |
280 if (fBitmap.isImmutable()) { | 281 if (fBitmap.isImmutable()) { |
281 bitmap->setInfo(fBitmap.info(), fBitmap.rowBytes()); | 282 bitmap->setInfo(fBitmap.info(), fBitmap.rowBytes()); |
282 bitmap->setPixelRef(fBitmap.pixelRef(), fBitmap.pixelRefOrigin()); | 283 bitmap->setPixelRef(fBitmap.pixelRef(), fBitmap.pixelRefOrigin()); |
283 return true; | 284 return true; |
284 } | 285 } |
285 } | 286 } |
286 return this->INHERITED::onAsLegacyBitmap(bitmap, mode); | 287 return this->INHERITED::onAsLegacyBitmap(bitmap, mode); |
287 } | 288 } |
OLD | NEW |