new image from backend desc

tests/GrSurfaceTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #include "GrRenderTarget.h"
 #include "GrTexture.h"
 #include "GrSurfacePriv.h"
+#include "SkCanvas.h"
+#include "SkImage.h"
+#include "SkSurface.h"
+#include "SkUtils.h"
 #include "Test.h"
 
 // Tests that GrSurface::asTexture(), GrSurface::asRenderTarget(), and static upcasting of texture
 // and render targets to GrSurface all work as expected.
 DEF_GPUTEST(GrSurface, reporter, factory) {
     GrContext* context = factory->get(GrContextFactory::kNull_GLContextType);
     if (context) {
         GrSurfaceDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
@@ skipping 33 matching lines @@
                                   static_cast<GrSurface*>(texRT2->asTexture()));
         REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT2->asRenderTarget()) ==
                                    static_cast<GrSurface*>(texRT2->asTexture()));
 
         texRT1->unref();
         texRT2->unref();
         tex1->unref();
     }
 }
 
+static SkImage* make_gpu_image(GrContext* ctx, int w, int h, SkColor color) {

[bsalomon, 2015/05/07 19:52:22]

This file is really about testing GrSurface, not SkSurface. Maybe this belongs
in SurfaceTest.cpp?

There is already a similar cheat for wrapping a texture there in
test_wrapped_texture_surface

[reed1, 2015/05/07 20:28:00]

Done.

+    const SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info));
+    if (!surface) {
+        return NULL;
+    }
+    surface->getCanvas()->drawColor(color);
+    surface->getCanvas()->flush();
+    return surface->newImageSnapshot();
+}
+
+static void test_tex_image(skiatest::Reporter* reporter, GrContext* ctx, GrBackendObject nativeTex,
+                           int w, int h, bool testCopy, SkPMColor expected) {
+    GrBackendTextureDesc desc;
+    desc.fConfig = kSkia8888_GrPixelConfig;
+    // need to be a rendertarget for now...
+    desc.fFlags = kRenderTarget_GrBackendTextureFlag;   //kNone_GrBackendTextureFlag;
+    desc.fWidth = w;
+    desc.fHeight = h;
+    desc.fSampleCnt = 0;
+    desc.fTextureHandle = nativeTex;
+    SkAutoTUnref<SkImage> image(testCopy ?
+                                SkImage::NewFromTextureCopy(ctx, desc) :
+                                SkImage::NewFromTexture(ctx, desc));
+    REPORTER_ASSERT(reporter, image.get() != NULL);
+    if (image) {
+        const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
+        SkPMColor pixel;
+        REPORTER_ASSERT(reporter, image->readPixels(info, &pixel, sizeof(pixel), 0, 0));
+        REPORTER_ASSERT(reporter, pixel == expected);
+    }
+}
+

[robertphillips, 2015/05/07 20:09:08]

// Test wrapping a GrBackendObject in a surface, rendering to it, and then
reading back

?

[reed1, 2015/05/07 20:28:00]

Acknowledged.

+DEF_GPUTEST(SkImage_NewFromTexture, reporter, factory) {
+    GrContext* ctx = factory->get(GrContextFactory::kNative_GLContextType);
+    if (!ctx) {
+        REPORTER_ASSERT(reporter, false);
+        return;
+    }
+    
+    const int w = 10;
+    const int h = 10;
+    const SkColor srcColor = SK_ColorRED;

[robertphillips, 2015/05/07 20:09:07]

constify 'expected' too ?

[reed1, 2015/05/07 20:28:00]

Done.

+    SkPMColor expected = SkPreMultiplyColor(srcColor);
+    SkAutoTUnref<SkImage> srcImg(make_gpu_image(ctx, w, h, srcColor));
+    if (!srcImg) {
+        REPORTER_ASSERT(reporter, false);
+        return;
+    }
+
+    GrBackendObject srcTex = srcImg->getTexture()->getTextureHandle();
+    test_tex_image(reporter, ctx, srcTex, w, h, false, expected);
+    test_tex_image(reporter, ctx, srcTex, w, h, true, expected);
+}
+

[robertphillips, 2015/05/07 20:09:08]

// Test pulling a GrBackendObject from a GrTexture, wrapping it in a surface,
rendering to it and then reading back

?

[reed1, 2015/05/07 20:28:00]

Acknowledged.

+DEF_GPUTEST(SkImage_NewFromTexture2, reporter, factory) {
+    GrContext* ctx = factory->get(GrContextFactory::kNative_GLContextType);
+    if (!ctx) {
+        REPORTER_ASSERT(reporter, false);
+        return;
+    }
+    GrTextureProvider* provider = ctx->textureProvider();
+
+    const int w = 10;
+    const int h = 10;
+    SkPMColor storage[w * h];
+    SkPMColor expected = SkPreMultiplyColor(SK_ColorRED);
+    sk_memset32(storage, expected, w * h);
+
+    GrSurfaceDesc desc;
+    desc.fFlags = kRenderTarget_GrSurfaceFlag;  // needs to be a rendertarget for readpixels();
+    desc.fOrigin = kDefault_GrSurfaceOrigin;
+    desc.fWidth = w;
+    desc.fHeight = h;
+    desc.fConfig = kSkia8888_GrPixelConfig;
+    desc.fSampleCnt = 0;
+
+    SkAutoTUnref<GrTexture> tex(provider->createTexture(desc, false, storage, w * 4));
+    if (!tex) {
+        REPORTER_ASSERT(reporter, false);
+        return;
+    }
+
+    GrBackendObject srcTex = tex->getTextureHandle();
+    test_tex_image(reporter, ctx, srcTex, w, h, false, expected);
+    test_tex_image(reporter, ctx, srcTex, w, h, true, expected);

[robertphillips, 2015/05/07 20:09:08]

Re-scribble on 'tex' and readback again ?

[reed1, 2015/05/07 20:28:00]

Done.

+}
+
 #endif