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 "GrCaps.h" | 8 #include "GrCaps.h" |
9 #include "GrContext.h" | 9 #include "GrContext.h" |
10 #include "GrDrawContext.h" | 10 #include "GrDrawContext.h" |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
127 // all other combos need to change. | 127 // all other combos need to change. |
128 // | 128 // |
129 // Should this be handled by Ganesh? todo:? | 129 // Should this be handled by Ganesh? todo:? |
130 // | 130 // |
131 if (kPremul_SkAlphaType == info.alphaType() && kUnpremul_SkAlphaType == fAlp
haType) { | 131 if (kPremul_SkAlphaType == info.alphaType() && kUnpremul_SkAlphaType == fAlp
haType) { |
132 apply_premul(info, pixels, rowBytes); | 132 apply_premul(info, pixels, rowBytes); |
133 } | 133 } |
134 return true; | 134 return true; |
135 } | 135 } |
136 | 136 |
137 sk_sp<SkImage> SkImage_Gpu::onMakeSubset(const SkIRect& subset) const { | 137 SkImage* SkImage_Gpu::onNewSubset(const SkIRect& subset) const { |
138 GrContext* ctx = fTexture->getContext(); | 138 GrContext* ctx = fTexture->getContext(); |
139 GrSurfaceDesc desc = fTexture->desc(); | 139 GrSurfaceDesc desc = fTexture->desc(); |
140 desc.fWidth = subset.width(); | 140 desc.fWidth = subset.width(); |
141 desc.fHeight = subset.height(); | 141 desc.fHeight = subset.height(); |
142 | 142 |
143 GrTexture* subTx = ctx->textureProvider()->createTexture(desc, fBudgeted); | 143 GrTexture* subTx = ctx->textureProvider()->createTexture(desc, fBudgeted); |
144 if (!subTx) { | 144 if (!subTx) { |
145 return nullptr; | 145 return nullptr; |
146 } | 146 } |
147 ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0)); | 147 ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0)); |
148 return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqu
eID, | 148 return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, fAl
phaType, subTx, |
149 fAlphaType, subTx, fBudgeted); | 149 fBudgeted); |
150 } | 150 } |
151 | 151 |
152 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 152 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
153 | 153 |
154 static sk_sp<SkImage> new_wrapped_texture_common(GrContext* ctx, const GrBackend
TextureDesc& desc, | 154 static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextur
eDesc& desc, |
155 SkAlphaType at, GrWrapOwnership
ownership, | 155 SkAlphaType at, GrWrapOwnership owner
ship, |
156 SkImage::TextureReleaseProc rel
easeProc, | 156 SkImage::TextureReleaseProc releasePr
oc, |
157 SkImage::ReleaseContext release
Ctx) { | 157 SkImage::ReleaseContext releaseCtx) { |
158 if (desc.fWidth <= 0 || desc.fHeight <= 0) { | 158 if (desc.fWidth <= 0 || desc.fHeight <= 0) { |
159 return nullptr; | 159 return nullptr; |
160 } | 160 } |
161 SkAutoTUnref<GrTexture> tex(ctx->textureProvider()->wrapBackendTexture(desc,
ownership)); | 161 SkAutoTUnref<GrTexture> tex(ctx->textureProvider()->wrapBackendTexture(desc,
ownership)); |
162 if (!tex) { | 162 if (!tex) { |
163 return nullptr; | 163 return nullptr; |
164 } | 164 } |
165 if (releaseProc) { | 165 if (releaseProc) { |
166 tex->setRelease(releaseProc, releaseCtx); | 166 tex->setRelease(releaseProc, releaseCtx); |
167 } | 167 } |
168 | 168 |
169 const SkBudgeted budgeted = SkBudgeted::kNo; | 169 const SkBudgeted budgeted = SkBudgeted::kNo; |
170 return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqu
eID, | 170 return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at,
tex, budgeted); |
171 at, tex, budgeted); | |
172 } | 171 } |
173 | 172 |
174 sk_sp<SkImage> SkImage::MakeFromTexture(GrContext* ctx, const GrBackendTextureDe
sc& desc, | 173 SkImage* SkImage::NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& des
c, SkAlphaType at, |
175 SkAlphaType at, TextureReleaseProc relea
seP, | 174 TextureReleaseProc releaseP, ReleaseContext rel
easeC) { |
176 ReleaseContext releaseC) { | |
177 return new_wrapped_texture_common(ctx, desc, at, kBorrow_GrWrapOwnership, re
leaseP, releaseC); | 175 return new_wrapped_texture_common(ctx, desc, at, kBorrow_GrWrapOwnership, re
leaseP, releaseC); |
178 } | 176 } |
179 | 177 |
180 sk_sp<SkImage> SkImage::MakeFromAdoptedTexture(GrContext* ctx, const GrBackendTe
xtureDesc& desc, | 178 SkImage* SkImage::NewFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDe
sc& desc, |
181 SkAlphaType at) { | 179 SkAlphaType at) { |
182 return new_wrapped_texture_common(ctx, desc, at, kAdopt_GrWrapOwnership, nul
lptr, nullptr); | 180 return new_wrapped_texture_common(ctx, desc, at, kAdopt_GrWrapOwnership, nul
lptr, nullptr); |
183 } | 181 } |
184 | 182 |
185 sk_sp<SkImage> SkImage::MakeFromTextureCopy(GrContext* ctx, const GrBackendTextu
reDesc& desc, | 183 SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc&
desc, |
186 SkAlphaType at) { | 184 SkAlphaType at) { |
187 if (desc.fWidth <= 0 || desc.fHeight <= 0) { | 185 if (desc.fWidth <= 0 || desc.fHeight <= 0) { |
188 return nullptr; | 186 return nullptr; |
189 } | 187 } |
190 | 188 |
191 SkAutoTUnref<GrTexture> src(ctx->textureProvider()->wrapBackendTexture( | 189 SkAutoTUnref<GrTexture> src(ctx->textureProvider()->wrapBackendTexture( |
192 desc, kBorrow_GrWrapOwnership)); | 190 desc, kBorrow_GrWrapOwnership)); |
193 if (!src) { | 191 if (!src) { |
194 return nullptr; | 192 return nullptr; |
195 } | 193 } |
196 | 194 |
197 SkAutoTUnref<GrTexture> dst(GrDeepCopyTexture(src, SkBudgeted::kYes)); | 195 SkAutoTUnref<GrTexture> dst(GrDeepCopyTexture(src, SkBudgeted::kYes)); |
198 if (!dst) { | 196 if (!dst) { |
199 return nullptr; | 197 return nullptr; |
200 } | 198 } |
201 | 199 |
202 return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqu
eID, at, dst, | 200 return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at,
dst, |
203 SkBudgeted::kYes); | 201 SkBudgeted::kYes); |
204 } | 202 } |
205 | 203 |
206 sk_sp<SkImage> SkImage::MakeFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace
colorSpace, | 204 SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorS
pace, |
207 const GrBackendObject yuvTexture
Handles[3], | 205 const GrBackendObject yuvTextureHandles
[3], |
208 const SkISize yuvSizes[3], | 206 const SkISize yuvSizes[3], |
209 GrSurfaceOrigin origin) { | 207 GrSurfaceOrigin origin) { |
210 const SkBudgeted budgeted = SkBudgeted::kYes; | 208 const SkBudgeted budgeted = SkBudgeted::kYes; |
211 | 209 |
212 if (yuvSizes[0].fWidth <= 0 || yuvSizes[0].fHeight <= 0 || | 210 if (yuvSizes[0].fWidth <= 0 || yuvSizes[0].fHeight <= 0 || |
213 yuvSizes[1].fWidth <= 0 || yuvSizes[1].fHeight <= 0 || | 211 yuvSizes[1].fWidth <= 0 || yuvSizes[1].fHeight <= 0 || |
214 yuvSizes[2].fWidth <= 0 || yuvSizes[2].fHeight <= 0) { | 212 yuvSizes[2].fWidth <= 0 || yuvSizes[2].fHeight <= 0) { |
215 return nullptr; | 213 return nullptr; |
216 } | 214 } |
217 static const GrPixelConfig kConfig = kAlpha_8_GrPixelConfig; | 215 static const GrPixelConfig kConfig = kAlpha_8_GrPixelConfig; |
218 GrBackendTextureDesc yDesc; | 216 GrBackendTextureDesc yDesc; |
219 yDesc.fConfig = kConfig; | 217 yDesc.fConfig = kConfig; |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
270 | 268 |
271 const SkRect rect = SkRect::MakeWH(SkIntToScalar(dstDesc.fWidth), | 269 const SkRect rect = SkRect::MakeWH(SkIntToScalar(dstDesc.fWidth), |
272 SkIntToScalar(dstDesc.fHeight)); | 270 SkIntToScalar(dstDesc.fHeight)); |
273 SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext(dst->asRenderTarget
())); | 271 SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext(dst->asRenderTarget
())); |
274 if (!drawContext) { | 272 if (!drawContext) { |
275 return nullptr; | 273 return nullptr; |
276 } | 274 } |
277 | 275 |
278 drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect); | 276 drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect); |
279 ctx->flushSurfaceWrites(dst); | 277 ctx->flushSurfaceWrites(dst); |
280 return sk_make_sp<SkImage_Gpu>(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImag
eUniqueID, | 278 return new SkImage_Gpu(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImageUniqueI
D, |
281 kOpaque_SkAlphaType, dst, budgeted); | 279 kOpaque_SkAlphaType, dst, budgeted); |
282 } | 280 } |
283 | 281 |
284 static sk_sp<SkImage> create_image_from_maker(GrTextureMaker* maker, SkAlphaType
at, uint32_t id) { | 282 static SkImage* create_image_from_maker(GrTextureMaker* maker, SkAlphaType at, u
int32_t id) { |
285 SkAutoTUnref<GrTexture> texture(maker->refTextureForParams(GrTextureParams::
ClampNoFilter())); | 283 SkAutoTUnref<GrTexture> texture(maker->refTextureForParams(GrTextureParams::
ClampNoFilter())); |
286 if (!texture) { | 284 if (!texture) { |
287 return nullptr; | 285 return nullptr; |
288 } | 286 } |
289 return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), id, at,
texture, | 287 return new SkImage_Gpu(texture->width(), texture->height(), id, at, texture, |
290 SkBudgeted::kNo); | 288 SkBudgeted::kNo); |
291 } | 289 } |
292 | 290 |
293 sk_sp<SkImage> SkImage::makeTextureImage(GrContext *context) const { | 291 SkImage* SkImage::newTextureImage(GrContext *context) const { |
294 if (!context) { | 292 if (!context) { |
295 return nullptr; | 293 return nullptr; |
296 } | 294 } |
297 if (GrTexture* peek = as_IB(this)->peekTexture()) { | 295 if (GrTexture* peek = as_IB(this)->peekTexture()) { |
298 return peek->getContext() == context ? sk_ref_sp(const_cast<SkImage*>(th
is)) : nullptr; | 296 return peek->getContext() == context ? SkRef(const_cast<SkImage*>(this))
: nullptr; |
299 } | 297 } |
300 // No way to check whether a image is premul or not? | 298 // No way to check whether a image is premul or not? |
301 SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaTyp
e; | 299 SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaTyp
e; |
302 | 300 |
303 if (SkImageCacherator* cacher = as_IB(this)->peekCacherator()) { | 301 if (SkImageCacherator* cacher = as_IB(this)->peekCacherator()) { |
304 GrImageTextureMaker maker(context, cacher, this, kDisallow_CachingHint); | 302 GrImageTextureMaker maker(context, cacher, this, kDisallow_CachingHint); |
305 return create_image_from_maker(&maker, at, this->uniqueID()); | 303 return create_image_from_maker(&maker, at, this->uniqueID()); |
306 } | 304 } |
307 SkBitmap bmp; | 305 SkBitmap bmp; |
308 if (!this->asLegacyBitmap(&bmp, kRO_LegacyBitmapMode)) { | 306 if (!this->asLegacyBitmap(&bmp, kRO_LegacyBitmapMode)) { |
309 return nullptr; | 307 return nullptr; |
310 } | 308 } |
311 GrBitmapTextureMaker maker(context, bmp); | 309 GrBitmapTextureMaker maker(context, bmp); |
312 return create_image_from_maker(&maker, at, this->uniqueID()); | 310 return create_image_from_maker(&maker, at, this->uniqueID()); |
313 } | 311 } |
314 | 312 |
315 sk_sp<SkImage> SkImage::MakeTextureFromPixmap(GrContext* ctx, const SkPixmap& pi
xmap, | 313 SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pixmap, |
316 SkBudgeted budgeted) { | 314 SkBudgeted budgeted) { |
317 if (!ctx) { | 315 if (!ctx) { |
318 return nullptr; | 316 return nullptr; |
319 } | 317 } |
320 SkAutoTUnref<GrTexture> texture(GrUploadPixmapToTexture(ctx, pixmap)); | 318 SkAutoTUnref<GrTexture> texture(GrUploadPixmapToTexture(ctx, pixmap)); |
321 if (!texture) { | 319 if (!texture) { |
322 return nullptr; | 320 return nullptr; |
323 } | 321 } |
324 return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNew
ImageUniqueID, | 322 return new SkImage_Gpu(texture->width(), texture->height(), kNeedNewImageUni
queID, |
325 pixmap.alphaType(), texture, budgeted); | 323 pixmap.alphaType(), texture, budgeted); |
326 } | 324 } |
327 | 325 |
328 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 326 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
329 | 327 |
330 GrTexture* GrDeepCopyTexture(GrTexture* src, SkBudgeted budgeted) { | 328 GrTexture* GrDeepCopyTexture(GrTexture* src, SkBudgeted budgeted) { |
331 GrContext* ctx = src->getContext(); | 329 GrContext* ctx = src->getContext(); |
332 | 330 |
333 GrSurfaceDesc desc = src->desc(); | 331 GrSurfaceDesc desc = src->desc(); |
334 GrTexture* dst = ctx->textureProvider()->createTexture(desc, budgeted, nullp
tr, 0); | 332 GrTexture* dst = ctx->textureProvider()->createTexture(desc, budgeted, nullp
tr, 0); |
335 if (!dst) { | 333 if (!dst) { |
336 return nullptr; | 334 return nullptr; |
337 } | 335 } |
338 | 336 |
339 const SkIRect srcR = SkIRect::MakeWH(desc.fWidth, desc.fHeight); | 337 const SkIRect srcR = SkIRect::MakeWH(desc.fWidth, desc.fHeight); |
340 const SkIPoint dstP = SkIPoint::Make(0, 0); | 338 const SkIPoint dstP = SkIPoint::Make(0, 0); |
341 ctx->copySurface(dst, src, srcR, dstP); | 339 ctx->copySurface(dst, src, srcR, dstP); |
342 ctx->flushSurfaceWrites(dst); | 340 ctx->flushSurfaceWrites(dst); |
343 return dst; | 341 return dst; |
344 } | 342 } |
345 | 343 |
OLD | NEW |