src/image/SkImage_GpuYUVA.cpp - skia - Git at Google

 /*
  * Copyright 2018 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include <cstddef>
 #include <cstring>
 #include <type_traits>

 #include "GrClip.h"
 #include "GrContext.h"
 #include "GrContextPriv.h"
 #include "GrGpu.h"
 #include "GrRenderTargetContext.h"
 #include "GrTexture.h"
 #include "GrTextureProducer.h"
 #include "SkAutoPixmapStorage.h"
 #include "SkGr.h"
 #include "SkImage_Gpu.h"
 #include "SkImage_GpuYUVA.h"
 #include "SkMipMap.h"
 #include "SkScopeExit.h"
 #include "SkYUVASizeInfo.h"
 #include "effects/GrYUVtoRGBEffect.h"

 SkImage_GpuYUVA::SkImage_GpuYUVA(sk_sp<GrContext> context, int width, int height, uint32_t uniqueID,
                                  SkYUVColorSpace colorSpace, sk_sp<GrTextureProxy> proxies[],
                                  int numProxies, const SkYUVAIndex yuvaIndices[4],
                                  GrSurfaceOrigin origin, sk_sp<SkColorSpace> imageColorSpace)
         : INHERITED(std::move(context), width, height, uniqueID,
                     // If an alpha channel is present we always switch to kPremul. This is because,
                     // although the planar data is always un-premul, the final interleaved RGB image
                     // is/would-be premul.
                     GetAlphaTypeFromYUVAIndices(yuvaIndices), imageColorSpace)
         , fNumProxies(numProxies)
         , fYUVColorSpace(colorSpace)
         , fOrigin(origin) {
     // The caller should have done this work, just verifying
     SkDEBUGCODE(int textureCount;)
     SkASSERT(SkYUVAIndex::AreValidIndices(yuvaIndices, &textureCount));
     SkASSERT(textureCount == fNumProxies);

     for (int i = 0; i < numProxies; ++i) {
         fProxies[i] = std::move(proxies[i]);
     }
     memcpy(fYUVAIndices, yuvaIndices, 4*sizeof(SkYUVAIndex));
 }

 // For onMakeColorSpace()
 SkImage_GpuYUVA::SkImage_GpuYUVA(const SkImage_GpuYUVA* image, sk_sp<SkColorSpace> targetCS)
     : INHERITED(image->fContext, image->width(), image->height(), kNeedNewImageUniqueID,
                 // If an alpha channel is present we always switch to kPremul. This is because,
                 // although the planar data is always un-premul, the final interleaved RGB image
                 // is/would-be premul.
                 GetAlphaTypeFromYUVAIndices(image->fYUVAIndices), image->fColorSpace)
     , fNumProxies(image->fNumProxies)
     , fYUVColorSpace(image->fYUVColorSpace)
     , fOrigin(image->fOrigin)
     , fTargetColorSpace(targetCS) {
         // The caller should have done this work, just verifying
     SkDEBUGCODE(int textureCount;)
         SkASSERT(SkYUVAIndex::AreValidIndices(image->fYUVAIndices, &textureCount));
     SkASSERT(textureCount == fNumProxies);

     for (int i = 0; i < fNumProxies; ++i) {
         fProxies[i] = image->fProxies[i];  // we ref in this case, not move
     }
     memcpy(fYUVAIndices, image->fYUVAIndices, 4 * sizeof(SkYUVAIndex));
 }

 SkImage_GpuYUVA::~SkImage_GpuYUVA() {}

 SkImageInfo SkImage_GpuYUVA::onImageInfo() const {
     // Note: this is the imageInfo for the flattened image, not the YUV planes
     return SkImageInfo::Make(this->width(), this->height(), kRGBA_8888_SkColorType,
                              fAlphaType, fColorSpace);
 }

 bool SkImage_GpuYUVA::setupMipmapsForPlanes() const {
     for (int i = 0; i < fNumProxies; ++i) {
         GrTextureProducer::CopyParams copyParams;
         int mipCount = SkMipMap::ComputeLevelCount(fProxies[i]->width(), fProxies[i]->height());
         if (mipCount && GrGpu::IsACopyNeededForMips(fContext->contextPriv().caps(),
                                                     fProxies[i].get(),
                                                     GrSamplerState::Filter::kMipMap,
                                                     &copyParams)) {
             auto mippedProxy = GrCopyBaseMipMapToTextureProxy(fContext.get(), fProxies[i].get());
             if (!mippedProxy) {
                 return false;
             }
             fProxies[i] = mippedProxy;
         }
     }
     return true;
 }

 //////////////////////////////////////////////////////////////////////////////////////////////////

 sk_sp<GrTextureProxy> SkImage_GpuYUVA::asTextureProxyRef() const {
     if (!fRGBProxy) {
         const GrBackendFormat format =
             fContext->contextPriv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);

         // Needs to create a render target in order to draw to it for the yuv->rgb conversion.
         sk_sp<GrRenderTargetContext> renderTargetContext(
             fContext->contextPriv().makeDeferredRenderTargetContext(
                 format, SkBackingFit::kExact, this->width(), this->height(),
                 kRGBA_8888_GrPixelConfig, fColorSpace, 1, GrMipMapped::kNo, fOrigin));
         if (!renderTargetContext) {
             return nullptr;
         }

         const SkRect rect = SkRect::MakeIWH(this->width(), this->height());
         if (!RenderYUVAToRGBA(fContext.get(), renderTargetContext.get(), rect, fYUVColorSpace,
                               fProxies, fYUVAIndices)) {
             return nullptr;
         }

         fRGBProxy = renderTargetContext->asTextureProxyRef();
     }

     return fRGBProxy;
 }

 sk_sp<GrTextureProxy> SkImage_GpuYUVA::asMippedTextureProxyRef() const {
     // if invalid or already has miplevels
     auto proxy = this->asTextureProxyRef();
     if (!proxy || GrMipMapped::kYes == fRGBProxy->mipMapped()) {
         return proxy;
     }

     // need to generate mips for the proxy
     if (auto mippedProxy = GrCopyBaseMipMapToTextureProxy(fContext.get(), proxy.get())) {
         fRGBProxy = mippedProxy;
         return mippedProxy;
     }

     // failed to generate mips
     return nullptr;
 }

 //////////////////////////////////////////////////////////////////////////////////////////////////

 sk_sp<SkImage> SkImage_GpuYUVA::onMakeColorTypeAndColorSpace(SkColorType,
                                                              sk_sp<SkColorSpace> targetCS) const {
     // We explicitly ignore color type changes, for now.

     // we may need a mutex here but for now we expect usage to be in a single thread
     if (fOnMakeColorSpaceTarget &&
         SkColorSpace::Equals(targetCS.get(), fOnMakeColorSpaceTarget.get())) {
         return fOnMakeColorSpaceResult;
     }
     sk_sp<SkImage> result = sk_sp<SkImage>(new SkImage_GpuYUVA(this, targetCS));
     if (result) {
         fOnMakeColorSpaceTarget = targetCS;
         fOnMakeColorSpaceResult = result;
     }
     return result;
 }

 //////////////////////////////////////////////////////////////////////////////////////////////////

 sk_sp<SkImage> SkImage::MakeFromYUVATextures(GrContext* ctx,
                                              SkYUVColorSpace colorSpace,
                                              const GrBackendTexture yuvaTextures[],
                                              const SkYUVAIndex yuvaIndices[4],
                                              SkISize imageSize,
                                              GrSurfaceOrigin imageOrigin,
                                              sk_sp<SkColorSpace> imageColorSpace) {
     int numTextures;
     if (!SkYUVAIndex::AreValidIndices(yuvaIndices, &numTextures)) {
         return nullptr;
     }

     sk_sp<GrTextureProxy> tempTextureProxies[4];
     if (!SkImage_GpuBase::MakeTempTextureProxies(ctx, yuvaTextures, numTextures, yuvaIndices,
                                                  imageOrigin, tempTextureProxies)) {
         return nullptr;
     }

     return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(ctx), imageSize.width(), imageSize.height(),
                                        kNeedNewImageUniqueID, colorSpace, tempTextureProxies,
                                        numTextures, yuvaIndices, imageOrigin, imageColorSpace);
 }

 sk_sp<SkImage> SkImage::MakeFromYUVAPixmaps(
         GrContext* context, SkYUVColorSpace yuvColorSpace, const SkPixmap yuvaPixmaps[],
         const SkYUVAIndex yuvaIndices[4], SkISize imageSize, GrSurfaceOrigin imageOrigin,
         bool buildMips, bool limitToMaxTextureSize, sk_sp<SkColorSpace> imageColorSpace) {
     int numPixmaps;
     if (!SkYUVAIndex::AreValidIndices(yuvaIndices, &numPixmaps)) {
         return nullptr;
     }

     // Make proxies
     GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
     sk_sp<GrTextureProxy> tempTextureProxies[4];
     for (int i = 0; i < numPixmaps; ++i) {
         const SkPixmap* pixmap = &yuvaPixmaps[i];
         SkAutoPixmapStorage resized;
         int maxTextureSize = context->contextPriv().caps()->maxTextureSize();
         int maxDim = SkTMax(yuvaPixmaps[i].width(), yuvaPixmaps[i].height());
         if (limitToMaxTextureSize && maxDim > maxTextureSize) {
             float scale = static_cast<float>(maxTextureSize) / maxDim;
             int newWidth = SkTMin(static_cast<int>(yuvaPixmaps[i].width() * scale),
                                   maxTextureSize);
             int newHeight = SkTMin(static_cast<int>(yuvaPixmaps[i].height() * scale),
                                    maxTextureSize);
             SkImageInfo info = yuvaPixmaps[i].info().makeWH(newWidth, newHeight);
             if (!resized.tryAlloc(info) ||
                 !yuvaPixmaps[i].scalePixels(resized, kLow_SkFilterQuality)) {
                 return nullptr;
             }
             pixmap = &resized;
         }
         // Turn the pixmap into a GrTextureProxy
         if (buildMips) {
             SkBitmap bmp;
             bmp.installPixels(*pixmap);
             tempTextureProxies[i] = proxyProvider->createMipMapProxyFromBitmap(bmp);
         }
         if (!tempTextureProxies[i]) {
             if (SkImageInfoIsValid(pixmap->info())) {
                 ATRACE_ANDROID_FRAMEWORK("Upload Texture [%ux%u]",
                                          pixmap->width(), pixmap->height());
                 // We don't need a release proc on the data in pixmap since we know we are in a
                 // GrContext that has a resource provider. Thus the createTextureProxy call will
                 // immediately upload the data.
                 sk_sp<SkImage> image = SkImage::MakeFromRaster(*pixmap, nullptr, nullptr);
                 tempTextureProxies[i] =
                         proxyProvider->createTextureProxy(std::move(image), kNone_GrSurfaceFlags, 1,
                                                           SkBudgeted::kYes, SkBackingFit::kExact);
             }
         }

         if (!tempTextureProxies[i]) {
             return nullptr;
         }
     }

     return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context), imageSize.width(), imageSize.height(),
                                        kNeedNewImageUniqueID, yuvColorSpace, tempTextureProxies,
                                        numPixmaps, yuvaIndices, imageOrigin, imageColorSpace);
 }


 /////////////////////////////////////////////////////////////////////////////////////////////////
 sk_sp<SkImage> SkImage_GpuYUVA::MakePromiseYUVATexture(
         GrContext* context,
         SkYUVColorSpace yuvColorSpace,
         const GrBackendFormat yuvaFormats[],
         const SkISize yuvaSizes[],
         const SkYUVAIndex yuvaIndices[4],
         int imageWidth,
         int imageHeight,
         GrSurfaceOrigin imageOrigin,
         sk_sp<SkColorSpace> imageColorSpace,
         PromiseImageTextureFulfillProc textureFulfillProc,
         PromiseImageTextureReleaseProc textureReleaseProc,
         PromiseImageTextureDoneProc promiseDoneProc,
         PromiseImageTextureContext textureContexts[],
         DelayReleaseCallback delayReleaseCallback) {
     int numTextures;
     bool valid = SkYUVAIndex::AreValidIndices(yuvaIndices, &numTextures);

     // The contract here is that if 'promiseDoneProc' is passed in it should always be called,
     // even if creation of the SkImage fails. Once we call MakePromiseImageLazyProxy it takes
     // responsibility for calling the done proc.
     if (!promiseDoneProc) {
         return nullptr;
     }
     int proxiesCreated = 0;
     SkScopeExit callDone([promiseDoneProc, textureContexts, numTextures, &proxiesCreated]() {
         for (int i = proxiesCreated; i < numTextures; ++i) {
             promiseDoneProc(textureContexts[i]);
         }
     });

     if (!valid) {
         return nullptr;
     }

     if (!context) {
         return nullptr;
     }

     if (imageWidth <= 0 || imageWidth <= 0) {
         return nullptr;
     }

     SkAlphaType at = (-1 != yuvaIndices[SkYUVAIndex::kA_Index].fIndex) ? kPremul_SkAlphaType
                                                                        : kOpaque_SkAlphaType;
     SkImageInfo info = SkImageInfo::Make(imageWidth, imageHeight, kRGBA_8888_SkColorType,
                                          at, imageColorSpace);
     if (!SkImageInfoIsValid(info)) {
         return nullptr;
     }

     // verify sizes with expected texture count
     for (int i = 0; i < numTextures; ++i) {
         if (yuvaSizes[i].isEmpty()) {
             return nullptr;
         }
     }
     for (int i = numTextures; i < SkYUVASizeInfo::kMaxCount; ++i) {
         if (!yuvaSizes[i].isEmpty()) {
             return nullptr;
         }
     }

     // Get lazy proxies
     sk_sp<GrTextureProxy> proxies[4];
     for (int texIdx = 0; texIdx < numTextures; ++texIdx) {
         GrPixelConfig config =
                 context->contextPriv().caps()->getYUVAConfigFromBackendFormat(yuvaFormats[texIdx]);
         if (config == kUnknown_GrPixelConfig) {
             return nullptr;
         }
         proxies[texIdx] = MakePromiseImageLazyProxy(
                 context, yuvaSizes[texIdx].width(), yuvaSizes[texIdx].height(), imageOrigin, config,
                 yuvaFormats[texIdx], GrMipMapped::kNo, textureFulfillProc, textureReleaseProc,
                 promiseDoneProc, textureContexts[texIdx], delayReleaseCallback);
         ++proxiesCreated;
         if (!proxies[texIdx]) {
             return nullptr;
         }
     }

     return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context), imageWidth, imageHeight,
                                        kNeedNewImageUniqueID, yuvColorSpace, proxies, numTextures,
                                        yuvaIndices, imageOrigin, std::move(imageColorSpace));
 }
	/*
	* Copyright 2018 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include <cstddef>
	#include <cstring>
	#include <type_traits>

	#include "GrClip.h"
	#include "GrContext.h"
	#include "GrContextPriv.h"
	#include "GrGpu.h"
	#include "GrRenderTargetContext.h"
	#include "GrTexture.h"
	#include "GrTextureProducer.h"
	#include "SkAutoPixmapStorage.h"
	#include "SkGr.h"
	#include "SkImage_Gpu.h"
	#include "SkImage_GpuYUVA.h"
	#include "SkMipMap.h"
	#include "SkScopeExit.h"
	#include "SkYUVASizeInfo.h"
	#include "effects/GrYUVtoRGBEffect.h"

	SkImage_GpuYUVA::SkImage_GpuYUVA(sk_sp<GrContext> context, int width, int height, uint32_t uniqueID,
	SkYUVColorSpace colorSpace, sk_sp<GrTextureProxy> proxies[],
	int numProxies, const SkYUVAIndex yuvaIndices[4],
	GrSurfaceOrigin origin, sk_sp<SkColorSpace> imageColorSpace)
	: INHERITED(std::move(context), width, height, uniqueID,
	// If an alpha channel is present we always switch to kPremul. This is because,
	// although the planar data is always un-premul, the final interleaved RGB image
	// is/would-be premul.
	GetAlphaTypeFromYUVAIndices(yuvaIndices), imageColorSpace)
	, fNumProxies(numProxies)
	, fYUVColorSpace(colorSpace)
	, fOrigin(origin) {
	// The caller should have done this work, just verifying
	SkDEBUGCODE(int textureCount;)
	SkASSERT(SkYUVAIndex::AreValidIndices(yuvaIndices, &textureCount));
	SkASSERT(textureCount == fNumProxies);

	for (int i = 0; i < numProxies; ++i) {
	fProxies[i] = std::move(proxies[i]);
	}
	memcpy(fYUVAIndices, yuvaIndices, 4*sizeof(SkYUVAIndex));
	}

	// For onMakeColorSpace()
	SkImage_GpuYUVA::SkImage_GpuYUVA(const SkImage_GpuYUVA* image, sk_sp<SkColorSpace> targetCS)
	: INHERITED(image->fContext, image->width(), image->height(), kNeedNewImageUniqueID,
	// If an alpha channel is present we always switch to kPremul. This is because,
	// although the planar data is always un-premul, the final interleaved RGB image
	// is/would-be premul.
	GetAlphaTypeFromYUVAIndices(image->fYUVAIndices), image->fColorSpace)
	, fNumProxies(image->fNumProxies)
	, fYUVColorSpace(image->fYUVColorSpace)
	, fOrigin(image->fOrigin)
	, fTargetColorSpace(targetCS) {
	// The caller should have done this work, just verifying
	SkDEBUGCODE(int textureCount;)
	SkASSERT(SkYUVAIndex::AreValidIndices(image->fYUVAIndices, &textureCount));
	SkASSERT(textureCount == fNumProxies);

	for (int i = 0; i < fNumProxies; ++i) {
	fProxies[i] = image->fProxies[i]; // we ref in this case, not move
	}
	memcpy(fYUVAIndices, image->fYUVAIndices, 4 * sizeof(SkYUVAIndex));
	}

	SkImage_GpuYUVA::~SkImage_GpuYUVA() {}

	SkImageInfo SkImage_GpuYUVA::onImageInfo() const {
	// Note: this is the imageInfo for the flattened image, not the YUV planes
	return SkImageInfo::Make(this->width(), this->height(), kRGBA_8888_SkColorType,
	fAlphaType, fColorSpace);
	}

	bool SkImage_GpuYUVA::setupMipmapsForPlanes() const {
	for (int i = 0; i < fNumProxies; ++i) {
	GrTextureProducer::CopyParams copyParams;
	int mipCount = SkMipMap::ComputeLevelCount(fProxies[i]->width(), fProxies[i]->height());
	if (mipCount && GrGpu::IsACopyNeededForMips(fContext->contextPriv().caps(),
	fProxies[i].get(),
	GrSamplerState::Filter::kMipMap,
	&copyParams)) {
	auto mippedProxy = GrCopyBaseMipMapToTextureProxy(fContext.get(), fProxies[i].get());
	if (!mippedProxy) {
	return false;
	}
	fProxies[i] = mippedProxy;
	}
	}
	return true;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////

	sk_sp<GrTextureProxy> SkImage_GpuYUVA::asTextureProxyRef() const {
	if (!fRGBProxy) {
	const GrBackendFormat format =
	fContext->contextPriv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);

	// Needs to create a render target in order to draw to it for the yuv->rgb conversion.
	sk_sp<GrRenderTargetContext> renderTargetContext(
	fContext->contextPriv().makeDeferredRenderTargetContext(
	format, SkBackingFit::kExact, this->width(), this->height(),
	kRGBA_8888_GrPixelConfig, fColorSpace, 1, GrMipMapped::kNo, fOrigin));
	if (!renderTargetContext) {
	return nullptr;
	}

	const SkRect rect = SkRect::MakeIWH(this->width(), this->height());
	if (!RenderYUVAToRGBA(fContext.get(), renderTargetContext.get(), rect, fYUVColorSpace,
	fProxies, fYUVAIndices)) {
	return nullptr;
	}

	fRGBProxy = renderTargetContext->asTextureProxyRef();
	}

	return fRGBProxy;
	}

	sk_sp<GrTextureProxy> SkImage_GpuYUVA::asMippedTextureProxyRef() const {
	// if invalid or already has miplevels
	auto proxy = this->asTextureProxyRef();
	if (!proxy \|\| GrMipMapped::kYes == fRGBProxy->mipMapped()) {
	return proxy;
	}

	// need to generate mips for the proxy
	if (auto mippedProxy = GrCopyBaseMipMapToTextureProxy(fContext.get(), proxy.get())) {
	fRGBProxy = mippedProxy;
	return mippedProxy;
	}

	// failed to generate mips
	return nullptr;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////

	sk_sp<SkImage> SkImage_GpuYUVA::onMakeColorTypeAndColorSpace(SkColorType,
	sk_sp<SkColorSpace> targetCS) const {
	// We explicitly ignore color type changes, for now.

	// we may need a mutex here but for now we expect usage to be in a single thread
	if (fOnMakeColorSpaceTarget &&
	SkColorSpace::Equals(targetCS.get(), fOnMakeColorSpaceTarget.get())) {
	return fOnMakeColorSpaceResult;
	}
	sk_sp<SkImage> result = sk_sp<SkImage>(new SkImage_GpuYUVA(this, targetCS));
	if (result) {
	fOnMakeColorSpaceTarget = targetCS;
	fOnMakeColorSpaceResult = result;
	}
	return result;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////

	sk_sp<SkImage> SkImage::MakeFromYUVATextures(GrContext* ctx,
	SkYUVColorSpace colorSpace,
	const GrBackendTexture yuvaTextures[],
	const SkYUVAIndex yuvaIndices[4],
	SkISize imageSize,
	GrSurfaceOrigin imageOrigin,
	sk_sp<SkColorSpace> imageColorSpace) {
	int numTextures;
	if (!SkYUVAIndex::AreValidIndices(yuvaIndices, &numTextures)) {
	return nullptr;
	}

	sk_sp<GrTextureProxy> tempTextureProxies[4];
	if (!SkImage_GpuBase::MakeTempTextureProxies(ctx, yuvaTextures, numTextures, yuvaIndices,
	imageOrigin, tempTextureProxies)) {
	return nullptr;
	}

	return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(ctx), imageSize.width(), imageSize.height(),
	kNeedNewImageUniqueID, colorSpace, tempTextureProxies,
	numTextures, yuvaIndices, imageOrigin, imageColorSpace);
	}

	sk_sp<SkImage> SkImage::MakeFromYUVAPixmaps(
	GrContext* context, SkYUVColorSpace yuvColorSpace, const SkPixmap yuvaPixmaps[],
	const SkYUVAIndex yuvaIndices[4], SkISize imageSize, GrSurfaceOrigin imageOrigin,
	bool buildMips, bool limitToMaxTextureSize, sk_sp<SkColorSpace> imageColorSpace) {
	int numPixmaps;
	if (!SkYUVAIndex::AreValidIndices(yuvaIndices, &numPixmaps)) {
	return nullptr;
	}

	// Make proxies
	GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
	sk_sp<GrTextureProxy> tempTextureProxies[4];
	for (int i = 0; i < numPixmaps; ++i) {
	const SkPixmap* pixmap = &yuvaPixmaps[i];
	SkAutoPixmapStorage resized;
	int maxTextureSize = context->contextPriv().caps()->maxTextureSize();
	int maxDim = SkTMax(yuvaPixmaps[i].width(), yuvaPixmaps[i].height());
	if (limitToMaxTextureSize && maxDim > maxTextureSize) {
	float scale = static_cast<float>(maxTextureSize) / maxDim;
	int newWidth = SkTMin(static_cast<int>(yuvaPixmaps[i].width() * scale),
	maxTextureSize);
	int newHeight = SkTMin(static_cast<int>(yuvaPixmaps[i].height() * scale),
	maxTextureSize);
	SkImageInfo info = yuvaPixmaps[i].info().makeWH(newWidth, newHeight);
	if (!resized.tryAlloc(info) \|\|
	!yuvaPixmaps[i].scalePixels(resized, kLow_SkFilterQuality)) {
	return nullptr;
	}
	pixmap = &resized;
	}
	// Turn the pixmap into a GrTextureProxy
	if (buildMips) {
	SkBitmap bmp;
	bmp.installPixels(*pixmap);
	tempTextureProxies[i] = proxyProvider->createMipMapProxyFromBitmap(bmp);
	}
	if (!tempTextureProxies[i]) {
	if (SkImageInfoIsValid(pixmap->info())) {
	ATRACE_ANDROID_FRAMEWORK("Upload Texture [%ux%u]",
	pixmap->width(), pixmap->height());
	// We don't need a release proc on the data in pixmap since we know we are in a
	// GrContext that has a resource provider. Thus the createTextureProxy call will
	// immediately upload the data.
	sk_sp<SkImage> image = SkImage::MakeFromRaster(*pixmap, nullptr, nullptr);
	tempTextureProxies[i] =
	proxyProvider->createTextureProxy(std::move(image), kNone_GrSurfaceFlags, 1,
	SkBudgeted::kYes, SkBackingFit::kExact);
	}
	}

	if (!tempTextureProxies[i]) {
	return nullptr;
	}
	}

	return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context), imageSize.width(), imageSize.height(),
	kNeedNewImageUniqueID, yuvColorSpace, tempTextureProxies,
	numPixmaps, yuvaIndices, imageOrigin, imageColorSpace);
	}


	/////////////////////////////////////////////////////////////////////////////////////////////////
	sk_sp<SkImage> SkImage_GpuYUVA::MakePromiseYUVATexture(
	GrContext* context,
	SkYUVColorSpace yuvColorSpace,
	const GrBackendFormat yuvaFormats[],
	const SkISize yuvaSizes[],
	const SkYUVAIndex yuvaIndices[4],
	int imageWidth,
	int imageHeight,
	GrSurfaceOrigin imageOrigin,
	sk_sp<SkColorSpace> imageColorSpace,
	PromiseImageTextureFulfillProc textureFulfillProc,
	PromiseImageTextureReleaseProc textureReleaseProc,
	PromiseImageTextureDoneProc promiseDoneProc,
	PromiseImageTextureContext textureContexts[],
	DelayReleaseCallback delayReleaseCallback) {
	int numTextures;
	bool valid = SkYUVAIndex::AreValidIndices(yuvaIndices, &numTextures);

	// The contract here is that if 'promiseDoneProc' is passed in it should always be called,
	// even if creation of the SkImage fails. Once we call MakePromiseImageLazyProxy it takes
	// responsibility for calling the done proc.
	if (!promiseDoneProc) {
	return nullptr;
	}
	int proxiesCreated = 0;
	SkScopeExit callDone([promiseDoneProc, textureContexts, numTextures, &proxiesCreated]() {
	for (int i = proxiesCreated; i < numTextures; ++i) {
	promiseDoneProc(textureContexts[i]);
	}
	});

	if (!valid) {
	return nullptr;
	}

	if (!context) {
	return nullptr;
	}

	if (imageWidth <= 0 \|\| imageWidth <= 0) {
	return nullptr;
	}

	SkAlphaType at = (-1 != yuvaIndices[SkYUVAIndex::kA_Index].fIndex) ? kPremul_SkAlphaType
	: kOpaque_SkAlphaType;
	SkImageInfo info = SkImageInfo::Make(imageWidth, imageHeight, kRGBA_8888_SkColorType,
	at, imageColorSpace);
	if (!SkImageInfoIsValid(info)) {
	return nullptr;
	}

	// verify sizes with expected texture count
	for (int i = 0; i < numTextures; ++i) {
	if (yuvaSizes[i].isEmpty()) {
	return nullptr;
	}
	}
	for (int i = numTextures; i < SkYUVASizeInfo::kMaxCount; ++i) {
	if (!yuvaSizes[i].isEmpty()) {
	return nullptr;
	}
	}

	// Get lazy proxies
	sk_sp<GrTextureProxy> proxies[4];
	for (int texIdx = 0; texIdx < numTextures; ++texIdx) {
	GrPixelConfig config =
	context->contextPriv().caps()->getYUVAConfigFromBackendFormat(yuvaFormats[texIdx]);
	if (config == kUnknown_GrPixelConfig) {
	return nullptr;
	}
	proxies[texIdx] = MakePromiseImageLazyProxy(
	context, yuvaSizes[texIdx].width(), yuvaSizes[texIdx].height(), imageOrigin, config,
	yuvaFormats[texIdx], GrMipMapped::kNo, textureFulfillProc, textureReleaseProc,
	promiseDoneProc, textureContexts[texIdx], delayReleaseCallback);
	++proxiesCreated;
	if (!proxies[texIdx]) {
	return nullptr;
	}
	}

	return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context), imageWidth, imageHeight,
	kNeedNewImageUniqueID, yuvColorSpace, proxies, numTextures,
	yuvaIndices, imageOrigin, std::move(imageColorSpace));
	}