diff --git a/gm/yuvtorgbsubset.cpp b/gm/yuvtorgbsubset.cpp
index 642dc35..04081c3 100644
--- a/gm/yuvtorgbsubset.cpp
+++ b/gm/yuvtorgbsubset.cpp
@@ -16,14 +16,15 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkString.h"
-#include "include/private/GrTypesPriv.h"
-#include "src/core/SkYUVAInfoLocation.h"
+#include "include/core/SkYUVAInfo.h"
+#include "include/core/SkYUVAPixmaps.h"
 #include "src/gpu/GrBitmapTextureMaker.h"
 #include "src/gpu/GrDirectContextPriv.h"
 #include "src/gpu/GrPaint.h"
 #include "src/gpu/GrSamplerState.h"
 #include "src/gpu/GrSurfaceDrawContext.h"
 #include "src/gpu/GrTextureProxy.h"
+#include "src/gpu/GrYUVATextureProxies.h"
 #include "src/gpu/effects/GrYUVtoRGBEffect.h"
 
 #include <memory>
@@ -31,10 +32,6 @@
 
 class SkCanvas;
 
-#define YSIZE 8
-#define USIZE 4
-#define VSIZE 4
-
 namespace skiagm {
 
 //////////////////////////////////////////////////////////////////////////////
@@ -55,13 +52,16 @@
 
     SkISize onISize() override { return {1310, 540}; }
 
-    void onOnceBeforeDraw() override {
-        SkImageInfo yinfo = SkImageInfo::MakeA8(YSIZE, YSIZE);
-        fBitmaps[0].allocPixels(yinfo);
-        SkImageInfo uinfo = SkImageInfo::MakeA8(USIZE, USIZE);
-        fBitmaps[1].allocPixels(uinfo);
-        SkImageInfo vinfo = SkImageInfo::MakeA8(VSIZE, VSIZE);
-        fBitmaps[2].allocPixels(vinfo);
+    void makePixmaps() {
+        SkYUVAInfo yuvaInfo = SkYUVAInfo({8, 8},
+                                         SkYUVAInfo::PlaneConfig::kY_U_V,
+                                         SkYUVAInfo::Subsampling::k420,
+                                         kJPEG_Full_SkYUVColorSpace);
+        SkColorType colorTypes[] = {kAlpha_8_SkColorType,
+                                    kAlpha_8_SkColorType,
+                                    kAlpha_8_SkColorType};
+        SkYUVAPixmapInfo pmapInfo(yuvaInfo, colorTypes, nullptr);
+        fPixmaps = SkYUVAPixmaps::Allocate(pmapInfo);
 
         unsigned char innerY[16] = {149, 160, 130, 105,
                                     160, 130, 105, 149,
@@ -70,45 +70,62 @@
         unsigned char innerU[4] = {43, 75, 145, 200};
         unsigned char innerV[4] = {88, 180, 200, 43};
         int outerYUV[] = {128, 128, 128};
+        SkBitmap bitmaps[3];
         for (int i = 0; i < 3; ++i) {
-            fBitmaps[i].eraseColor(SkColorSetARGB(outerYUV[i], 0, 0, 0));
+            bitmaps[i].installPixels(fPixmaps.plane(i));
+            bitmaps[i].eraseColor(SkColorSetARGB(outerYUV[i], 0, 0, 0));
         }
         SkPixmap innerYPM(SkImageInfo::MakeA8(4, 4), innerY, 4);
         SkPixmap innerUPM(SkImageInfo::MakeA8(2, 2), innerU, 2);
         SkPixmap innerVPM(SkImageInfo::MakeA8(2, 2), innerV, 2);
-        fBitmaps[0].writePixels(innerYPM, 2, 2);
-        fBitmaps[1].writePixels(innerUPM, 1, 1);
-        fBitmaps[2].writePixels(innerVPM, 1, 1);
-        for (auto& fBitmap : fBitmaps) {
-            fBitmap.setImmutable();
-        }
+        bitmaps[0].writePixels(innerYPM, 2, 2);
+        bitmaps[1].writePixels(innerUPM, 1, 1);
+        bitmaps[2].writePixels(innerVPM, 1, 1);
     }
 
-    DrawResult onDraw(GrRecordingContext* context, GrSurfaceDrawContext* surfaceDrawContext,
-                      SkCanvas* canvas, SkString* errorMsg) override {
-        GrSurfaceProxyView views[3];
-
-        for (int i = 0; i < 3; ++i) {
-            GrBitmapTextureMaker maker(context, fBitmaps[i], GrImageTexGenPolicy::kDraw);
+    DrawResult onGpuSetup(GrDirectContext* context, SkString* errorMsg) override {
+        if (!context) {
+            return DrawResult::kSkip;
+        }
+        if (!fPixmaps.isValid()) {
+            this->makePixmaps();
+        }
+        GrSurfaceProxyView views[SkYUVAInfo::kMaxPlanes];
+        GrColorType colorTypes[SkYUVAInfo::kMaxPlanes];
+        for (int i = 0; i < fPixmaps.numPlanes(); ++i) {
+            SkBitmap bitmap;
+            bitmap.installPixels(fPixmaps.plane(i));
+            bitmap.setImmutable();
+            GrBitmapTextureMaker maker(
+                    context, bitmap, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
             views[i] = maker.view(GrMipmapped::kNo);
             if (!views[i]) {
                 *errorMsg = "Failed to create proxy";
-                return DrawResult::kFail;
+                return context->abandoned() ? DrawResult::kSkip : DrawResult::kFail;
             }
+            colorTypes[i] = SkColorTypeToGrColorType(bitmap.colorType());
         }
+        fProxies = GrYUVATextureProxies(fPixmaps.yuvaInfo(), views, colorTypes);
+        if (!fProxies.isValid()) {
+            *errorMsg = "Failed to create GrYUVATextureProxies";
+            return DrawResult::kFail;
+        }
+        return DrawResult::kOk;
+    }
 
+    void onGpuTeardown() override { fProxies = {}; }
+
+    DrawResult onDraw(GrRecordingContext* context,
+                      GrSurfaceDrawContext* surfaceDrawContext,
+                      SkCanvas* canvas,
+                      SkString* errorMsg) override {
         static const GrSamplerState::Filter kFilters[] = {GrSamplerState::Filter::kNearest,
                                                           GrSamplerState::Filter::kLinear};
         static const SkRect kColorRect = SkRect::MakeLTRB(2.f, 2.f, 6.f, 6.f);
 
-        SkYUVAInfo::YUVALocations yuvaLocations = {{
-            { 0, SkColorChannel::kA},
-            { 1, SkColorChannel::kA},
-            { 2, SkColorChannel::kA},
-            {-1, SkColorChannel::kA}
-        }};
         // Outset to visualize wrap modes.
-        SkRect rect = SkRect::MakeWH(YSIZE, YSIZE).makeOutset(YSIZE/2, YSIZE/2);
+        SkRect rect = SkRect::Make(fProxies.yuvaInfo().dimensions());
+        rect = rect.makeOutset(fProxies.yuvaInfo().width()/2.f, fProxies.yuvaInfo().height()/2.f);
 
         SkScalar y = kTestPad;
         // Rows are filter modes.
@@ -129,9 +146,8 @@
                     samplerState.setWrapModeY(wm);
                 }
                 const auto& caps = *context->priv().caps();
-                std::unique_ptr<GrFragmentProcessor> fp(
-                        GrYUVtoRGBEffect::Make(views, yuvaLocations, kJPEG_SkYUVColorSpace,
-                                               samplerState, caps, SkMatrix::I(), subset));
+                std::unique_ptr<GrFragmentProcessor> fp =
+                        GrYUVtoRGBEffect::Make(fProxies, samplerState, caps, SkMatrix::I(), subset);
                 if (fp) {
                     GrPaint grPaint;
                     grPaint.setColorFragmentProcessor(std::move(fp));
@@ -145,10 +161,11 @@
         }
 
         return DrawResult::kOk;
-     }
+    }
 
 private:
-    SkBitmap fBitmaps[3];
+    SkYUVAPixmaps fPixmaps;
+    GrYUVATextureProxies fProxies;
 
     static constexpr SkScalar kTestPad = 10.f;
 
diff --git a/gn/gpu.gni b/gn/gpu.gni
index 6bff75a..daa2e41 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -277,6 +277,8 @@
   "$_src/gpu/GrXferProcessor.cpp",
   "$_src/gpu/GrXferProcessor.h",
   "$_src/gpu/GrYUVABackendTextures.cpp",
+  "$_src/gpu/GrYUVATextureProxies.cpp",
+  "$_src/gpu/GrYUVATextureProxies.h",
 
   # Ops
   "$_src/gpu/effects/GrBezierEffect.cpp",
diff --git a/include/core/SkYUVAInfo.h b/include/core/SkYUVAInfo.h
index 3683335..a3cf210 100644
--- a/include/core/SkYUVAInfo.h
+++ b/include/core/SkYUVAInfo.h
@@ -93,6 +93,16 @@
 
     static constexpr int kMaxPlanes = 4;
 
+    /** ratio of Y/A values to U/V values in x and y. */
+    static std::tuple<int, int> SubsamplingFactors(Subsampling);
+
+    /**
+     * SubsamplingFactors(Subsampling) if planedIdx refers to a U/V plane and otherwise {1, 1} if
+     * inputs are valid. Invalid inputs consist of incompatible PlaneConfig/Subsampling/planeIdx
+     * combinations. {0, 0} is returned for invalid inputs.
+     */
+    static std::tuple<int, int> PlaneSubsamplingFactors(PlaneConfig, Subsampling, int planeIdx);
+
     /**
      * Given image dimensions, a planer configuration, subsampling, and origin, determine the
      * expected size of each plane. Returns the number of expected planes. planeDimensions[0]
@@ -146,6 +156,10 @@
     PlaneConfig planeConfig() const { return fPlaneConfig; }
     Subsampling subsampling() const { return fSubsampling; }
 
+    std::tuple<int, int> planeSubsamplingFactors(int planeIdx) const {
+        return PlaneSubsamplingFactors(fPlaneConfig, fSubsampling, planeIdx);
+    }
+
     /**
      * Dimensions of the full resolution image (after planes have been oriented to how the image
      * is displayed as indicated by fOrigin).
@@ -160,6 +174,10 @@
 
     SkEncodedOrigin origin() const { return fOrigin; }
 
+    SkMatrix originMatrix() const {
+        return SkEncodedOriginToMatrix(fOrigin, this->width(), this->height());
+    }
+
     bool hasAlpha() const { return HasAlpha(fPlaneConfig); }
 
     /**
@@ -199,6 +217,12 @@
      */
     SkYUVAInfo makeSubsampling(SkYUVAInfo::Subsampling) const;
 
+    /**
+     * Makes a SkYUVAInfo that is identical to this one but with the passed dimensions. If the
+     * passed dimensions is empty then the result will be an invalid SkYUVAInfo.
+     */
+    SkYUVAInfo makeDimensions(SkISize) const;
+
     bool operator==(const SkYUVAInfo& that) const;
     bool operator!=(const SkYUVAInfo& that) const { return !(*this == that); }
 
diff --git a/src/core/SkYUVAInfo.cpp b/src/core/SkYUVAInfo.cpp
index 8e4ce2b..74b3a84 100644
--- a/src/core/SkYUVAInfo.cpp
+++ b/src/core/SkYUVAInfo.cpp
@@ -24,6 +24,54 @@
             config != SkYUVAInfo::PlaneConfig::kUYVA);
 }
 
+std::tuple<int, int> SkYUVAInfo::SubsamplingFactors(Subsampling subsampling) {
+    switch (subsampling) {
+        case Subsampling::kUnknown: return {0, 0};
+        case Subsampling::k444:     return {1, 1};
+        case Subsampling::k422:     return {2, 1};
+        case Subsampling::k420:     return {2, 2};
+        case Subsampling::k440:     return {1, 2};
+        case Subsampling::k411:     return {4, 1};
+        case Subsampling::k410:     return {4, 2};
+    }
+    SkUNREACHABLE;
+}
+
+std::tuple<int, int> SkYUVAInfo::PlaneSubsamplingFactors(PlaneConfig planeConfig,
+                                                         Subsampling subsampling,
+                                                         int planeIdx) {
+    if (!is_plane_config_compatible_with_subsampling(planeConfig, subsampling) ||
+        planeIdx < 0                                                           ||
+        planeIdx > NumPlanes(planeConfig)) {
+        return {0, 0};
+    }
+    bool isSubsampledPlane = false;
+    switch (planeConfig) {
+        case PlaneConfig::kUnknown:     SkUNREACHABLE;
+
+        case PlaneConfig::kY_U_V:
+        case PlaneConfig::kY_V_U:
+        case PlaneConfig::kY_U_V_A:
+        case PlaneConfig::kY_V_U_A:
+            isSubsampledPlane = planeIdx == 1 || planeIdx == 2;
+            break;
+
+        case PlaneConfig::kY_UV:
+        case PlaneConfig::kY_VU:
+        case PlaneConfig::kY_UV_A:
+        case PlaneConfig::kY_VU_A:
+            isSubsampledPlane = planeIdx == 1;
+            break;
+
+        case PlaneConfig::kYUV:
+        case PlaneConfig::kUYV:
+        case PlaneConfig::kYUVA:
+        case PlaneConfig::kUYVA:
+            break;
+    }
+    return isSubsampledPlane ? SubsamplingFactors(subsampling) : std::make_tuple(1, 1);
+}
+
 int SkYUVAInfo::PlaneDimensions(SkISize imageDimensions,
                                 PlaneConfig planeConfig,
                                 Subsampling subsampling,
@@ -310,13 +358,11 @@
 }
 
 SkYUVAInfo SkYUVAInfo::makeSubsampling(SkYUVAInfo::Subsampling subsampling) const {
-    return {fDimensions,
-            fPlaneConfig,
-            subsampling,
-            fYUVColorSpace,
-            fOrigin,
-            fSitingX,
-            fSitingY};
+    return {fDimensions, fPlaneConfig, subsampling, fYUVColorSpace, fOrigin, fSitingX, fSitingY};
+}
+
+SkYUVAInfo SkYUVAInfo::makeDimensions(SkISize dimensions) const {
+    return {dimensions, fPlaneConfig, fSubsampling, fYUVColorSpace, fOrigin, fSitingX, fSitingY};
 }
 
 bool SkYUVAInfo::operator==(const SkYUVAInfo& that) const {
diff --git a/src/gpu/GrImageTextureMaker.cpp b/src/gpu/GrImageTextureMaker.cpp
index d8a4e71..2934e30 100644
--- a/src/gpu/GrImageTextureMaker.cpp
+++ b/src/gpu/GrImageTextureMaker.cpp
@@ -77,12 +77,16 @@
     }
 
     const auto& caps = *fImage->context()->priv().caps();
-    auto fp = GrYUVtoRGBEffect::Make(fImage->fViews, fImage->fYUVALocations, fImage->fYUVColorSpace,
-                                     samplerState, caps, textureMatrix, subset, domain);
+    auto fp = GrYUVtoRGBEffect::Make(fImage->fYUVAProxies,
+                                     samplerState,
+                                     caps,
+                                     textureMatrix,
+                                     subset,
+                                     domain);
     if (fImage->fFromColorSpace) {
-        fp = GrColorSpaceXformEffect::Make(std::move(fp), fImage->fFromColorSpace.get(),
-                                           fImage->alphaType(), fImage->colorSpace(),
-                                           kPremul_SkAlphaType);
+        fp = GrColorSpaceXformEffect::Make(std::move(fp),
+                                           fImage->fFromColorSpace.get(), fImage->alphaType(),
+                                           fImage->colorSpace(), kPremul_SkAlphaType);
     }
     return fp;
 }
@@ -96,12 +100,12 @@
         SkImage::CubicResampler kernel) {
     const auto& caps = *fImage->context()->priv().caps();
     GrSamplerState samplerState(wrapX, wrapY, GrSamplerState::Filter::kNearest);
-    auto fp = GrYUVtoRGBEffect::Make(fImage->fViews, fImage->fYUVALocations, fImage->fYUVColorSpace,
-                                     samplerState, caps, SkMatrix::I(), subset, domain);
+    auto fp = GrYUVtoRGBEffect::Make(fImage->fYUVAProxies, samplerState, caps, SkMatrix::I(),
+                                     subset, domain);
     fp = GrBicubicEffect::Make(std::move(fp),
                                fImage->alphaType(),
                                textureMatrix,
-                               kernel /*GrBicubicEffect::gMitchell*/,
+                               kernel,
                                GrBicubicEffect::Direction::kXY);
     if (fImage->fFromColorSpace) {
         fp = GrColorSpaceXformEffect::Make(std::move(fp),
diff --git a/src/gpu/GrYUVATextureProxies.cpp b/src/gpu/GrYUVATextureProxies.cpp
new file mode 100644
index 0000000..4715a0f
--- /dev/null
+++ b/src/gpu/GrYUVATextureProxies.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrYUVATextureProxies.h"
+
+#ifdef SK_DEBUG
+static int num_channels(uint32_t channelFlags) {
+    switch (channelFlags) {
+        case kRed_SkColorChannelFlag        : return 1;
+        case kAlpha_SkColorChannelFlag      : return 1;
+        case kGray_SkColorChannelFlag       : return 1;
+        case kGrayAlpha_SkColorChannelFlags : return 2;
+        case kRG_SkColorChannelFlags        : return 2;
+        case kRGB_SkColorChannelFlags       : return 3;
+        case kRGBA_SkColorChannelFlags      : return 4;
+
+        default:
+            SkDEBUGFAILF("Unexpected channel combination 0x%08x", channelFlags);
+            return 0;
+    }
+}
+#endif
+
+GrYUVATextureProxies::GrYUVATextureProxies(const SkYUVAInfo& yuvaInfo,
+                                           sk_sp<GrSurfaceProxy> proxies[SkYUVAInfo::kMaxPlanes],
+                                           GrSurfaceOrigin textureOrigin)
+        : fYUVAInfo(yuvaInfo), fTextureOrigin(textureOrigin) {
+    int n = yuvaInfo.numPlanes();
+    if (n == 0) {
+        *this = {};
+        SkASSERT(!this->isValid());
+        return;
+    }
+    uint32_t textureChannelMasks[SkYUVAInfo::kMaxPlanes];
+    for (int i = 0; i < n; ++i) {
+        if (!proxies[i]) {
+            *this = {};
+            SkASSERT(!this->isValid());
+            return;
+        }
+        textureChannelMasks[i] = proxies[i]->backendFormat().channelMask();
+    }
+    fYUVALocations = yuvaInfo.toYUVALocations(textureChannelMasks);
+    if (fYUVALocations[0].fPlane < 0) {
+        *this = {};
+        SkASSERT(!this->isValid());
+        return;
+    }
+    fMipmapped = GrMipmapped::kYes;
+    for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
+        if (!proxies[i]) {
+            *this = {};
+            SkASSERT(!this->isValid());
+            return;
+        }
+        SkASSERT(proxies[i]->asTextureProxy());
+        if (proxies[i]->asTextureProxy()->mipmapped() == GrMipmapped::kNo) {
+            fMipmapped = GrMipmapped::kNo;
+        }
+        fProxies[i] = std::move(proxies[i]);
+    }
+    SkASSERT(this->isValid());
+}
+
+GrYUVATextureProxies::GrYUVATextureProxies(const SkYUVAInfo& yuvaInfo,
+                                           GrSurfaceProxyView views[SkYUVAInfo::kMaxPlanes],
+                                           GrColorType colorTypes[SkYUVAInfo::kMaxPlanes])
+        : fYUVAInfo(yuvaInfo) {
+    uint32_t pixmapChannelMasks[SkYUVAInfo::kMaxPlanes];
+    int n = yuvaInfo.numPlanes();
+    if (n == 0) {
+        *this = {};
+        SkASSERT(!this->isValid());
+        return;
+    }
+    fMipmapped = GrMipmapped::kYes;
+    for (int i = 0; i < n; ++i) {
+        pixmapChannelMasks[i] = GrColorTypeChannelFlags(colorTypes[i]);
+        SkASSERT(num_channels(pixmapChannelMasks[i]) <=
+                 num_channels(views[i].proxy()->backendFormat().channelMask()));
+        if (!views[i] || views[i].origin() != views[0].origin()) {
+            *this = {};
+            SkASSERT(!this->isValid());
+            return;
+        }
+        if (views[i].proxy()->asTextureProxy()->mipmapped() == GrMipmapped::kNo) {
+            fMipmapped = GrMipmapped::kNo;
+        }
+    }
+    // Initial locations refer to the CPU pixmap channels.
+    fYUVALocations = yuvaInfo.toYUVALocations(pixmapChannelMasks);
+    if (fYUVALocations[0].fPlane < 0) {
+        *this = {};
+        SkASSERT(!this->isValid());
+        return;
+    }
+
+    // Run each location through the proxy view's swizzle to get the actual texture format channel.
+    for (int i = 0; i < SkYUVAInfo::kYUVAChannelCount; ++i) {
+        int plane = fYUVALocations[i].fPlane;
+        if (plane >= 0) {
+            int chanAsIdx = static_cast<int>(fYUVALocations[i].fChannel);
+            switch (views[plane].swizzle()[chanAsIdx]) {
+                case 'r': fYUVALocations[i].fChannel = SkColorChannel::kR; break;
+                case 'g': fYUVALocations[i].fChannel = SkColorChannel::kG; break;
+                case 'b': fYUVALocations[i].fChannel = SkColorChannel::kB; break;
+                case 'a': fYUVALocations[i].fChannel = SkColorChannel::kA; break;
+
+                default:
+                    SkDEBUGFAILF("Unexpected swizzle value: %c", views[i].swizzle()[chanAsIdx]);
+                    *this = {};
+                    SkASSERT(!this->isValid());
+                    return;
+            }
+        }
+    }
+    for (int i = 0; i < n; ++i) {
+        fProxies[i] = views[i].detachProxy();
+    }
+    fTextureOrigin = views[0].origin();
+    SkASSERT(this->isValid());
+}
diff --git a/src/gpu/GrYUVATextureProxies.h b/src/gpu/GrYUVATextureProxies.h
new file mode 100644
index 0000000..c6c4a68
--- /dev/null
+++ b/src/gpu/GrYUVATextureProxies.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrYUVATextureProxies_DEFINED
+#define GrYUVATextureProxies_DEFINED
+
+#include "include/core/SkYUVAInfo.h"
+#include "src/core/SkYUVAInfoLocation.h"
+#include "src/gpu/GrSurfaceProxy.h"
+#include "src/gpu/GrSurfaceProxyView.h"
+
+class GrSurfaceProxyView;
+
+class GrYUVATextureProxies {
+public:
+    GrYUVATextureProxies() = default;
+
+    /** Assumes all planes are sampled with a default "rgba" swizzle. */
+    GrYUVATextureProxies(const SkYUVAInfo&,
+                         sk_sp<GrSurfaceProxy>[SkYUVAInfo::kMaxPlanes],
+                         GrSurfaceOrigin textureOrigin);
+
+    /**
+     * When uploading pixmaps to textures it is important that we account for how the original
+     * pixmaps' channels are swizzled into the texture during upload. This will compute a swizzle
+     * for each texture based on the original color types and the views' swizzles. The views must
+     * all have the same origin or the result will be an invalid GrYUVATextureProxies.
+     */
+    GrYUVATextureProxies(const SkYUVAInfo&,
+                         GrSurfaceProxyView[SkYUVAInfo::kMaxPlanes],
+                         GrColorType[SkYUVAInfo::kMaxPlanes]);
+
+    GrYUVATextureProxies(const GrYUVATextureProxies&) = default;
+    GrYUVATextureProxies(GrYUVATextureProxies&&) = default;
+
+    GrYUVATextureProxies& operator=(const GrYUVATextureProxies&) = default;
+    GrYUVATextureProxies& operator=(GrYUVATextureProxies&&) = default;
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
+
+    // Overall set of YUVA proxies is mip mapped if each plane is mip mapped.
+    GrMipmapped mipmapped() const { return fMipmapped; }
+
+    GrSurfaceProxy* proxy(int i) const { return fProxies[i].get(); }
+
+    const std::array<sk_sp<GrSurfaceProxy>, SkYUVAInfo::kMaxPlanes>& proxies() const {
+        return fProxies;
+    }
+
+    sk_sp<GrSurfaceProxy> refProxy(int i) const { return fProxies[i]; }
+
+    GrSurfaceProxyView makeView(int i) const {
+        return {fProxies[i], fTextureOrigin, GrSwizzle::RGBA()};
+    }
+
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    const SkYUVAInfo::YUVALocations& yuvaLocations() const { return fYUVALocations; }
+
+private:
+    std::array<sk_sp<GrSurfaceProxy>, SkYUVAInfo::kMaxPlanes> fProxies;
+    SkYUVAInfo fYUVAInfo;
+    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
+    GrMipmapped fMipmapped = GrMipmapped::kNo;
+    SkYUVAInfo::YUVALocations fYUVALocations = {};
+};
+
+#endif
diff --git a/src/gpu/effects/GrYUVtoRGBEffect.cpp b/src/gpu/effects/GrYUVtoRGBEffect.cpp
index a8f516e..45361d4 100644
--- a/src/gpu/effects/GrYUVtoRGBEffect.cpp
+++ b/src/gpu/effects/GrYUVtoRGBEffect.cpp
@@ -7,8 +7,10 @@
 
 #include "src/gpu/effects/GrYUVtoRGBEffect.h"
 
+#include "include/core/SkYUVAInfo.h"
 #include "src/core/SkYUVMath.h"
 #include "src/gpu/GrTexture.h"
+#include "src/gpu/GrYUVATextureProxies.h"
 #include "src/gpu/effects/GrMatrixEffect.h"
 #include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
@@ -16,88 +18,82 @@
 #include "src/sksl/SkSLCPP.h"
 #include "src/sksl/SkSLUtil.h"
 
-static void border_colors(SkYUVColorSpace cs,
-                          const SkYUVAInfo::YUVALocations& locations,
-                          float planeBorders[4][4]) {
+static void border_colors(const GrYUVATextureProxies& yuvaProxies, float planeBorders[4][4]) {
     float m[20];
-    SkColorMatrix_RGB2YUV(cs, m);
-    int i = 0;
-    for (auto [plane, channel] : locations) {
+    SkColorMatrix_RGB2YUV(yuvaProxies.yuvaInfo().yuvColorSpace(), m);
+    for (int i = 0; i < SkYUVAInfo::kYUVAChannelCount; ++i) {
+        auto [plane, channel] = yuvaProxies.yuvaLocations()[i];
         if (plane == -1) {
-            continue;
+            return;
         }
         auto c = static_cast<int>(channel);
         planeBorders[plane][c] = m[i*5 + 4];
-        ++i;
     }
 }
 
-std::unique_ptr<GrFragmentProcessor> GrYUVtoRGBEffect::Make(
-        GrSurfaceProxyView views[],
-        const SkYUVAInfo::YUVALocations& locations,
-        SkYUVColorSpace yuvColorSpace,
-        GrSamplerState samplerState,
-        const GrCaps& caps,
-        const SkMatrix& localMatrix,
-        const SkRect* subset,
-        const SkRect* domain) {
-    int numPlanes;
-    SkAssertResult(SkYUVAInfo::YUVALocation::AreValidLocations(locations, &numPlanes));
-
-    const SkISize yDimensions =
-            views[locations[SkYUVAInfo::YUVAChannels::kY].fPlane].proxy()->dimensions();
+std::unique_ptr<GrFragmentProcessor> GrYUVtoRGBEffect::Make(const GrYUVATextureProxies& yuvaProxies,
+                                                            GrSamplerState samplerState,
+                                                            const GrCaps& caps,
+                                                            const SkMatrix& localMatrix,
+                                                            const SkRect* subset,
+                                                            const SkRect* domain) {
+    int numPlanes = yuvaProxies.yuvaInfo().numPlanes();
+    if (!yuvaProxies.isValid()) {
+        return nullptr;
+    }
 
     bool usesBorder = samplerState.wrapModeX() == GrSamplerState::WrapMode::kClampToBorder ||
                       samplerState.wrapModeY() == GrSamplerState::WrapMode::kClampToBorder;
     float planeBorders[4][4] = {};
     if (usesBorder) {
-        border_colors(yuvColorSpace, locations, planeBorders);
+        border_colors(yuvaProxies, planeBorders);
     }
 
     bool snap[2] = {false, false};
-    std::unique_ptr<GrFragmentProcessor> planeFPs[4];
+    std::unique_ptr<GrFragmentProcessor> planeFPs[SkYUVAInfo::kMaxPlanes];
     for (int i = 0; i < numPlanes; ++i) {
-        SkISize dimensions = views[i].proxy()->dimensions();
-        SkTCopyOnFirstWrite<SkMatrix> planeMatrix(&SkMatrix::I());
+        GrSurfaceProxyView view = yuvaProxies.makeView(i);
+        SkMatrix planeMatrix = yuvaProxies.yuvaInfo().originMatrix();
+        // The returned matrix is a view matrix but we need a local matrix.
+        SkAssertResult(planeMatrix.invert(&planeMatrix));
         SkRect planeSubset;
         SkRect planeDomain;
         bool makeLinearWithSnap = false;
-        float sx = 1.f,
-              sy = 1.f;
-        if (dimensions != yDimensions) {
+        auto [ssx, ssy] = yuvaProxies.yuvaInfo().planeSubsamplingFactors(i);
+        SkASSERT(ssx > 0 && ssx <= 4);
+        SkASSERT(ssy > 0 && ssy <= 2);
+        float scaleX = 1.f;
+        float scaleY = 1.f;
+        if (ssx > 1 || ssy > 1) {
             // JPEG chroma subsampling of odd dimensions produces U and V planes with the ceiling of
             // the image size divided by the subsampling factor (2). Our API for creating YUVA
             // doesn't capture the intended subsampling (and we should fix that). This fixes up 2x
             // subsampling for images with odd widths/heights (e.g. JPEG 420 or 422).
-            sx = (float)dimensions.width()  / yDimensions.width();
-            sy = (float)dimensions.height() / yDimensions.height();
-            if ((yDimensions.width() & 0b1) && dimensions.width() == yDimensions.width() / 2 + 1) {
-                sx = 0.5f;
-            }
-            if ((yDimensions.height() & 0b1) &&
-                dimensions.height() == yDimensions.height() / 2 + 1) {
-                sy = 0.5f;
-            }
-            *planeMatrix.writable() = SkMatrix::Scale(sx, sy);
+            scaleX = 1.f/ssx;
+            scaleY = 1.f/ssy;
+            // We would want to add a translation to this matrix to handle other sitings.
+            SkASSERT(yuvaProxies.yuvaInfo().sitingX() == SkYUVAInfo::Siting::kCentered);
+            SkASSERT(yuvaProxies.yuvaInfo().sitingY() == SkYUVAInfo::Siting::kCentered);
+            planeMatrix.postConcat(SkMatrix::Scale(scaleX, scaleY));
             if (subset) {
-                planeSubset = {subset->fLeft   * sx,
-                               subset->fTop    * sy,
-                               subset->fRight  * sx,
-                               subset->fBottom * sy};
+                planeSubset = {subset->fLeft  *scaleX,
+                               subset->fTop   *scaleY,
+                               subset->fRight *scaleX,
+                               subset->fBottom*scaleY};
             }
             if (domain) {
-                planeDomain = {domain->fLeft   * sx,
-                               domain->fTop    * sy,
-                               domain->fRight  * sx,
-                               domain->fBottom * sy};
+                planeDomain = {domain->fLeft  *scaleX,
+                               domain->fTop   *scaleY,
+                               domain->fRight *scaleX,
+                               domain->fBottom*scaleY};
             }
             // This promotion of nearest to linear filtering for UV planes exists to mimic
             // libjpeg[-turbo]'s do_fancy_upsampling option. We will filter the subsampled plane,
             // however we want to filter at a fixed point for each logical image pixel to simulate
             // nearest neighbor.
             if (samplerState.filter() == GrSamplerState::Filter::kNearest) {
-                bool snapX = (sx != 1.f),
-                     snapY = (sy != 1.f);
+                bool snapX = (ssx != 1),
+                     snapY = (ssy != 1);
                 makeLinearWithSnap = snapX || snapY;
                 snap[0] |= snapX;
                 snap[1] |= snapY;
@@ -131,30 +127,53 @@
                 // planeSubset but allows linear filtering to read pixels from the plane that are
                 // just outside planeSubset.
                 SkRect* domainRect = domain ? &planeDomain : nullptr;
-                planeFPs[i] = GrTextureEffect::MakeCustomLinearFilterInset(
-                        views[i], kUnknown_SkAlphaType, *planeMatrix, samplerState.wrapModeX(),
-                        samplerState.wrapModeY(), planeSubset, domainRect, {sx / 2.f, sy / 2.f},
-                        caps, planeBorders[i]);
+                planeFPs[i] = GrTextureEffect::MakeCustomLinearFilterInset(std::move(view),
+                                                                           kUnknown_SkAlphaType,
+                                                                           planeMatrix,
+                                                                           samplerState.wrapModeX(),
+                                                                           samplerState.wrapModeY(),
+                                                                           planeSubset,
+                                                                           domainRect,
+                                                                           {scaleX/2.f, scaleY/2.f},
+                                                                           caps,
+                                                                           planeBorders[i]);
             } else if (domain) {
-                planeFPs[i] = GrTextureEffect::MakeSubset(views[i], kUnknown_SkAlphaType,
-                                                          *planeMatrix, samplerState, planeSubset,
-                                                          planeDomain, caps, planeBorders[i]);
+                planeFPs[i] = GrTextureEffect::MakeSubset(std::move(view),
+                                                          kUnknown_SkAlphaType,
+                                                          planeMatrix,
+                                                          samplerState,
+                                                          planeSubset,
+                                                          planeDomain,
+                                                          caps,
+                                                          planeBorders[i]);
             } else {
-                planeFPs[i] = GrTextureEffect::MakeSubset(views[i], kUnknown_SkAlphaType,
-                                                          *planeMatrix, samplerState, planeSubset,
-                                                          caps, planeBorders[i]);
+                planeFPs[i] = GrTextureEffect::MakeSubset(std::move(view),
+                                                          kUnknown_SkAlphaType,
+                                                          planeMatrix,
+                                                          samplerState,
+                                                          planeSubset,
+                                                          caps,
+                                                          planeBorders[i]);
             }
         } else {
             GrSamplerState planeSampler = samplerState;
             if (makeLinearWithSnap) {
                 planeSampler.setFilterMode(GrSamplerState::Filter::kLinear);
             }
-            planeFPs[i] = GrTextureEffect::Make(views[i], kUnknown_SkAlphaType, *planeMatrix,
-                                                planeSampler, caps, planeBorders[i]);
+            planeFPs[i] = GrTextureEffect::Make(std::move(view),
+                                                kUnknown_SkAlphaType,
+                                                planeMatrix,
+                                                planeSampler,
+                                                caps,
+                                                planeBorders[i]);
         }
     }
-    auto fp = std::unique_ptr<GrFragmentProcessor>(
-            new GrYUVtoRGBEffect(planeFPs, numPlanes, locations, snap, yuvColorSpace));
+    std::unique_ptr<GrFragmentProcessor> fp(
+            new GrYUVtoRGBEffect(planeFPs,
+                                 numPlanes,
+                                 yuvaProxies.yuvaLocations(),
+                                 snap,
+                                 yuvaProxies.yuvaInfo().yuvColorSpace()));
     return GrMatrixEffect::Make(localMatrix, std::move(fp));
 }
 
diff --git a/src/gpu/effects/GrYUVtoRGBEffect.h b/src/gpu/effects/GrYUVtoRGBEffect.h
index 3f1d090..92a8bf3 100644
--- a/src/gpu/effects/GrYUVtoRGBEffect.h
+++ b/src/gpu/effects/GrYUVtoRGBEffect.h
@@ -12,11 +12,11 @@
 #include "src/core/SkYUVAInfoLocation.h"
 #include "src/gpu/GrFragmentProcessor.h"
 
+class GrYUVATextureProxies;
+
 class GrYUVtoRGBEffect : public GrFragmentProcessor {
 public:
-    static std::unique_ptr<GrFragmentProcessor> Make(GrSurfaceProxyView views[],
-                                                     const SkYUVAInfo::YUVALocations&,
-                                                     SkYUVColorSpace yuvColorSpace,
+    static std::unique_ptr<GrFragmentProcessor> Make(const GrYUVATextureProxies& yuvaProxies,
                                                      GrSamplerState samplerState,
                                                      const GrCaps&,
                                                      const SkMatrix& localMatrix = SkMatrix::I(),
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index ffe40bc..483949e 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -39,6 +39,7 @@
 #include "src/gpu/GrTextureAdjuster.h"
 #include "src/gpu/GrTextureProxy.h"
 #include "src/gpu/GrTextureProxyPriv.h"
+#include "src/gpu/GrYUVATextureProxies.h"
 #include "src/gpu/SkGr.h"
 #include "src/gpu/gl/GrGLTexture.h"
 
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index a528f84..90172a2 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -12,6 +12,7 @@
 #include "include/gpu/GrBackendSurface.h"
 #include "include/gpu/GrDirectContext.h"
 #include "include/gpu/GrRecordingContext.h"
+#include "include/gpu/GrYUVABackendTextures.h"
 #include "src/core/SkBitmapCache.h"
 #include "src/core/SkTLList.h"
 #include "src/gpu/GrDirectContextPriv.h"
@@ -22,6 +23,7 @@
 #include "src/gpu/GrSurfaceDrawContext.h"
 #include "src/gpu/GrTexture.h"
 #include "src/gpu/GrTextureAdjuster.h"
+#include "src/gpu/GrYUVATextureProxies.h"
 #include "src/gpu/effects/GrYUVtoRGBEffect.h"
 #include "src/image/SkImage_Gpu.h"
 #include "src/image/SkReadPixelsRec.h"
diff --git a/src/image/SkImage_GpuBase.h b/src/image/SkImage_GpuBase.h
index ed68a7c..ad6c8b6 100644
--- a/src/image/SkImage_GpuBase.h
+++ b/src/image/SkImage_GpuBase.h
@@ -60,11 +60,6 @@
     static bool ValidateCompressedBackendTexture(const GrCaps*, const GrBackendTexture& tex,
                                                  SkAlphaType);
 
-    static SkAlphaType GetAlphaTypeFromYUVALocations(const SkYUVAInfo::YUVALocations locations) {
-        return locations[SkYUVAInfo::YUVAChannels::kA].fPlane >= 0 ? kPremul_SkAlphaType
-                                                                   : kOpaque_SkAlphaType;
-    }
-
     using PromiseImageTextureContext = SkDeferredDisplayListRecorder::PromiseImageTextureContext;
     using PromiseImageTextureFulfillProc =
             SkDeferredDisplayListRecorder::PromiseImageTextureFulfillProc;
diff --git a/src/image/SkImage_GpuYUVA.cpp b/src/image/SkImage_GpuYUVA.cpp
index e38fd34..9a91ba3 100644
--- a/src/image/SkImage_GpuYUVA.cpp
+++ b/src/image/SkImage_GpuYUVA.cpp
@@ -34,33 +34,21 @@
 static constexpr auto kAssumedColorType = kRGBA_8888_SkColorType;
 
 SkImage_GpuYUVA::SkImage_GpuYUVA(sk_sp<GrImageContext> context,
-                                 SkISize size,
                                  uint32_t uniqueID,
-                                 SkYUVColorSpace colorSpace,
-                                 GrSurfaceProxyView views[],
-                                 int numViews,
-                                 const SkYUVAInfo::YUVALocations& yuvaLocations,
+                                 GrYUVATextureProxies proxies,
                                  sk_sp<SkColorSpace> imageColorSpace)
         : INHERITED(std::move(context),
-                    size,
+                    proxies.yuvaInfo().dimensions(),
                     uniqueID,
                     kAssumedColorType,
-                    // If an alpha channel is present we always switch to kPremul. This is because,
+                    // If an alpha channel is present we always use kPremul. This is because,
                     // although the planar data is always un-premul, the final interleaved RGB image
                     // is/would-be premul.
-                    GetAlphaTypeFromYUVALocations(yuvaLocations),
+                    proxies.yuvaInfo().hasAlpha() ? kPremul_SkAlphaType : kOpaque_SkAlphaType,
                     std::move(imageColorSpace))
-        , fNumViews(numViews)
-        , fYUVALocations(yuvaLocations)
-        , fYUVColorSpace(colorSpace) {
-    // The caller should have done this work, just verifying
-    SkDEBUGCODE(int textureCount;)
-    SkASSERT(SkYUVAInfo::YUVALocation::AreValidLocations(fYUVALocations, &textureCount));
-    SkASSERT(textureCount == fNumViews);
-
-    for (int i = 0; i < numViews; ++i) {
-        fViews[i] = std::move(views[i]);
-    }
+        , fYUVAProxies(std::move(proxies)) {
+    // The caller should have checked this, just verifying.
+    SkASSERT(fYUVAProxies.isValid());
 }
 
 // For onMakeColorSpace()
@@ -71,55 +59,46 @@
                     image->dimensions(),
                     kNeedNewImageUniqueID,
                     kAssumedColorType,
-                    // 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.
-                    GetAlphaTypeFromYUVALocations(image->fYUVALocations),
+                    image->alphaType(),
                     std::move(targetCS))
-        , fNumViews(image->fNumViews)
-        , fYUVALocations(image->fYUVALocations)
-        , fYUVColorSpace(image->fYUVColorSpace)
+        , fYUVAProxies(image->fYUVAProxies)
+        , fRGBView(image->fRGBView)
         // Since null fFromColorSpace means no GrColorSpaceXform, we turn a null
         // image->refColorSpace() into an explicit SRGB.
         , fFromColorSpace(image->colorSpace() ? image->refColorSpace() : SkColorSpace::MakeSRGB()) {
-    // The caller should have done this work, just verifying
-    SkDEBUGCODE(int textureCount;)
-    SkASSERT(SkYUVAInfo::YUVALocation::AreValidLocations(image->fYUVALocations, &textureCount));
-    SkASSERT(textureCount == fNumViews);
-
-    if (image->fRGBView.proxy()) {
-        fRGBView = image->fRGBView;  // we ref in this case, not move
-    } else {
-        for (int i = 0; i < fNumViews; ++i) {
-            fViews[i] = image->fViews[i];  // we ref in this case, not move
-        }
-    }
+    // We should either have a RGB proxy *or* a set of YUVA proxies.
+    SkASSERT(fYUVAProxies.isValid() != SkToBool(image->fRGBView));
 }
 
 bool SkImage_GpuYUVA::setupMipmapsForPlanes(GrRecordingContext* context) const {
     // We shouldn't get here if the planes were already flattened to RGBA.
-    SkASSERT(fViews[0].proxy() && !fRGBView.proxy());
+    SkASSERT(fYUVAProxies.isValid() && !fRGBView);
     if (!context || !fContext->priv().matches(context)) {
         return false;
     }
-    GrSurfaceProxyView newViews[4];
     if (!context->priv().caps()->mipmapSupport()) {
         // We succeed in this case by doing nothing.
         return true;
     }
-    for (int i = 0; i < fNumViews; ++i) {
-        auto* t = fViews[i].asTextureProxy();
+    int n = fYUVAProxies.yuvaInfo().numPlanes();
+    sk_sp<GrSurfaceProxy> newProxies[4];
+    for (int i = 0; i < n; ++i) {
+        auto* t = fYUVAProxies.proxy(i)->asTextureProxy();
         if (t->mipmapped() == GrMipmapped::kNo && (t->width() > 1 || t->height() > 1)) {
-            if (!(newViews[i] = GrCopyBaseMipMapToView(context, fViews[i]))) {
+            auto newView = GrCopyBaseMipMapToView(context, fYUVAProxies.makeView(i));
+            if (!newView) {
                 return false;
             }
+            SkASSERT(newView.swizzle() == fYUVAProxies.makeView(i).swizzle());
+            newProxies[i] = newView.detachProxy();
         } else {
-            newViews[i] = fViews[i];
+            newProxies[i] = fYUVAProxies.refProxy(i);
         }
     }
-    for (int i = 0; i < fNumViews; ++i) {
-        fViews[i] = std::move(newViews[i]);
-    }
+    fYUVAProxies = GrYUVATextureProxies(fYUVAProxies.yuvaInfo(),
+                                        newProxies,
+                                        fYUVAProxies.textureOrigin());
+    SkASSERT(fYUVAProxies.isValid());
     return true;
 }
 
@@ -136,15 +115,19 @@
         return GrSemaphoresSubmitted::kNo;
     }
 
-    GrSurfaceProxy* proxies[4] = {fViews[0].proxy(), fViews[1].proxy(), fViews[2].proxy(),
-                                  fViews[3].proxy()};
-    size_t numProxies = fNumViews;
-    if (fRGBView.proxy()) {
+    GrSurfaceProxy* proxies[SkYUVAInfo::kMaxPlanes] = {};
+    size_t numProxies;
+    if (fRGBView) {
         // Either we've already flushed the flattening draw or the flattening is unflushed. In the
         // latter case it should still be ok to just pass fRGBView proxy because it in turn depends
         // on the planar proxies and will cause all of their work to flush as well.
         proxies[0] = fRGBView.proxy();
         numProxies = 1;
+    } else {
+        numProxies = fYUVAProxies.numPlanes();
+        for (size_t i = 0; i < numProxies; ++i) {
+            proxies[i] = fYUVAProxies.proxy(i);
+        }
     }
     return dContext->priv().flushSurfaces({proxies, numProxies},
                                           SkSurface::BackendSurfaceAccess::kNoAccess,
@@ -153,49 +136,6 @@
 
 GrTextureProxy* SkImage_GpuYUVA::peekProxy() const { return fRGBView.asTextureProxy(); }
 
-bool SkImage_GpuYUVA::MakeTempTextureProxies(GrRecordingContext* rContext,
-                                             const GrBackendTexture yuvaTextures[],
-                                             int numTextures,
-                                             const SkYUVAInfo::YUVALocations& yuvaLocations,
-                                             GrSurfaceOrigin imageOrigin,
-                                             GrSurfaceProxyView tempViews[4],
-                                             sk_sp<GrRefCntedCallback> releaseHelper) {
-    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
-    for (int textureIndex = 0; textureIndex < numTextures; ++textureIndex) {
-        const GrBackendFormat& backendFormat = yuvaTextures[textureIndex].getBackendFormat();
-        if (!backendFormat.isValid()) {
-            return false;
-        }
-
-        SkASSERT(yuvaTextures[textureIndex].isValid());
-
-        auto proxy = proxyProvider->wrapBackendTexture(yuvaTextures[textureIndex],
-                                                       kBorrow_GrWrapOwnership,
-                                                       GrWrapCacheable::kNo,
-                                                       kRead_GrIOType,
-                                                       releaseHelper);
-        if (!proxy) {
-            return false;
-        }
-        tempViews[textureIndex] =
-                GrSurfaceProxyView(std::move(proxy), imageOrigin, GrSwizzle("rgba"));
-#ifdef SK_DEBUG
-        // Check that each texture contains the channel data for the corresponding YUVA location
-        auto formatChannelMask = backendFormat.channelMask();
-        if (formatChannelMask & kGray_SkColorChannelFlag) {
-            formatChannelMask |= kRGB_SkColorChannelFlags;
-        }
-        for (int i = 0; i < SkYUVAInfo::kYUVAChannelCount; ++i) {
-            if (yuvaLocations[i].fPlane == textureIndex) {
-                uint32_t channelAsMask = 1 << static_cast<int>(yuvaLocations[i].fChannel);
-                SkASSERT(channelAsMask & formatChannelMask);
-            }
-        }
-#endif
-    }
-    return true;
-}
-
 void SkImage_GpuYUVA::flattenToRGB(GrRecordingContext* context) const {
     if (fRGBView.proxy()) {
         return;
@@ -222,23 +162,18 @@
 
     const GrCaps& caps = *context->priv().caps();
 
-    auto fp = GrYUVtoRGBEffect::Make(
-            fViews, fYUVALocations, fYUVColorSpace, GrSamplerState::Filter::kNearest, caps);
+    auto fp = GrYUVtoRGBEffect::Make(fYUVAProxies, GrSamplerState::Filter::kNearest, caps);
     if (fFromColorSpace) {
-        auto colorSpaceXform = GrColorSpaceXform::Make(fFromColorSpace.get(),
-                                                       this->alphaType(),
-                                                       this->colorSpace(),
-                                                       this->alphaType());
-        fp = GrColorSpaceXformEffect::Make(std::move(fp), std::move(colorSpaceXform));
+        fp = GrColorSpaceXformEffect::Make(std::move(fp),
+                                           fFromColorSpace.get(), this->alphaType(),
+                                           this->colorSpace(),    this->alphaType());
     }
 
     surfaceFillContext->fillWithFP(std::move(fp));
 
     fRGBView = surfaceFillContext->readSurfaceView();
     SkASSERT(fRGBView.swizzle() == GrSwizzle());
-    for (auto& v : fViews) {
-        v.reset();
-    }
+    fYUVAProxies = {};
 }
 
 GrSurfaceProxyView SkImage_GpuYUVA::refMippedView(GrRecordingContext* context) const {
@@ -286,9 +221,7 @@
 }
 
 sk_sp<SkImage> SkImage_GpuYUVA::onReinterpretColorSpace(sk_sp<SkColorSpace> newCS) const {
-    return sk_make_sp<SkImage_GpuYUVA>(fContext, this->dimensions(), kNeedNewImageUniqueID,
-                                       fYUVColorSpace, fViews, fNumViews, fYUVALocations,
-                                       std::move(newCS));
+    return sk_sp<SkImage>(new SkImage_GpuYUVA(fContext, this, std::move(newCS)));
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -300,32 +233,36 @@
                                              ReleaseContext releaseContext) {
     auto releaseHelper = GrRefCntedCallback::Make(textureReleaseProc, releaseContext);
 
-    SkYUVAInfo::YUVALocations yuvaLocations = yuvaTextures.toYUVALocations();
+    GrProxyProvider* proxyProvider = context->priv().proxyProvider();
+    int numPlanes = yuvaTextures.yuvaInfo().numPlanes();
+    sk_sp<GrSurfaceProxy> proxies[SkYUVAInfo::kMaxPlanes];
+    for (int plane = 0; plane < numPlanes; ++plane) {
+        proxies[plane] = proxyProvider->wrapBackendTexture(yuvaTextures.texture(plane),
+                                                           kBorrow_GrWrapOwnership,
+                                                           GrWrapCacheable::kNo,
+                                                           kRead_GrIOType,
+                                                           releaseHelper);
+        if (!proxies[plane]) {
+            return {};
+        }
+    }
+    GrYUVATextureProxies yuvaProxies(yuvaTextures.yuvaInfo(),
+                                     proxies,
+                                     yuvaTextures.textureOrigin());
 
-    GrSurfaceProxyView tempViews[4];
-    if (!SkImage_GpuYUVA::MakeTempTextureProxies(context,
-                                                 yuvaTextures.textures().data(),
-                                                 yuvaTextures.numPlanes(),
-                                                 yuvaLocations,
-                                                 yuvaTextures.textureOrigin(),
-                                                 tempViews,
-                                                 std::move(releaseHelper))) {
+    if (!yuvaProxies.isValid()) {
         return nullptr;
     }
 
     return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context),
-                                       yuvaTextures.yuvaInfo().dimensions(),
                                        kNeedNewImageUniqueID,
-                                       yuvaTextures.yuvaInfo().yuvColorSpace(),
-                                       tempViews,
-                                       yuvaTextures.numPlanes(),
-                                       yuvaLocations,
+                                       yuvaProxies,
                                        imageColorSpace);
 }
 
 sk_sp<SkImage> SkImage::MakeFromYUVAPixmaps(GrRecordingContext* context,
                                             const SkYUVAPixmaps& pixmaps,
-                                            GrMipMapped buildMips,
+                                            GrMipmapped buildMips,
                                             bool limitToMaxTextureSize,
                                             sk_sp<SkColorSpace> imageColorSpace) {
     if (!context) {
@@ -336,8 +273,6 @@
         return nullptr;
     }
 
-    SkYUVAInfo::YUVALocations yuvaLocations = pixmaps.toYUVALocations();
-
     // SkImage_GpuYUVA doesn't yet support different encoded origins.
     if (pixmaps.yuvaInfo().origin() != kTopLeft_SkEncodedOrigin) {
         return nullptr;
@@ -347,45 +282,58 @@
         buildMips = GrMipMapped::kNo;
     }
 
-    // Make proxies
-    GrSurfaceProxyView tempViews[4];
+    // Resize the pixmaps if necessary.
     int numPlanes = pixmaps.numPlanes();
     int maxTextureSize = context->priv().caps()->maxTextureSize();
-    for (int i = 0; i < numPlanes; ++i) {
-        const SkPixmap* pixmap = &pixmaps.plane(i);
-        SkAutoPixmapStorage resized;
-        int maxDim = std::max(pixmap->width(), pixmap->height());
-        if (maxDim > maxTextureSize) {
-            if (!limitToMaxTextureSize) {
-                return nullptr;
-            }
-            float scale = static_cast<float>(maxTextureSize)/maxDim;
-            int newWidth  = std::min(static_cast<int>(pixmap->width() *scale), maxTextureSize);
-            int newHeight = std::min(static_cast<int>(pixmap->height()*scale), maxTextureSize);
-            SkImageInfo info = pixmap->info().makeWH(newWidth, newHeight);
-            SkSamplingOptions sampling(SkFilterMode::kLinear, SkMipmapMode::kNone);
-            if (!resized.tryAlloc(info) || !pixmap->scalePixels(resized, sampling)) {
-                return nullptr;
-            }
-            pixmap = &resized;
-        }
-        // Turn the pixmap into a GrTextureProxy
-        SkBitmap bmp;
-        bmp.installPixels(*pixmap);
-        GrBitmapTextureMaker bitmapMaker(context, bmp, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-        tempViews[i] = bitmapMaker.view(buildMips);
-        if (!tempViews[i]) {
+    int maxDim = std::max(pixmaps.yuvaInfo().width(), pixmaps.yuvaInfo().height());
+
+    SkYUVAPixmaps tempPixmaps;
+    const SkYUVAPixmaps* pixmapsToUpload = &pixmaps;
+    // We assume no plane is larger than the image size (and at least one plane is as big).
+    if (maxDim > maxTextureSize) {
+        if (!limitToMaxTextureSize) {
             return nullptr;
         }
+        float scale = static_cast<float>(maxTextureSize)/maxDim;
+        SkISize newDimensions = {
+            std::min(static_cast<int>(pixmaps.yuvaInfo().width() *scale), maxTextureSize),
+            std::min(static_cast<int>(pixmaps.yuvaInfo().height()*scale), maxTextureSize)
+        };
+        SkYUVAInfo newInfo = pixmaps.yuvaInfo().makeDimensions(newDimensions);
+        SkYUVAPixmapInfo newPixmapInfo(newInfo, pixmaps.dataType(), /*row bytes*/ nullptr);
+        tempPixmaps = SkYUVAPixmaps::Allocate(newPixmapInfo);
+        SkSamplingOptions sampling(SkFilterMode::kLinear, SkMipmapMode::kNone);
+        if (!tempPixmaps.isValid()) {
+            return nullptr;
+        }
+        for (int i = 0; i < numPlanes; ++i) {
+            if (!pixmaps.plane(i).scalePixels(tempPixmaps.plane(i), sampling)) {
+                return nullptr;
+            }
+        }
+        pixmapsToUpload = &tempPixmaps;
     }
 
+    // Convert to texture proxies.
+    GrSurfaceProxyView views[SkYUVAInfo::kMaxPlanes];
+    GrColorType pixmapColorTypes[SkYUVAInfo::kMaxPlanes];
+    for (int i = 0; i < numPlanes; ++i) {
+        // Turn the pixmap into a GrTextureProxy
+        SkBitmap bmp;
+        bmp.installPixels(pixmapsToUpload->plane(i));
+        GrBitmapTextureMaker bitmapMaker(context, bmp, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
+        views[i] = bitmapMaker.view(buildMips);
+        if (!views[i]) {
+            return nullptr;
+        }
+        pixmapColorTypes[i] = SkColorTypeToGrColorType(bmp.colorType());
+    }
+
+    GrYUVATextureProxies yuvaProxies(pixmapsToUpload->yuvaInfo(), views, pixmapColorTypes);
+    SkASSERT(yuvaProxies.isValid());
     return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context),
-                                       pixmaps.yuvaInfo().dimensions(),
                                        kNeedNewImageUniqueID,
-                                       pixmaps.yuvaInfo().yuvColorSpace(),
-                                       tempViews,
-                                       numPlanes,
-                                       yuvaLocations,
+                                       std::move(yuvaProxies),
                                        std::move(imageColorSpace));
 }
 
@@ -413,7 +361,6 @@
         releaseHelpers[i] = GrRefCntedCallback::Make(textureReleaseProc, textureContexts[i]);
     }
 
-    SkYUVAInfo::YUVALocations yuvaLocations = yuvaBackendTextureInfo.toYUVALocations();
     if (yuvaBackendTextureInfo.yuvaInfo().origin() != SkEncodedOrigin::kDefault_SkEncodedOrigin) {
         // SkImage_GpuYUVA does not support this yet. This will get removed
         // when the old APIs are gone and we only have to support YUVA configs described by
@@ -434,23 +381,24 @@
     }
 
     // Make a lazy proxy for each plane and wrap in a view.
-    GrSurfaceProxyView views[4];
-    for (int texIdx = 0; texIdx < n; ++texIdx) {
-        auto proxy = MakePromiseImageLazyProxy(context,
-                                               planeDimensions[texIdx],
-                                               yuvaBackendTextureInfo.planeFormat(texIdx),
+    sk_sp<GrSurfaceProxy> proxies[4];
+    for (int i = 0; i < n; ++i) {
+        proxies[i] = MakePromiseImageLazyProxy(context,
+                                               planeDimensions[i],
+                                               yuvaBackendTextureInfo.planeFormat(i),
                                                GrMipmapped::kNo,
                                                textureFulfillProc,
-                                               std::move(releaseHelpers[texIdx]));
-        if (!proxy) {
+                                               std::move(releaseHelpers[i]));
+        if (!proxies[i]) {
             return nullptr;
         }
-        views[texIdx] = GrSurfaceProxyView(std::move(proxy), yuvaBackendTextureInfo.textureOrigin(),
-                                           GrSwizzle("rgba"));
     }
-
-    return sk_make_sp<SkImage_GpuYUVA>(
-            sk_ref_sp(context), yuvaBackendTextureInfo.yuvaInfo().dimensions(),
-            kNeedNewImageUniqueID, yuvaBackendTextureInfo.yuvColorSpace(), views, n, yuvaLocations,
-            std::move(imageColorSpace));
+    GrYUVATextureProxies yuvaTextureProxies(yuvaBackendTextureInfo.yuvaInfo(),
+                                            proxies,
+                                            yuvaBackendTextureInfo.textureOrigin());
+    SkASSERT(yuvaTextureProxies.isValid());
+    return sk_make_sp<SkImage_GpuYUVA>(sk_ref_sp(context),
+                                       kNeedNewImageUniqueID,
+                                       std::move(yuvaTextureProxies),
+                                       std::move(imageColorSpace));
 }
diff --git a/src/image/SkImage_GpuYUVA.h b/src/image/SkImage_GpuYUVA.h
index 2378e0e..ddaf2bb 100644
--- a/src/image/SkImage_GpuYUVA.h
+++ b/src/image/SkImage_GpuYUVA.h
@@ -10,13 +10,14 @@
 
 #include "include/gpu/GrBackendSurface.h"
 #include "src/core/SkCachedData.h"
+#include "src/gpu/GrYUVATextureProxies.h"
 #include "src/image/SkImage_GpuBase.h"
 
 class GrDirectContext;
 class GrRecordingContext;
 class GrTexture;
 
-// Wraps the 3 or 4 planes of a YUVA image for consumption by the GPU.
+// Wraps the 1 to 4 planes of a YUVA image for consumption by the GPU.
 // Initially any direct rendering will be done by passing the individual planes to a shader.
 // Once any method requests a flattened image (e.g., onReadPixels), the flattened RGB
 // proxy will be stored and used for any future rendering.
@@ -25,12 +26,8 @@
     friend class GrYUVAImageTextureMaker;
 
     SkImage_GpuYUVA(sk_sp<GrImageContext>,
-                    SkISize size,
                     uint32_t uniqueID,
-                    SkYUVColorSpace,
-                    GrSurfaceProxyView views[],
-                    int numViews,
-                    const SkYUVAInfo::YUVALocations&,
+                    GrYUVATextureProxies proxies,
                     sk_sp<SkColorSpace>);
 
     GrSemaphoresSubmitted onFlush(GrDirectContext*, const GrFlushInfo&) override;
@@ -42,7 +39,8 @@
     const GrSurfaceProxyView* view(GrRecordingContext* context) const override;
 
     bool onIsTextureBacked() const override {
-        SkASSERT(fViews[0].proxy() || fRGBView.proxy());
+        // We should have YUVA proxies or a RGBA proxy,but not both.
+        SkASSERT(fYUVAProxies.isValid() != SkToBool(fRGBView));
         return true;
     }
 
@@ -61,7 +59,7 @@
 #if GR_TEST_UTILS
     bool testingOnly_IsFlattened() const {
         // We should only have the flattened proxy or the planar proxies at one point in time.
-        SkASSERT(SkToBool(fRGBView.proxy()) != SkToBool(fViews[0].proxy()));
+        SkASSERT(SkToBool(fRGBView) != fYUVAProxies.isValid());
         return SkToBool(fRGBView.proxy());
     }
 #endif
@@ -76,25 +74,17 @@
                                                  PromiseImageTextureReleaseProc textureReleaseProc,
                                                  PromiseImageTextureContext textureContexts[]);
 
-    static bool MakeTempTextureProxies(GrRecordingContext*,
-                                       const GrBackendTexture yuvaTextures[],
-                                       int numTextures,
-                                       const SkYUVAInfo::YUVALocations&,
-                                       GrSurfaceOrigin imageOrigin,
-                                       GrSurfaceProxyView tempViews[4],
-                                       sk_sp<GrRefCntedCallback> releaseHelper);
-
 private:
     SkImage_GpuYUVA(sk_sp<GrImageContext>, const SkImage_GpuYUVA* image, sk_sp<SkColorSpace>);
 
     void flattenToRGB(GrRecordingContext*) const;
 
-    // This array will usually only be sparsely populated.
-    // The actual non-null fields are dictated by the 'fYUVAIndices' indices
-    mutable GrSurfaceProxyView       fViews[4];
-    int                              fNumViews;
-    SkYUVAInfo::YUVALocations        fYUVALocations;
-    const SkYUVColorSpace            fYUVColorSpace;
+    mutable GrYUVATextureProxies     fYUVAProxies;
+
+    // This is only allocated when the image needs to be flattened rather than
+    // using the separate YUVA planes. From thence forth we will only use the
+    // the RGBView.
+    mutable GrSurfaceProxyView       fRGBView;
 
     // If this is non-null then the planar data should be converted from fFromColorSpace to
     // this->colorSpace(). Otherwise we assume the planar data (post YUV->RGB conversion) is already
@@ -106,10 +96,6 @@
     mutable sk_sp<SkColorSpace>      fOnMakeColorSpaceTarget;
     mutable sk_sp<SkImage>           fOnMakeColorSpaceResult;
 
-    // This is only allocated when the image needs to be flattened rather than
-    // using the separate YUVA planes. From thence forth we will only use the
-    // the RGBView.
-    mutable GrSurfaceProxyView       fRGBView;
     using INHERITED = SkImage_GpuBase;
 };
 
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
index b1582a8..37e3afd 100644
--- a/src/image/SkImage_Lazy.cpp
+++ b/src/image/SkImage_Lazy.cpp
@@ -30,7 +30,8 @@
 #include "src/gpu/GrProxyProvider.h"
 #include "src/gpu/GrRecordingContextPriv.h"
 #include "src/gpu/GrSamplerState.h"
-#include "src/gpu/GrSurfaceDrawContext.h"
+#include "src/gpu/GrSurfaceFillContext.h"
+#include "src/gpu/GrYUVATextureProxies.h"
 #include "src/gpu/SkGr.h"
 #include "src/gpu/effects/GrYUVtoRGBEffect.h"
 #endif
@@ -267,7 +268,8 @@
         return {};
     }
 
-    GrSurfaceProxyView yuvViews[SkYUVAInfo::kMaxPlanes];
+    GrSurfaceProxyView views[SkYUVAInfo::kMaxPlanes];
+    GrColorType pixmapColorTypes[SkYUVAInfo::kMaxPlanes];
     for (int i = 0; i < yuvaPixmaps.numPlanes(); ++i) {
         // If the sizes of the components are not all the same we choose to create exact-match
         // textures for the smaller ones rather than add a texture domain to the draw.
@@ -296,11 +298,12 @@
         bitmap.setImmutable();
 
         GrBitmapTextureMaker maker(ctx, bitmap, fit);
-        yuvViews[i] = maker.view(GrMipmapped::kNo);
+        views[i] = maker.view(GrMipmapped::kNo);
 
-        if (!yuvViews[i]) {
+        if (!views[i]) {
             return {};
         }
+        pixmapColorTypes[i] = SkColorTypeToGrColorType(bitmap.colorType());
     }
 
     // TODO: investigate preallocating mip maps here
@@ -320,12 +323,13 @@
         return {};
     }
 
-    std::unique_ptr<GrFragmentProcessor> yuvToRgbProcessor =
-            GrYUVtoRGBEffect::Make(yuvViews,
-                                   yuvaPixmaps.toYUVALocations(),
-                                   yuvaPixmaps.yuvaInfo().yuvColorSpace(),
-                                   GrSamplerState::Filter::kNearest,
-                                   *ctx->priv().caps());
+    GrYUVATextureProxies yuvaProxies(yuvaPixmaps.yuvaInfo(), views, pixmapColorTypes);
+    SkAssertResult(yuvaProxies.isValid());
+
+    std::unique_ptr<GrFragmentProcessor> fp = GrYUVtoRGBEffect::Make(
+            yuvaProxies,
+            GrSamplerState::Filter::kNearest,
+            *ctx->priv().caps());
 
     // The pixels after yuv->rgb will be in the generator's color space.
     // If onMakeColorTypeAndColorSpace has been called then this will not match this image's
@@ -340,18 +344,11 @@
 
     // If the caller expects the pixels in a different color space than the one from the image,
     // apply a color conversion to do this.
-    std::unique_ptr<GrFragmentProcessor> colorConversionProcessor =
-            GrColorSpaceXformEffect::Make(std::move(yuvToRgbProcessor),
-                                          srcColorSpace, kOpaque_SkAlphaType,
-                                          dstColorSpace, kOpaque_SkAlphaType);
-    SkMatrix m = SkEncodedOriginToMatrix(yuvaPixmaps.yuvaInfo().origin(),
-                                         this->width(),
-                                         this->height());
-    // The returned matrix is a view matrix but we need a local matrix.
-    SkAssertResult(m.invert(&m));
-    surfaceFillContext->fillWithFP(m, std::move(colorConversionProcessor));
+    fp = GrColorSpaceXformEffect::Make(std::move(fp),
+                                       srcColorSpace, kOpaque_SkAlphaType,
+                                       dstColorSpace, kOpaque_SkAlphaType);
+    surfaceFillContext->fillWithFP(std::move(fp));
 
-    SkASSERT(surfaceFillContext->asTextureProxy());
     return surfaceFillContext->readSurfaceView();
 }