Revert "Move all YUVA image creation in GMs into sk_gpu_test::LazyYUVImage."

This reverts commit db0288d.

Reason for revert: undeclared tuple size

Original change's description:
> Move all YUVA image creation in GMs into sk_gpu_test::LazyYUVImage.
>
> LazyYUVImage now supports making images from a generator and from
> textures. It uses ManagedBackendTexture to manage texture plane
> lifetime via ref-counting.
>
> Adds some supporting utility functions to SkYUVAInfo and
> SkYUVAPixmaps.
>
> Eases transition of forthcoming MakeFromYUVATextures API change.
>
> Bug: skia:10632
>
> Change-Id: I8cfd747c27076d1627da6ea8a169e554a96049e0
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/326720
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>

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

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

Author: bsalomon

gm/asyncrescaleandread.cpp

@@ -11,15 +11,14 @@
 #include "include/core/SkPaint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkSurface.h"
-#include "include/core/SkYUVAInfo.h"
-#include "include/core/SkYUVAPixmaps.h"
+#include "include/core/SkYUVAIndex.h"
 #include "include/gpu/GrDirectContext.h"
 #include "include/gpu/GrRecordingContext.h"
 #include "src/core/SkAutoPixmapStorage.h"
+#include "src/core/SkConvertPixels.h"
 #include "src/core/SkScopeExit.h"
 #include "tools/Resources.h"
 #include "tools/ToolUtils.h"
-#include "tools/gpu/YUVUtils.h"
 
 namespace {
 struct AsyncContext {
@@ -94,17 +93,33 @@ static sk_sp<SkImage> do_read_and_scale_yuv(Src* src,
     if (!asyncContext.fResult) {
         return nullptr;
     }
-    SkYUVAInfo yuvaInfo(size, SkYUVAInfo::PlanarConfig::kY_U_V_420, yuvCS);
-    SkPixmap yuvPMs[] = {
-            {yII,  asyncContext.fResult->data(0), asyncContext.fResult->rowBytes(0)},
-            {uvII, asyncContext.fResult->data(1), asyncContext.fResult->rowBytes(1)},
-            {uvII, asyncContext.fResult->data(2), asyncContext.fResult->rowBytes(2)}
+    GrBackendTexture backendTextures[3];
+
+    SkPixmap yPM(yII, asyncContext.fResult->data(0), asyncContext.fResult->rowBytes(0));
+    SkPixmap uPM(uvII, asyncContext.fResult->data(1), asyncContext.fResult->rowBytes(1));
+    SkPixmap vPM(uvII, asyncContext.fResult->data(2), asyncContext.fResult->rowBytes(2));
+
+    backendTextures[0] = direct->createBackendTexture(yPM, GrRenderable::kNo, GrProtected::kNo);
+    backendTextures[1] = direct->createBackendTexture(uPM, GrRenderable::kNo, GrProtected::kNo);
+    backendTextures[2] = direct->createBackendTexture(vPM, GrRenderable::kNo, GrProtected::kNo);
+
+    SkYUVAIndex indices[4] = {
+        { 0, SkColorChannel::kR},
+        { 1, SkColorChannel::kR},
+        { 2, SkColorChannel::kR},
+        {-1, SkColorChannel::kR}
     };
-    auto pixmaps = SkYUVAPixmaps::FromExternalPixmaps(yuvaInfo, yuvPMs);
-    SkASSERT(pixmaps.isValid());
-    auto lazyYUVImage = sk_gpu_test::LazyYUVImage::Make(pixmaps);
-    SkASSERT(lazyYUVImage);
-    return lazyYUVImage->refImage(direct, sk_gpu_test::LazyYUVImage::Type::kFromTextures);
+
+    *cleanup = {[direct, backendTextures] {
+        direct->flush();
+        direct->submit(true);
+        direct->deleteBackendTexture(backendTextures[0]);
+        direct->deleteBackendTexture(backendTextures[1]);
+        direct->deleteBackendTexture(backendTextures[2]);
+    }};
+
+    return SkImage::MakeFromYUVATextures(direct, yuvCS, backendTextures, indices, size,
+                                         kTopLeft_GrSurfaceOrigin, SkColorSpace::MakeSRGB());
 }
 
 // Draws a grid of rescales. The columns are none, low, and high filter quality. The rows are

gm/compositor_quads.cpp

@@ -897,8 +897,7 @@ class YUVTextureSetRenderer : public ClipTileRenderer {
     int drawTiles(SkCanvas* canvas) override {
         // Refresh the SkImage at the start, so that it's not attempted for every set entry
         if (fYUVData) {
-            fImage = fYUVData->refImage(canvas->recordingContext(),
-                                        sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
+            fImage = fYUVData->refImage(canvas->recordingContext());
             if (!fImage) {
                 return 0;
             }

gm/ducky_yuv_blend.cpp

@@ -33,7 +33,7 @@ DEF_SIMPLE_GM_CAN_FAIL(ducky_yuv_blend, canvas, errorMsg, 560, 1130) {
         auto lazyYUV = sk_gpu_test::LazyYUVImage::Make(GetResourceAsData("images/ducky.jpg"),
                                                        GrMipmapped::kYes);
         if (lazyYUV) {
-            duckyFG[1] = lazyYUV->refImage(rContext, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
+            duckyFG[1] = lazyYUV->refImage(rContext);
         }
         if (!duckyFG[1]) {
             return skiagm::DrawResult::kFail;

gm/imagefromyuvtextures.cpp

@@ -32,6 +32,8 @@
 #include "tools/Resources.h"
 #include "tools/gpu/YUVUtils.h"
 
+using sk_gpu_test::YUVABackendReleaseContext;
+
 class GrRenderTargetContext;
 
 namespace skiagm {
@@ -48,90 +50,128 @@ class ImageFromYUVTextures : public GpuGM {
 
     SkISize onISize() override { return {1420, 610}; }
 
-    static std::unique_ptr<sk_gpu_test::LazyYUVImage> CreatePlanes(const char* name) {
+    static SkBitmap CreateBmpAndPlanes(const char* name, SkBitmap yuvaBmps[4]) {
         SkBitmap bmp;
         if (!GetResourceAsBitmap(name, &bmp)) {
             return {};
         }
-        if (bmp.colorType() != kRGBA_8888_SkColorType) {
-            auto info = bmp.info().makeColorType(kRGBA_8888_SkColorType);
-            SkBitmap copy;
-            copy.allocPixels(info);
-            SkAssertResult(bmp.readPixels(copy.pixmap()));
-            bmp = copy;
-        }
-        SkYUVAPixmapInfo pixmapInfo({bmp.dimensions(),
-                                     SkYUVAInfo::PlanarConfig::kY_U_V_A_4204,
-                                     kJPEG_Full_SkYUVColorSpace},
-                                    SkYUVAPixmapInfo::DataType::kUnorm8,
-                                    nullptr);
-        auto pixmaps = SkYUVAPixmaps::Allocate(pixmapInfo);
+        auto ii = SkImageInfo::Make(bmp.dimensions(), kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+
+        SkBitmap rgbaBmp;
+        rgbaBmp.allocPixels(ii);
+        bmp.readPixels(rgbaBmp.pixmap(), 0, 0);
+
+        SkImageInfo yaInfo = SkImageInfo::Make(rgbaBmp.dimensions(), kAlpha_8_SkColorType,
+                                               kUnpremul_SkAlphaType);
+        yuvaBmps[0].allocPixels(yaInfo);
+        SkISize uvSize = {rgbaBmp.width()/2, rgbaBmp.height()/2};
+        SkImageInfo uvInfo = SkImageInfo::Make(uvSize, kAlpha_8_SkColorType, kUnpremul_SkAlphaType);
+        yuvaBmps[1].allocPixels(uvInfo);
+        yuvaBmps[2].allocPixels(uvInfo);
+        yuvaBmps[3].allocPixels(yaInfo);
 
         unsigned char* yuvPixels[] = {
-                static_cast<unsigned char*>(pixmaps.planes()[0].writable_addr()),
-                static_cast<unsigned char*>(pixmaps.planes()[1].writable_addr()),
-                static_cast<unsigned char*>(pixmaps.planes()[2].writable_addr()),
-                static_cast<unsigned char*>(pixmaps.planes()[3].writable_addr()),
+                static_cast<unsigned char*>(yuvaBmps[0].getPixels()),
+                static_cast<unsigned char*>(yuvaBmps[1].getPixels()),
+                static_cast<unsigned char*>(yuvaBmps[2].getPixels()),
+                static_cast<unsigned char*>(yuvaBmps[3].getPixels()),
         };
 
         float m[20];
-        SkColorMatrix_RGB2YUV(pixmaps.yuvaInfo().yuvColorSpace(), m);
+        SkColorMatrix_RGB2YUV(kJPEG_SkYUVColorSpace, m);
         // Here we encode using the kJPEG_SkYUVColorSpace (i.e., full-swing Rec 601) even though
         // we will draw it with all the supported yuv color spaces when converted back to RGB
-        for (int j = 0; j < pixmaps.planes()[0].height(); ++j) {
-            for (int i = 0; i < pixmaps.planes()[0].width(); ++i) {
-                auto rgba = *bmp.getAddr32(i, j);
+        for (int j = 0; j < yaInfo.height(); ++j) {
+            for (int i = 0; i < yaInfo.width(); ++i) {
+                auto rgba = *rgbaBmp.getAddr32(i, j);
                 auto r = (rgba & 0x000000ff) >>  0;
                 auto g = (rgba & 0x0000ff00) >>  8;
                 auto b = (rgba & 0x00ff0000) >> 16;
                 auto a = (rgba & 0xff000000) >> 24;
-                yuvPixels[0][j*pixmaps.planes()[0].width() + i] = SkToU8(
+                yuvPixels[0][j*yaInfo.width() + i] = SkToU8(
                         sk_float_round2int(m[0]*r + m[1]*g + m[2]*b + m[3]*a + 255*m[4]));
-                yuvPixels[3][j*pixmaps.planes()[0].width() + i] = SkToU8(sk_float_round2int(
+                yuvPixels[3][j*yaInfo.width() + i] = SkToU8(sk_float_round2int(
                         m[15]*r + m[16]*g + m[17]*b + m[18]*a + 255*m[19]));
             }
         }
-        for (int j = 0; j < pixmaps.planes()[1].height(); ++j) {
-            for (int i = 0; i < pixmaps.planes()[1].width(); ++i) {
+        for (int j = 0; j < uvInfo.height(); ++j) {
+            for (int i = 0; i < uvInfo.width(); ++i) {
                 // Average together 4 pixels of RGB.
                 int rgba[] = {0, 0, 0, 0};
-                int denom = 0;
-                int ylimit = std::min(2*j + 2, pixmaps.planes()[0].height());
-                int xlimit = std::min(2*i + 2, pixmaps.planes()[0].width());
-                for (int y = 2*j; y < ylimit; ++y) {
-                    for (int x = 2*i; x < xlimit; ++x) {
-                        auto src = *bmp.getAddr32(x, y);
+                for (int y = 0; y < 2; ++y) {
+                    for (int x = 0; x < 2; ++x) {
+                        auto src = *rgbaBmp.getAddr32(2 * i + x, 2 * j + y);
                         rgba[0] += (src & 0x000000ff) >> 0;
                         rgba[1] += (src & 0x0000ff00) >> 8;
                         rgba[2] += (src & 0x00ff0000) >> 16;
                         rgba[3] += (src & 0xff000000) >> 24;
-                        ++denom;
                     }
                 }
                 for (int c = 0; c < 4; ++c) {
-                    rgba[c] /= denom;
+                    rgba[c] /= 4;
                 }
-                int uvIndex = j*pixmaps.planes()[1].width() + i;
+                int uvIndex = j*uvInfo.width() + i;
                 yuvPixels[1][uvIndex] = SkToU8(sk_float_round2int(
                         m[5]*rgba[0] + m[6]*rgba[1] + m[7]*rgba[2] + m[8]*rgba[3] + 255*m[9]));
                 yuvPixels[2][uvIndex] = SkToU8(sk_float_round2int(
                         m[10]*rgba[0] + m[11]*rgba[1] + m[12]*rgba[2] + m[13]*rgba[3] + 255*m[14]));
             }
         }
-        return sk_gpu_test::LazyYUVImage::Make(std::move(pixmaps));
+        return rgbaBmp;
     }
 
-    sk_sp<SkImage> makeYUVAImage(GrDirectContext* context) {
-        return fLazyYUVImage->refImage(context, sk_gpu_test::LazyYUVImage::Type::kFromTextures);
+    static bool CreateYUVBackendTextures(GrDirectContext* context, SkBitmap bmps[4],
+                                         SkYUVAIndex indices[4],
+                                         YUVABackendReleaseContext* beContext) {
+        for (int i = 0; i < 4; ++i) {
+            GrBackendTexture tmp = context->createBackendTexture(
+                                        bmps[i].pixmap(), GrRenderable::kNo, GrProtected::kNo,
+                                        YUVABackendReleaseContext::CreationCompleteProc(i),
+                                        beContext);
+            if (!tmp.isValid()) {
+                return false;
+            }
+
+            beContext->set(i, tmp);
+        }
+
+        for (int i = 0; i < 4; ++i) {
+            auto chanMask = beContext->beTexture(i).getBackendFormat().channelMask();
+            // We expect the single channel bitmaps to produce single channel textures.
+            SkASSERT(chanMask && SkIsPow2(chanMask));
+            if (chanMask & kGray_SkColorChannelFlag) {
+                indices[i].fChannel = SkColorChannel::kR;
+            } else {
+                indices[i].fChannel = static_cast<SkColorChannel>(31 - SkCLZ(chanMask));
+            }
+            indices[i].fIndex = i;
+        }
+
+        return true;
     }
 
-    sk_sp<SkImage> createReferenceImage(GrDirectContext* dContext) {
-        auto planarImage = this->makeYUVAImage(dContext);
-        if (!planarImage) {
+    sk_sp<SkImage> makeYUVAImage(GrDirectContext* context) {
+        auto releaseContext = new YUVABackendReleaseContext(context);
+        SkYUVAIndex indices[4];
+
+        if (!CreateYUVBackendTextures(context, fYUVABmps, indices, releaseContext)) {
+            YUVABackendReleaseContext::Unwind(context, releaseContext, false);
             return nullptr;
         }
 
-        auto resultInfo = SkImageInfo::Make(fLazyYUVImage->dimensions(),
+        return SkImage::MakeFromYUVATextures(context,
+                                             kJPEG_SkYUVColorSpace,
+                                             releaseContext->beTextures(),
+                                             indices,
+                                             fRGBABmp.dimensions(),
+                                             kTopLeft_GrSurfaceOrigin,
+                                             nullptr,
+                                             YUVABackendReleaseContext::Release,
+                                             releaseContext);
+    }
+
+    sk_sp<SkImage> createReferenceImage(GrDirectContext* dContext) {
+        auto resultInfo = SkImageInfo::Make(fRGBABmp.dimensions(),
                                             kRGBA_8888_SkColorType,
                                             kPremul_SkAlphaType);
         auto resultSurface = SkSurface::MakeRenderTarget(dContext,
@@ -144,7 +184,27 @@ class ImageFromYUVTextures : public GpuGM {
             return nullptr;
         }
 
-        resultSurface->getCanvas()->drawImage(std::move(planarImage), 0, 0);
+        auto planeReleaseContext = new YUVABackendReleaseContext(dContext);
+        SkYUVAIndex indices[4];
+
+        if (!CreateYUVBackendTextures(dContext, fYUVABmps, indices, planeReleaseContext)) {
+            YUVABackendReleaseContext::Unwind(dContext, planeReleaseContext, false);
+            return nullptr;
+        }
+
+        auto tmp = SkImage::MakeFromYUVATextures(dContext,
+                                                 kJPEG_SkYUVColorSpace,
+                                                 planeReleaseContext->beTextures(),
+                                                 indices,
+                                                 fRGBABmp.dimensions(),
+                                                 kTopLeft_GrSurfaceOrigin,
+                                                 nullptr);
+        if (!tmp) {
+            YUVABackendReleaseContext::Unwind(dContext, planeReleaseContext, false);
+            return nullptr;
+        }
+        resultSurface->getCanvas()->drawImage(std::move(tmp), 0, 0);
+        YUVABackendReleaseContext::Unwind(dContext, planeReleaseContext, true);
         return resultSurface->makeImageSnapshot();
     }
 
@@ -153,9 +213,7 @@ class ImageFromYUVTextures : public GpuGM {
             return DrawResult::kSkip;
         }
 
-        if (!fLazyYUVImage) {
-            fLazyYUVImage = CreatePlanes("images/mandrill_32.png");
-        }
+        fRGBABmp = CreateBmpAndPlanes("images/mandrill_32.png", fYUVABmps);
 
         // We make a version of this image for each draw because, if any draw flattens it to
         // RGBA, then all subsequent draws would use the RGBA texture.
@@ -262,7 +320,8 @@ class ImageFromYUVTextures : public GpuGM {
      }
 
 private:
-    std::unique_ptr<sk_gpu_test::LazyYUVImage> fLazyYUVImage;
+    SkBitmap fRGBABmp; // TODO: oddly, it looks like this could just be an SkISize
+    SkBitmap fYUVABmps[4];
 
     // 3 draws x 3 scales x 4 filter qualities
     static constexpr int kNumImages = 3 * 3 * 4;