Add srcData version of createBackendTexture API

rphilli · Skia Commit-Bot · commit cb1adb40d0f3 · 2019-06-10T19:39:33.000Z
Change-Id: I9679774d69e087a4ceb24de78e98585382bf8593 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/218553 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/gm/imagefromyuvtextures.cpp b/gm/imagefromyuvtextures.cpp
@@ -123,51 +123,32 @@ class ImageFromYUVTextures : public GpuGM {
     }
 
     void createYUVTextures(GrContext* context, GrBackendTexture yuvTextures[3]) {
-        GrGpu* gpu = context->priv().getGpu();
-        if (!gpu) {
-            return;
-        }
-
         for (int i = 0; i < 3; ++i) {
             SkASSERT(fYUVBmps[i].width() == SkToInt(fYUVBmps[i].rowBytes()));
-            yuvTextures[i] = gpu->createTestingOnlyBackendTexture(fYUVBmps[i].width(),
-                                                                  fYUVBmps[i].height(),
-                                                                  kAlpha_8_SkColorType,
-                                                                  GrMipMapped::kNo,
-                                                                  GrRenderable::kNo,
-                                                                  fYUVBmps[i].getPixels(),
-                                                                  fYUVBmps[i].rowBytes(),
-                                                                  nullptr);
+            yuvTextures[i] = context->priv().createBackendTexture(&fYUVBmps[i].pixmap(), 1,
+                                                                  GrRenderable::kNo);
         }
-        context->resetContext();
     }
 
     void createResultTexture(GrContext* context, int width, int height,
                              GrBackendTexture* resultTexture) {
         *resultTexture = context->createBackendTexture(
                 width, height, kRGBA_8888_SkColorType, SkColors::kTransparent,
                 GrMipMapped::kNo, GrRenderable::kYes);
-
-        context->resetContext();
     }
 
     void deleteBackendTextures(GrContext* context, GrBackendTexture textures[], int n) {
         if (context->abandoned()) {
             return;
         }
 
-        GrGpu* gpu = context->priv().getGpu();
-        if (!gpu) {
-            return;
-        }
+        GrFlushInfo flushInfo;
+        flushInfo.fFlags = kSyncCpu_GrFlushFlag;
+        context->flush(flushInfo);
 
-        context->flush();
-        gpu->testingOnly_flushGpuAndSync();
         for (int i = 0; i < n; ++i) {
             context->deleteBackendTexture(textures[i]);
         }
-
-        context->resetContext();
     }
 
     void onDraw(GrContext* context, GrRenderTargetContext*, SkCanvas* canvas) override {
diff --git a/gm/wacky_yuv_formats.cpp b/gm/wacky_yuv_formats.cpp
@@ -818,9 +818,9 @@ static void draw_row_label(SkCanvas* canvas, int y, int yuvFormat) {
     canvas->drawString(rowLabel, 0, y, font, paint);
 }
 
-static GrBackendTexture create_yuva_texture(GrGpu* gpu, const SkBitmap& bm,
+static GrBackendTexture create_yuva_texture(GrContext* context, const SkBitmap& bm,
                                             SkYUVAIndex yuvaIndices[4], int texIndex) {
-    const GrCaps* caps = gpu->caps();
+
 
     SkASSERT(texIndex >= 0 && texIndex <= 3);
     int channelCount = 0;
@@ -832,6 +832,9 @@ static GrBackendTexture create_yuva_texture(GrGpu* gpu, const SkBitmap& bm,
     // Need to create an RG texture for two-channel planes
     GrBackendTexture tex;
     if (2 == channelCount) {
+        const GrCaps* caps = context->priv().caps();
+        GrGpu* gpu = context->priv().getGpu();
+
         SkASSERT(kRGBA_8888_SkColorType == bm.colorType());
         SkAutoTMalloc<char> pixels(2 * bm.width()*bm.height());
         char* currPixel = pixels;
@@ -850,12 +853,7 @@ static GrBackendTexture create_yuva_texture(GrGpu* gpu, const SkBitmap& bm,
                                         pixels, 2*bm.width(), nullptr);
     }
     if (!tex.isValid()) {
-        tex = gpu->createTestingOnlyBackendTexture(
-            bm.width(),
-            bm.height(),
-            bm.colorType(),
-            GrMipMapped::kNo, GrRenderable::kNo,
-            bm.getPixels(), bm.rowBytes(), nullptr);
+        tex = context->priv().createBackendTexture(&bm.pixmap(), 1, GrRenderable::kNo);
     }
     return tex;
 }
@@ -961,16 +959,11 @@ class WackyYUVFormatsGM : public GM {
                             return;
                         }
 
-                        GrGpu* gpu = context->priv().getGpu();
-                        if (!gpu) {
-                            return;
-                        }
-
                         GrBackendTexture yuvaTextures[4];
                         SkPixmap yuvaPixmaps[4];
 
                         for (int i = 0; i < numTextures; ++i) {
-                            yuvaTextures[i] = create_yuva_texture(gpu, resultBMs[i],
+                            yuvaTextures[i] = create_yuva_texture(context, resultBMs[i],
                                                                   yuvaIndices, i);
                             if (yuvaTextures[i].isValid()) {
                                 fBackendTextures.push_back(yuvaTextures[i]);
@@ -1168,14 +1161,9 @@ class YUVMakeColorSpaceGM : public GpuGM {
                 continue;
             }
 
-            GrGpu* gpu = context->priv().getGpu();
-            if (!gpu) {
-                return;
-            }
-
             GrBackendTexture yuvaTextures[4];
             for (int i = 0; i < numTextures; ++i) {
-                yuvaTextures[i] = create_yuva_texture(gpu, resultBMs[i], yuvaIndices, i);
+                yuvaTextures[i] = create_yuva_texture(context, resultBMs[i], yuvaIndices, i);
                 if (yuvaTextures[i].isValid()) {
                     fBackendTextures.push_back(yuvaTextures[i]);
                 }
diff --git a/src/gpu/GrContextPriv.cpp b/src/gpu/GrContextPriv.cpp
@@ -367,3 +367,60 @@ std::unique_ptr<GrFragmentProcessor> GrContextPriv::createUPMToPMEffect(
 
     return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToPremul);
 }
+
+//////////////////////////////////////////////////////////////////////////////
+
+#include "src/core/SkMipMap.h"
+
+GrBackendTexture GrContextPriv::createBackendTexture(const SkPixmap srcData[], int numLevels,
+                                                     GrRenderable renderable) {
+    if (!fContext->asDirectContext()) {
+        return {};
+    }
+
+    if (this->abandoned()) {
+        return {};
+    }
+
+    if (!srcData || !numLevels) {
+        return {};
+    }
+
+    int baseWidth = srcData[0].width();
+    int baseHeight = srcData[0].height();
+    SkColorType colorType = srcData[0].colorType();
+
+    if (numLevels > 1) {
+        if (numLevels != SkMipMap::ComputeLevelCount(baseWidth, baseHeight) + 1) {
+            return {};
+        }
+
+        int currentWidth = baseWidth;
+        int currentHeight = baseHeight;
+        for (int i = 1; i < numLevels; ++i) {
+            currentWidth = SkTMax(1, currentWidth / 2);
+            currentHeight = SkTMax(1, currentHeight / 2);
+
+            if (srcData[i].colorType() != colorType) {
+                return {};
+            }
+
+            if (srcData[i].width() != currentWidth || srcData[i].height() != currentHeight) {
+                return {};
+            }
+        }
+    }
+
+    GrBackendFormat backendFormat = this->caps()->getBackendFormatFromColorType(colorType);
+    if (!backendFormat.isValid()) {
+        return {};
+    }
+
+    GrGpu* gpu = fContext->fGpu.get();
+
+    // TODO: propagate the array of pixmaps interface to GrGpu
+    return gpu->createBackendTexture(baseWidth, baseHeight, backendFormat,
+                                     GrMipMapped::kNo, // TODO: use real mipmap setting here
+                                     renderable, srcData[0].addr(), srcData[0].rowBytes(),
+                                     nullptr);
+}
diff --git a/src/gpu/GrContextPriv.h b/src/gpu/GrContextPriv.h
@@ -253,6 +253,14 @@ class GrContextPriv {
     void testingOnly_flushAndRemoveOnFlushCallbackObject(GrOnFlushCallbackObject*);
 #endif
 
+    // If possible, create a backend texture initialized with the provided pixmap data. The client
+    // should ensure that the returned backend texture is valid.
+    // If successful, the created backend texture will be compatible with the provided
+    // pixmap(s).
+    // If numLevels is 1 a non-mipMapped texture will result. If a mipMapped texture is desired
+    // the data for all the mipmap levels must be provided.
+    GrBackendTexture createBackendTexture(const SkPixmap srcData[], int numLevels, GrRenderable);
+
 private:
     explicit GrContextPriv(GrContext* context) : fContext(context) {}
     GrContextPriv(const GrContextPriv&); // unimpl
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
@@ -450,20 +450,6 @@ void GrGpu::dumpJSON(SkJSONWriter* writer) const {
 void GrGpu::dumpJSON(SkJSONWriter* writer) const { }
 #endif
 
-GrBackendTexture GrGpu::createTestingOnlyBackendTexture(int w, int h, SkColorType colorType,
-                                                        GrMipMapped mipMapped,
-                                                        GrRenderable renderable,
-                                                        const void* pixels, size_t rowBytes,
-                                                        const SkColor4f* color) {
-    GrBackendFormat format = this->caps()->getBackendFormatFromColorType(colorType);
-    if (!format.isValid()) {
-        return GrBackendTexture();
-    }
-
-    return this->createBackendTexture(w, h, format, mipMapped, renderable,
-                                      pixels, rowBytes, color);
-}
-
 #if GR_TEST_UTILS
 
 #if GR_GPU_STATS
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
@@ -378,13 +378,6 @@ class GrGpu : public SkRefCnt {
     Stats* stats() { return &fStats; }
     void dumpJSON(SkJSONWriter*) const;
 
-    // TODO: remove this method
-    GrBackendTexture createTestingOnlyBackendTexture(int w, int h, SkColorType,
-                                                     GrMipMapped, GrRenderable,
-                                                     const void* pixels,
-                                                     size_t rowBytes,
-                                                     const SkColor4f* color);
-
     /**
      * Creates a texture directly in the backend API without wrapping it in a GrTexture.
      * Must be matched with a call to deleteBackendTexture().
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
@@ -254,7 +254,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(InitialTextureClear, reporter, context_info)
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadOnlyTexture, reporter, context_info) {
-    auto fillPixels = [](const SkPixmap* p, const std::function<uint32_t(int x, int y)>& f) {
+    auto fillPixels = [](SkPixmap* p, const std::function<uint32_t(int x, int y)>& f) {
         for (int y = 0; y < p->height(); ++y) {
             for (int x = 0; x < p->width(); ++x) {
                 *p->writable_addr32(x, y) = f(x, y);
@@ -277,9 +277,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadOnlyTexture, reporter, context_info) {
     static constexpr int kSize = 100;
     SkAutoPixmapStorage pixels;
     pixels.alloc(SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType, kPremul_SkAlphaType));
-    fillPixels(&pixels, [](int x, int y) {
-        return (0xFFU << 24) | (x << 16) | (y << 8) | uint8_t((x * y) & 0xFF);
-    });
+    fillPixels(&pixels,
+               [](int x, int y) {
+                    return (0xFFU << 24) | (x << 16) | (y << 8) | uint8_t((x * y) & 0xFF);
+               });
 
     GrContext* context = context_info.grContext();
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
@@ -288,9 +289,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadOnlyTexture, reporter, context_info) {
     // that they'd succeed if the texture wasn't kRead. We want to be sure we're failing with
     // kRead for the right reason.
     for (auto ioType : {kRead_GrIOType, kRW_GrIOType}) {
-        auto backendTex = context->priv().getGpu()->createTestingOnlyBackendTexture(
-                kSize, kSize, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kYes,
-                pixels.addr(), 0, nullptr);
+        auto backendTex = context->priv().createBackendTexture(&pixels, 1, GrRenderable::kYes);
+
         auto proxy = proxyProvider->wrapBackendTexture(backendTex, kTopLeft_GrSurfaceOrigin,
                                                        kBorrow_GrWrapOwnership,
                                                        GrWrapCacheable::kNo, ioType);
diff --git a/tests/GrTestingBackendTextureUploadTest.cpp b/tests/GrTestingBackendTextureUploadTest.cpp
@@ -9,6 +9,7 @@
 
 #include "include/gpu/GrTexture.h"
 #include "src/core/SkConvertPixels.h"
+#include "src/core/SkAutoPixmapStorage.h"
 #include "src/gpu/GrContextPriv.h"
 #include "src/gpu/GrGpu.h"
 #include "src/gpu/SkGr.h"
@@ -20,12 +21,12 @@ void testing_only_texture_test(skiatest::Reporter* reporter, GrContext* context,
 
     const int kWidth = 16;
     const int kHeight = 16;
-    SkAutoTMalloc<GrColor> srcBuffer;
-    if (doDataUpload) {
-        srcBuffer.reset(kWidth * kHeight);
-        fill_pixel_data(kWidth, kHeight, srcBuffer.get());
-    }
-    SkAutoTMalloc<GrColor> dstBuffer(kWidth * kHeight);
+
+    SkImageInfo ii = SkImageInfo::Make(kWidth, kHeight, ct, kPremul_SkAlphaType);
+
+    SkAutoPixmapStorage expectedPixels, actualPixels;
+    expectedPixels.alloc(ii);
+    actualPixels.alloc(ii);
 
     const GrCaps* caps = context->priv().caps();
     GrGpu* gpu = context->priv().getGpu();
@@ -44,10 +45,23 @@ void testing_only_texture_test(skiatest::Reporter* reporter, GrContext* context,
         return;
     }
 
-    GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
-                                        kWidth, kHeight, ct,
-                                        mipMapped, renderable, srcBuffer, 0,
-                                        &SkColors::kTransparent);
+    GrBackendTexture backendTex;
+
+    if (doDataUpload) {
+        SkASSERT(GrMipMapped::kNo == mipMapped);
+
+        fill_pixel_data(kWidth, kHeight, expectedPixels.writable_addr32(0, 0));
+
+        backendTex = context->priv().createBackendTexture(&expectedPixels, 1, renderable);
+    } else {
+        backendTex = context->createBackendTexture(kWidth, kHeight, ct, SkColors::kTransparent,
+                                                   mipMapped, renderable);
+
+        size_t allocSize = SkAutoPixmapStorage::AllocSize(ii, nullptr);
+        // createBackendTexture will fill the texture with 0's if no data is provided, so
+        // we set the expected result likewise.
+        memset(expectedPixels.writable_addr32(0, 0), 0, allocSize);
+    }
     if (!backendTex.isValid()) {
         return;
     }
@@ -62,18 +76,14 @@ void testing_only_texture_test(skiatest::Reporter* reporter, GrContext* context,
     }
     REPORTER_ASSERT(reporter, wrappedTex);
 
-    int rowBytes = GrColorTypeBytesPerPixel(grCT) * kWidth;
     bool result = gpu->readPixels(wrappedTex.get(), 0, 0, kWidth,
-                                  kHeight, grCT, dstBuffer, rowBytes);
+                                  kHeight, grCT,
+                                  actualPixels.writable_addr32(0, 0),
+                                  actualPixels.rowBytes());
 
-    if (!doDataUpload) {
-        // createTestingOnlyBackendTexture will fill the texture with 0's if no data is provided, so
-        // we set the expected result likewise.
-        srcBuffer.reset(kWidth * kHeight);
-        memset(srcBuffer, 0, kWidth * kHeight * sizeof(GrColor));
-    }
     REPORTER_ASSERT(reporter, result);
-    REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer, dstBuffer,
+    REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(expectedPixels.addr32(),
+                                                                     actualPixels.addr32(),
                                                                      kWidth, kHeight));
 }
 
diff --git a/tests/TestUtils.cpp b/tests/TestUtils.cpp
@@ -100,24 +100,15 @@ void fill_pixel_data(int width, int height, GrColor* data) {
 bool create_backend_texture(GrContext* context, GrBackendTexture* backendTex,
                             const SkImageInfo& ii, GrMipMapped mipMapped, SkColor color,
                             GrRenderable renderable) {
-    GrGpu* gpu = context->priv().getGpu();
-    if (!gpu) {
-        return false;
-    }
-
     SkBitmap bm;
     bm.allocPixels(ii);
-    // TODO: a SkBitmap::eraseColor would be better here
     sk_memset32(bm.getAddr32(0, 0), color, ii.width() * ii.height());
 
-    *backendTex = gpu->createTestingOnlyBackendTexture(ii.width(), ii.height(), ii.colorType(),
-                                                       mipMapped, renderable,
-                                                       bm.getPixels(), bm.rowBytes(), nullptr);
-    if (!backendTex->isValid() || !gpu->isTestingOnlyBackendTexture(*backendTex)) {
-        return false;
-    }
+    SkASSERT(GrMipMapped::kNo == mipMapped);
+    // TODO: replace w/ the color-init version of createBackendTexture once Metal supports it.
+    *backendTex = context->priv().createBackendTexture(&bm.pixmap(), 1, renderable);
 
-    return true;
+    return backendTex->isValid();
 }
 
 void delete_backend_texture(GrContext* context, const GrBackendTexture& backendTex) {
@@ -127,12 +118,12 @@ void delete_backend_texture(GrContext* context, const GrBackendTexture& backendT
     context->deleteBackendTexture(backendTex);
 }
 
-bool does_full_buffer_contain_correct_color(GrColor* srcBuffer,
-                                            GrColor* dstBuffer,
+bool does_full_buffer_contain_correct_color(const GrColor* srcBuffer,
+                                            const GrColor* dstBuffer,
                                             int width,
                                             int height) {
-    GrColor* srcPtr = srcBuffer;
-    GrColor* dstPtr = dstBuffer;
+    const GrColor* srcPtr = srcBuffer;
+    const GrColor* dstPtr = dstBuffer;
     for (int j = 0; j < height; ++j) {
         for (int i = 0; i < width; ++i) {
             if (srcPtr[i] != dstPtr[i]) {
diff --git a/tests/TestUtils.h b/tests/TestUtils.h
diff --git a/tools/DDLPromiseImageHelper.cpp b/tools/DDLPromiseImageHelper.cpp
