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 "SkBitmap.h" | 8 #include "SkBitmap.h" |
9 #include "SkBitmapCache.h" | 9 #include "SkBitmapCache.h" |
10 #include "SkCanvas.h" | 10 #include "SkCanvas.h" |
11 #include "SkData.h" | 11 #include "SkData.h" |
12 #include "SkImageEncoder.h" | 12 #include "SkImageEncoder.h" |
13 #include "SkImageGenerator.h" | 13 #include "SkImageGenerator.h" |
14 #include "SkImagePriv.h" | 14 #include "SkImagePriv.h" |
15 #include "SkImageShader.h" | 15 #include "SkImageShader.h" |
16 #include "SkImage_Base.h" | 16 #include "SkImage_Base.h" |
17 #include "SkNextID.h" | 17 #include "SkNextID.h" |
18 #include "SkPicture.h" | |
19 #include "SkPixelRef.h" | 18 #include "SkPixelRef.h" |
20 #include "SkPixelSerializer.h" | 19 #include "SkPixelSerializer.h" |
21 #include "SkReadPixelsRec.h" | 20 #include "SkReadPixelsRec.h" |
22 #include "SkString.h" | 21 #include "SkString.h" |
23 #include "SkSurface.h" | 22 #include "SkSurface.h" |
24 | 23 |
25 #if SK_SUPPORT_GPU | 24 #if SK_SUPPORT_GPU |
26 #include "GrTexture.h" | 25 #include "GrTexture.h" |
27 #include "GrContext.h" | 26 #include "GrContext.h" |
28 #include "SkImage_Gpu.h" | 27 #include "SkImage_Gpu.h" |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 } | 143 } |
145 | 144 |
146 return nullptr; | 145 return nullptr; |
147 } | 146 } |
148 | 147 |
149 SkData* SkImage::refEncoded() const { | 148 SkData* SkImage::refEncoded() const { |
150 GrContext* ctx = nullptr; // should we allow the caller to pass in a ctx? | 149 GrContext* ctx = nullptr; // should we allow the caller to pass in a ctx? |
151 return as_IB(this)->onRefEncoded(ctx); | 150 return as_IB(this)->onRefEncoded(ctx); |
152 } | 151 } |
153 | 152 |
154 sk_sp<SkImage> SkImage::MakeFromEncoded(sk_sp<SkData> encoded, const SkIRect* su
bset) { | 153 SkImage* SkImage::NewFromEncoded(SkData* encoded, const SkIRect* subset) { |
155 if (nullptr == encoded || 0 == encoded->size()) { | 154 if (nullptr == encoded || 0 == encoded->size()) { |
156 return nullptr; | 155 return nullptr; |
157 } | 156 } |
158 SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded.get()
); | 157 SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded); |
159 return SkImage::MakeFromGenerator(generator, subset); | 158 return generator ? SkImage::NewFromGenerator(generator, subset) : nullptr; |
160 } | 159 } |
161 | 160 |
162 const char* SkImage::toString(SkString* str) const { | 161 const char* SkImage::toString(SkString* str) const { |
163 str->appendf("image: (id:%d (%d, %d) %s)", this->uniqueID(), this->width(),
this->height(), | 162 str->appendf("image: (id:%d (%d, %d) %s)", this->uniqueID(), this->width(),
this->height(), |
164 this->isOpaque() ? "opaque" : ""); | 163 this->isOpaque() ? "opaque" : ""); |
165 return str->c_str(); | 164 return str->c_str(); |
166 } | 165 } |
167 | 166 |
168 sk_sp<SkImage> SkImage::makeSubset(const SkIRect& subset) const { | 167 SkImage* SkImage::newSubset(const SkIRect& subset) const { |
169 if (subset.isEmpty()) { | 168 if (subset.isEmpty()) { |
170 return nullptr; | 169 return nullptr; |
171 } | 170 } |
172 | 171 |
173 const SkIRect bounds = SkIRect::MakeWH(this->width(), this->height()); | 172 const SkIRect bounds = SkIRect::MakeWH(this->width(), this->height()); |
174 if (!bounds.contains(subset)) { | 173 if (!bounds.contains(subset)) { |
175 return nullptr; | 174 return nullptr; |
176 } | 175 } |
177 | 176 |
178 // optimization : return self if the subset == our bounds | 177 // optimization : return self if the subset == our bounds |
179 if (bounds == subset) { | 178 if (bounds == subset) { |
180 return sk_ref_sp(const_cast<SkImage*>(this)); | 179 return SkRef(const_cast<SkImage*>(this)); |
181 } | 180 } |
182 return as_IB(this)->onMakeSubset(subset); | 181 return as_IB(this)->onNewSubset(subset); |
183 } | 182 } |
184 | 183 |
185 #if SK_SUPPORT_GPU | 184 #if SK_SUPPORT_GPU |
186 | 185 |
187 GrTexture* SkImage::getTexture() const { | 186 GrTexture* SkImage::getTexture() const { |
188 return as_IB(this)->peekTexture(); | 187 return as_IB(this)->peekTexture(); |
189 } | 188 } |
190 | 189 |
191 bool SkImage::isTextureBacked() const { return SkToBool(as_IB(this)->peekTexture
()); } | 190 bool SkImage::isTextureBacked() const { return SkToBool(as_IB(this)->peekTexture
()); } |
192 | 191 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
277 if (GrTextureToYUVPlanes(texture, sizes, planes, rowBytes, colorSpace))
{ | 276 if (GrTextureToYUVPlanes(texture, sizes, planes, rowBytes, colorSpace))
{ |
278 return true; | 277 return true; |
279 } | 278 } |
280 } | 279 } |
281 #endif | 280 #endif |
282 return SkRGBAToYUV(this, sizes, planes, rowBytes, colorSpace); | 281 return SkRGBAToYUV(this, sizes, planes, rowBytes, colorSpace); |
283 } | 282 } |
284 | 283 |
285 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 284 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
286 | 285 |
287 sk_sp<SkImage> SkImage::MakeFromBitmap(const SkBitmap& bm) { | 286 SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) { |
288 SkPixelRef* pr = bm.pixelRef(); | 287 SkPixelRef* pr = bm.pixelRef(); |
289 if (nullptr == pr) { | 288 if (nullptr == pr) { |
290 return nullptr; | 289 return nullptr; |
291 } | 290 } |
292 | 291 |
293 #if SK_SUPPORT_GPU | 292 #if SK_SUPPORT_GPU |
294 if (GrTexture* tex = pr->getTexture()) { | 293 if (GrTexture* tex = pr->getTexture()) { |
295 SkAutoTUnref<GrTexture> unrefCopy; | 294 SkAutoTUnref<GrTexture> unrefCopy; |
296 if (!bm.isImmutable()) { | 295 if (!bm.isImmutable()) { |
297 tex = GrDeepCopyTexture(tex, SkBudgeted::kNo); | 296 tex = GrDeepCopyTexture(tex, SkBudgeted::kNo); |
298 if (nullptr == tex) { | 297 if (nullptr == tex) { |
299 return nullptr; | 298 return nullptr; |
300 } | 299 } |
301 unrefCopy.reset(tex); | 300 unrefCopy.reset(tex); |
302 } | 301 } |
303 const SkImageInfo info = bm.info(); | 302 const SkImageInfo info = bm.info(); |
304 return sk_make_sp<SkImage_Gpu>(info.width(), info.height(), bm.getGenera
tionID(), | 303 return new SkImage_Gpu(info.width(), info.height(), bm.getGenerationID()
, info.alphaType(), |
305 info.alphaType(), tex, SkBudgeted::kNo); | 304 tex, SkBudgeted::kNo); |
306 } | 305 } |
307 #endif | 306 #endif |
308 | 307 |
309 // This will check for immutable (share or copy) | 308 // This will check for immutable (share or copy) |
310 return SkMakeImageFromRasterBitmap(bm); | 309 return SkNewImageFromRasterBitmap(bm); |
311 } | 310 } |
312 | 311 |
313 bool SkImage::asLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) const { | 312 bool SkImage::asLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) const { |
314 return as_IB(this)->onAsLegacyBitmap(bitmap, mode); | 313 return as_IB(this)->onAsLegacyBitmap(bitmap, mode); |
315 } | 314 } |
316 | 315 |
317 bool SkImage_Base::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) con
st { | 316 bool SkImage_Base::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) con
st { |
318 // As the base-class, all we can do is make a copy (regardless of mode). | 317 // As the base-class, all we can do is make a copy (regardless of mode). |
319 // Subclasses that want to be more optimal should override. | 318 // Subclasses that want to be more optimal should override. |
320 SkImageInfo info = SkImageInfo::MakeN32(this->width(), this->height(), | 319 SkImageInfo info = SkImageInfo::MakeN32(this->width(), this->height(), |
321 this->isOpaque() ? kOpaque_SkAlphaType : kPr
emul_SkAlphaType); | 320 this->isOpaque() ? kOpaque_SkAlphaType : kPr
emul_SkAlphaType); |
322 if (!bitmap->tryAllocPixels(info)) { | 321 if (!bitmap->tryAllocPixels(info)) { |
323 return false; | 322 return false; |
324 } | 323 } |
325 if (!this->readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(
), 0, 0)) { | 324 if (!this->readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(
), 0, 0)) { |
326 bitmap->reset(); | 325 bitmap->reset(); |
327 return false; | 326 return false; |
328 } | 327 } |
329 | 328 |
330 if (kRO_LegacyBitmapMode == mode) { | 329 if (kRO_LegacyBitmapMode == mode) { |
331 bitmap->setImmutable(); | 330 bitmap->setImmutable(); |
332 } | 331 } |
333 return true; | 332 return true; |
334 } | 333 } |
335 | 334 |
336 sk_sp<SkImage> SkImage::MakeFromPicture(sk_sp<SkPicture> picture, const SkISize&
dimensions, | 335 SkImage* SkImage::NewFromPicture(const SkPicture* picture, const SkISize& dimens
ions, |
337 const SkMatrix* matrix, const SkPaint* p
aint) { | 336 const SkMatrix* matrix, const SkPaint* paint) { |
338 if (!picture) { | 337 if (!picture) { |
339 return nullptr; | 338 return nullptr; |
340 } | 339 } |
341 return MakeFromGenerator(SkImageGenerator::NewFromPicture(dimensions, pictur
e.release(), | 340 return NewFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture
, matrix, paint)); |
342 matrix, paint)); | |
343 } | 341 } |
344 | 342 |
345 bool SkImage::isLazyGenerated() const { | 343 bool SkImage::isLazyGenerated() const { |
346 return as_IB(this)->onIsLazyGenerated(); | 344 return as_IB(this)->onIsLazyGenerated(); |
347 } | 345 } |
348 | 346 |
349 ////////////////////////////////////////////////////////////////////////////////
////// | 347 ////////////////////////////////////////////////////////////////////////////////
////// |
350 | 348 |
351 #if !SK_SUPPORT_GPU | 349 #if !SK_SUPPORT_GPU |
352 | 350 |
353 sk_sp<SkImage> SkImage::MakeTextureFromPixmap(GrContext*, const SkPixmap&, SkBud
geted budgeted) { | 351 SkImage* SkImage::NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted b
udgeted) { |
354 return nullptr; | 352 return nullptr; |
355 } | 353 } |
356 | 354 |
357 sk_sp<SkImage> SkImage::MakeFromTexture(GrContext*, const GrBackendTextureDesc&,
SkAlphaType, | 355 SkImage* SkImage::NewFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlph
aType, |
358 TextureReleaseProc, ReleaseContext) { | 356 TextureReleaseProc, ReleaseContext) { |
359 return nullptr; | 357 return nullptr; |
360 } | 358 } |
361 | 359 |
362 sk_sp<SkImage> SkImage::MakeFromAdoptedTexture(GrContext*, const GrBackendTextur
eDesc&, | 360 SkImage* SkImage::NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&,
SkAlphaType) { |
363 SkAlphaType) { | |
364 return nullptr; | 361 return nullptr; |
365 } | 362 } |
366 | 363 |
367 sk_sp<SkImage> SkImage::MakeFromTextureCopy(GrContext*, const GrBackendTextureDe
sc&, SkAlphaType) { | 364 SkImage* SkImage::NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, Sk
AlphaType) { |
368 return nullptr; | 365 return nullptr; |
369 } | 366 } |
370 | 367 |
371 sk_sp<SkImage> SkImage::MakeFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace
space, | 368 SkImage* SkImage::newTextureImage(GrContext*) const { |
372 const GrBackendObject yuvTexture
Handles[3], | |
373 const SkISize yuvSizes[3], | |
374 GrSurfaceOrigin origin) { | |
375 return nullptr; | |
376 } | |
377 | |
378 sk_sp<SkImage> SkImage::makeTextureImage(GrContext*) const { | |
379 return nullptr; | 369 return nullptr; |
380 } | 370 } |
381 | 371 |
382 #endif | 372 #endif |
383 | |
384 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | |
385 | |
386 #ifdef SK_SUPPORT_LEGACY_IMAGEFACTORY | |
387 SkImage* SkImage::NewRasterCopy(const Info& info, const void* pixels, size_t row
Bytes, | |
388 SkColorTable* ctable) { | |
389 return MakeRasterCopy(SkPixmap(info, pixels, rowBytes, ctable)).release(); | |
390 } | |
391 | |
392 SkImage* SkImage::NewRasterData(const Info& info, SkData* pixels, size_t rowByte
s) { | |
393 return MakeRasterData(info, sk_ref_sp(pixels), rowBytes).release(); | |
394 } | |
395 | |
396 SkImage* SkImage::NewFromRaster(const Info& info, const void* pixels, size_t row
Bytes, | |
397 RasterReleaseProc proc, ReleaseContext releasect
x) { | |
398 return MakeFromRaster(SkPixmap(info, pixels, rowBytes), proc, releasectx).re
lease(); | |
399 } | |
400 | |
401 SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) { | |
402 return MakeFromBitmap(bm).release(); | |
403 } | |
404 | |
405 SkImage* SkImage::NewFromGenerator(SkImageGenerator* gen, const SkIRect* subset)
{ | |
406 return MakeFromGenerator(gen, subset).release(); | |
407 } | |
408 | |
409 SkImage* SkImage::NewFromEncoded(SkData* encoded, const SkIRect* subset) { | |
410 return MakeFromEncoded(sk_ref_sp(encoded), subset).release(); | |
411 } | |
412 | |
413 SkImage* SkImage::NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& des
c, SkAlphaType at, | |
414 TextureReleaseProc proc, ReleaseContext release
ctx) { | |
415 return MakeFromTexture(ctx, desc, at, proc, releasectx).release(); | |
416 } | |
417 | |
418 SkImage* SkImage::NewFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDe
sc& desc, | |
419 SkAlphaType at) { | |
420 return MakeFromAdoptedTexture(ctx, desc, at).release(); | |
421 } | |
422 | |
423 SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc&
desc, | |
424 SkAlphaType at) { | |
425 return MakeFromTextureCopy(ctx, desc, at).release(); | |
426 } | |
427 | |
428 SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace space, | |
429 const GrBackendObject yuvTextureHandles
[3], | |
430 const SkISize yuvSizes[3], | |
431 GrSurfaceOrigin origin) { | |
432 return MakeFromYUVTexturesCopy(ctx, space, yuvTextureHandles, yuvSizes, orig
in).release(); | |
433 } | |
434 | |
435 SkImage* SkImage::NewFromPicture(const SkPicture* picture, const SkISize& dimens
ions, | |
436 const SkMatrix* matrix, const SkPaint* paint) { | |
437 return MakeFromPicture(sk_ref_sp(const_cast<SkPicture*>(picture)), dimension
s, | |
438 matrix, paint).release(); | |
439 } | |
440 | |
441 SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pmap, SkB
udgeted budgeted) { | |
442 return MakeTextureFromPixmap(ctx, pmap, budgeted).release(); | |
443 } | |
444 #endif | |
OLD | NEW |