Revert "New variant of SkImage::MakeFromYUVATextures."

This reverts commit fea1223.

Reason for revert: MSAN/SwiftShader failure

Original change's description:
> New variant of SkImage::MakeFromYUVATextures.
>
> Takes a new type GrYUVATextures. This a set of GrBackendTextures and
> SkYUVAInfo that have been pre-validated to be compatible.
>
> Bug: skia:10632
>
> Change-Id: Id252f8662ede0f268e88fd40dc1b0b8f4ab6345f
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/317762
> Commit-Queue: Brian Salomon <bsalomon@google.com>
> Reviewed-by: Jim Van Verth <jvanverth@google.com>
> Reviewed-by: Robert Phillips <robertphillips@google.com>

TBR=jvanverth@google.com,bsalomon@google.com,robertphillips@google.com

Change-Id: I5350d4f9b1eda0503fb0af9db8575a734bdc811f
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:10632
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/327922
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

Author: bsalomon

RELEASE_NOTES.txt

@@ -6,12 +6,8 @@ This file includes a list of high level updates for each milestone release.
 
 Milestone 88
 ------------
-  * <insert new release notes here>
 
-  * New variant of SkImage::MakeFromYUVATextures. Takes a new type GrYUVATextures
-    which wraps an SkYUVAInfo and compatible set of GrBackendTextures. The provides
-    a more complete and structured specification of the planar configuration. Previous
-    version is deprecated.
+  * <insert new release notes here>
 
   * SkTPin() removed from public API.
 

gn/gpu.gni

@@ -19,7 +19,6 @@ skia_gpu_sources = [
   "$_include/gpu/GrDriverBugWorkarounds.h",
   "$_include/gpu/GrRecordingContext.h",
   "$_include/gpu/GrTypes.h",
-  "$_include/gpu/GrYUVABackendTextures.h",
 
   # Private includes
   "$_include/private/GrContext.h",
@@ -270,7 +269,6 @@ skia_gpu_sources = [
   "$_src/gpu/GrWindowRectsState.h",
   "$_src/gpu/GrXferProcessor.cpp",
   "$_src/gpu/GrXferProcessor.h",
-  "$_src/gpu/GrYUVABackendTextures.cpp",
 
   # Ops
   "$_src/gpu/effects/GrBezierEffect.cpp",

include/core/SkImage.h

@@ -38,7 +38,6 @@ class GrContext;
 class GrDirectContext;
 class GrRecordingContext;
 class GrContextThreadSafeProxy;
-class GrYUVABackendTextures;
 
 struct SkYUVAIndex;
 
@@ -409,30 +408,7 @@ class SK_API SkImage : public SkRefCnt {
                                                  SkAlphaType alphaType = kPremul_SkAlphaType,
                                                  sk_sp<SkColorSpace> colorSpace = nullptr);
 
-    /** Creates an SkImage from YUV[A] planar textures. This requires that the textures stay valid
-        for the lifetime of the image. The ReleaseContext can be used to know when it is safe to
-        either delete or overwrite the textures. If ReleaseProc is provided it is also called before
-        return on failure.
-
-        @param context            GPU context
-        @param yuvaTextures       A set of textures containing YUVA data and a description of the
-                                  data and transformation to RGBA.
-        @param imageColorSpace    range of colors of the resulting image after conversion to RGB;
-                                  may be nullptr
-        @param textureReleaseProc called when the backend textures can be released
-        @param releaseContext     state passed to textureReleaseProc
-        @return                   created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromYUVATextures(GrRecordingContext* context,
-                                               const GrYUVABackendTextures& yuvaTextures,
-                                               sk_sp<SkColorSpace> imageColorSpace = nullptr,
-                                               TextureReleaseProc textureReleaseProc = nullptr,
-                                               ReleaseContext releaseContext = nullptr);
-
-    /**
-        Deprecated. Use version that takes GrYUVABackendTextures.
-
-        Creates an SkImage by storing the specified YUVA planes into an image, to be rendered
+    /** Creates an SkImage by storing the specified YUVA planes into an image, to be rendered
         via multitexturing.
 
         When all the provided backend textures can be released 'textureReleaseProc' will be called

include/core/SkYUVAInfo.h

@@ -39,8 +39,6 @@ class SK_API SkYUVAInfo {
      * this expands.
      */
     enum class PlanarConfig {
-        kUnknown,
-
         kY_U_V_444,    ///< Plane 0: Y, Plane 1: U,  Plane 2: V
         kY_U_V_422,    ///< Plane 0: Y, Plane 1: U,  Plane 2: V
         kY_U_V_420,    ///< Plane 0: Y, Plane 1: U,  Plane 2: V
@@ -179,12 +177,10 @@ class SK_API SkYUVAInfo {
     bool operator==(const SkYUVAInfo& that) const;
     bool operator!=(const SkYUVAInfo& that) const { return !(*this == that); }
 
-    bool isValid() const { return fPlanarConfig != PlanarConfig::kUnknown; }
-
 private:
     SkISize fDimensions = {0, 0};
 
-    PlanarConfig fPlanarConfig = PlanarConfig::kUnknown;
+    PlanarConfig fPlanarConfig = PlanarConfig::kY_U_V_444;
 
     SkYUVColorSpace fYUVColorSpace = SkYUVColorSpace::kIdentity_SkYUVColorSpace;
 
@@ -200,8 +196,6 @@ class SK_API SkYUVAInfo {
 
 constexpr int SkYUVAInfo::NumPlanes(PlanarConfig planarConfig) {
     switch (planarConfig) {
-        case PlanarConfig::kUnknown:      return 0;
-
         case PlanarConfig::kY_U_V_444:    return 3;
         case PlanarConfig::kY_U_V_422:    return 3;
         case PlanarConfig::kY_U_V_420:    return 3;
@@ -229,9 +223,6 @@ constexpr int SkYUVAInfo::NumPlanes(PlanarConfig planarConfig) {
 
 constexpr int SkYUVAInfo::NumChannelsInPlane(PlanarConfig config, int i) {
     switch (config) {
-        case PlanarConfig::kUnknown:
-            return 0;
-
         case SkYUVAInfo::PlanarConfig::kY_U_V_444:
         case SkYUVAInfo::PlanarConfig::kY_U_V_422:
         case SkYUVAInfo::PlanarConfig::kY_U_V_420:

include/gpu/GrYUVABackendTextures.h

@@ -11,7 +11,7 @@
 int SkYUVAInfo::PlaneDimensions(SkISize imageDimensions,
                                 PlanarConfig planarConfig,
                                 SkEncodedOrigin origin,
-                                SkISize planeDimensions[SkYUVAInfo::kMaxPlanes]) {
+                                SkISize* planeDimensions) {
     int w = imageDimensions.width();
     int h = imageDimensions.height();
     if (origin >= kLeftTop_SkEncodedOrigin) {
@@ -21,12 +21,6 @@ int SkYUVAInfo::PlaneDimensions(SkISize imageDimensions,
     auto down2 = [](int x) { return (x + 1)/2; };
     auto down4 = [](int x) { return (x + 3)/4; };
     switch (planarConfig) {
-        case PlanarConfig::kUnknown:
-            planeDimensions[0] =
-            planeDimensions[1] =
-            planeDimensions[2] =
-            planeDimensions[3] = {0, 0};
-            return 0;
         case PlanarConfig::kY_U_V_444:
             planeDimensions[0] = planeDimensions[1] = planeDimensions[2] = {w, h};
             planeDimensions[3] = {0, 0};
@@ -131,9 +125,6 @@ bool SkYUVAInfo::GetYUVAIndices(PlanarConfig config,
     struct Location {int plane, chanIdx;};
     const Location* locations = nullptr;
     switch (config) {
-        case PlanarConfig::kUnknown:
-            return false;
-
         case PlanarConfig::kY_U_V_444:
         case PlanarConfig::kY_U_V_422:
         case PlanarConfig::kY_U_V_420:
@@ -219,8 +210,6 @@ bool SkYUVAInfo::GetYUVAIndices(PlanarConfig config,
 
 bool SkYUVAInfo::HasAlpha(PlanarConfig planarConfig) {
     switch (planarConfig) {
-        case PlanarConfig::kUnknown:      return false;
-
         case PlanarConfig::kY_U_V_444:    return false;
         case PlanarConfig::kY_U_V_422:    return false;
         case PlanarConfig::kY_U_V_420:    return false;
@@ -258,20 +247,11 @@ SkYUVAInfo::SkYUVAInfo(SkISize dimensions,
     , fYUVColorSpace(yuvColorSpace)
     , fOrigin(origin)
     , fSitingX(sitingX)
-    , fSitingY(sitingY) {
-    if (fDimensions.width() <= 0 ||
-        fDimensions.height() <= 0 ||
-        planarConfig == PlanarConfig::kUnknown) {
-        *this = {};
-        SkASSERT(!this->isValid());
-        return;
-    }
-    SkASSERT(this->isValid());
-}
+    , fSitingY(sitingY) {}
 
 size_t SkYUVAInfo::computeTotalBytes(const size_t rowBytes[kMaxPlanes],
                                      size_t planeSizes[kMaxPlanes]) const {
-    if (!this->isValid()) {
+    if (fDimensions.isEmpty()) {
         return 0;
     }
     SkSafeMath safe;

src/core/SkYUVAInfo.cpp

@@ -80,7 +80,7 @@ SkYUVAPixmapInfo::SkYUVAPixmapInfo(const SkYUVAInfo& yuvaInfo,
                                    const SkColorType colorTypes[kMaxPlanes],
                                    const size_t rowBytes[kMaxPlanes])
         : fYUVAInfo(yuvaInfo) {
-    if (!yuvaInfo.isValid()) {
+    if (yuvaInfo.dimensions().isEmpty()) {
         *this = {};
         SkASSERT(!this->isValid());
         return;

src/core/SkYUVAPixmaps.cpp

@@ -13,7 +13,6 @@
 #include "include/core/SkYUVASizeInfo.h"
 #include "include/gpu/GrDirectContext.h"
 #include "include/gpu/GrRecordingContext.h"
-#include "include/gpu/GrYUVABackendTextures.h"
 #include "src/core/SkAutoPixmapStorage.h"
 #include "src/core/SkMipmap.h"
 #include "src/core/SkScopeExit.h"
@@ -235,45 +234,6 @@ sk_sp<SkImage> SkImage_GpuYUVA::onReinterpretColorSpace(sk_sp<SkColorSpace> newC
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-sk_sp<SkImage> SkImage::MakeFromYUVATextures(GrRecordingContext* context,
-                                             const GrYUVABackendTextures& yuvaTextures,
-                                             sk_sp<SkColorSpace> imageColorSpace,
-                                             TextureReleaseProc textureReleaseProc,
-                                             ReleaseContext releaseContext) {
-    sk_sp<GrRefCntedCallback> releaseHelper;
-    if (textureReleaseProc) {
-        releaseHelper.reset(new GrRefCntedCallback(textureReleaseProc, releaseContext));
-    }
-
-    SkYUVAIndex yuvaIndices[4];
-    yuvaTextures.toYUVAIndices(yuvaIndices);
-    int numTextures;
-    if (!SkYUVAIndex::AreValidIndices(yuvaIndices, &numTextures)) {
-        return nullptr;
-    }
-    SkASSERT(numTextures == yuvaTextures.numPlanes());
-
-    GrSurfaceProxyView tempViews[4];
-    if (!SkImage_GpuBase::MakeTempTextureProxies(context,
-                                                 yuvaTextures.textures().data(),
-                                                 numTextures,
-                                                 yuvaIndices,
-                                                 yuvaTextures.textureOrigin(),
-                                                 tempViews,
-                                                 std::move(releaseHelper))) {
-        return nullptr;
-    }
-
-    return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context),
-                                       yuvaTextures.yuvaInfo().dimensions(),
-                                       kNeedNewImageUniqueID,
-                                       yuvaTextures.yuvaInfo().yuvColorSpace(),
-                                       tempViews,
-                                       numTextures,
-                                       yuvaIndices,
-                                       imageColorSpace);
-}
-
 sk_sp<SkImage> SkImage::MakeFromYUVATextures(GrContext* ctx,
                                              SkYUVColorSpace colorSpace,
                                              const GrBackendTexture yuvaTextures[],

src/gpu/GrYUVABackendTextures.cpp

@@ -10,7 +10,6 @@
 #include "include/core/SkColorPriv.h"
 #include "include/core/SkData.h"
 #include "include/gpu/GrRecordingContext.h"
-#include "include/gpu/GrYUVABackendTextures.h"
 #include "src/codec/SkCodecImageGenerator.h"
 #include "src/core/SkYUVMath.h"
 #include "src/gpu/GrDirectContextPriv.h"
@@ -227,23 +226,30 @@ bool LazyYUVImage::ensureYUVImage(GrRecordingContext* rContext, Type type) {
             if (auto direct = rContext->asDirectContext()) {
                 sk_sp<sk_gpu_test::ManagedBackendTexture> mbets[SkYUVAInfo::kMaxPlanes];
                 GrBackendTexture textures[SkYUVAInfo::kMaxPlanes];
+                uint32_t componentFlags[SkYUVAInfo::kMaxPlanes] = {};
                 for (int i = 0; i < fPixmaps.numPlanes(); ++i) {
                     mbets[i] = sk_gpu_test::ManagedBackendTexture::MakeWithData(
                             direct, fPixmaps.plane(i), GrRenderable::kNo, GrProtected::kNo);
                     if (mbets[i]) {
                         textures[i] = mbets[i]->texture();
+                        componentFlags[i] = textures[i].getBackendFormat().channelMask();
                     } else {
                         return false;
                     }
                 }
-                GrYUVABackendTextures yuvaTextures(fPixmaps.yuvaInfo(),
-                                                   textures,
-                                                   kTopLeft_GrSurfaceOrigin);
+                SkYUVAIndex indices[SkYUVAIndex::kIndexCount];
+                if (!fPixmaps.yuvaInfo().toYUVAIndices(componentFlags, indices)) {
+                    return false;
+                }
                 void* relContext =
                         sk_gpu_test::ManagedBackendTexture::MakeYUVAReleaseContext(mbets);
                 fYUVImage[idx] = SkImage::MakeFromYUVATextures(
                         direct,
-                        yuvaTextures,
+                        fPixmaps.yuvaInfo().yuvColorSpace(),
+                        textures,
+                        indices,
+                        fPixmaps.yuvaInfo().dimensions(),
+                        kTopLeft_GrSurfaceOrigin,
                         fColorSpace,
                         sk_gpu_test::ManagedBackendTexture::ReleaseProc,
                         relContext);