tests/CrossContextImageTest.cpp - platform/external/skqp - Gitiles

 /*
  * Copyright 2017 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 "GrContextFactory.h"
 #include "Resources.h"
 #include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkCrossContextImageData.h"
 #include "SkSemaphore.h"
 #include "SkSurface.h"
 #include "SkThreadUtils.h"
 #include "Test.h"

 using namespace sk_gpu_test;

 static SkImageInfo read_pixels_info(SkImage* image) {
     return SkImageInfo::MakeN32(image->width(), image->height(), image->alphaType());
 }

 static bool colors_are_close(SkColor a, SkColor b, int error) {
     return SkTAbs((int)SkColorGetR(a) - (int)SkColorGetR(b)) <= error &&
            SkTAbs((int)SkColorGetG(a) - (int)SkColorGetG(b)) <= error &&
            SkTAbs((int)SkColorGetB(a) - (int)SkColorGetB(b)) <= error;
 }

 static void assert_equal(skiatest::Reporter* reporter, SkImage* a, SkImage* b, int error) {
     REPORTER_ASSERT(reporter, a->width() == b->width());
     REPORTER_ASSERT(reporter, a->height() == b->height());

     SkAutoPixmapStorage pmapA, pmapB;
     pmapA.alloc(read_pixels_info(a));
     pmapB.alloc(read_pixels_info(b));

     REPORTER_ASSERT(reporter, a->readPixels(pmapA, 0, 0));
     REPORTER_ASSERT(reporter, b->readPixels(pmapB, 0, 0));

     for (int y = 0; y < a->height(); ++y) {
         for (int x = 0; x < a->width(); ++x) {
             SkColor ca = pmapA.getColor(x, y);
             SkColor cb = pmapB.getColor(x, y);
             if (!error) {
                 if (ca != cb) {
                     ERRORF(reporter, "Expected 0x%08x but got 0x%08x at (%d, %d)", ca, cb, x, y);
                     return;
                 }
             } else {
                 if (!colors_are_close(ca, cb, error)) {
                     ERRORF(reporter, "Expected 0x%08x +-%d but got 0x%08x at (%d, %d)",
                            ca, error, cb, x, y);
                     return;
                 }
             }
         }
     }
 }

 static void draw_image_test_pattern(SkCanvas* canvas) {
     canvas->clear(SK_ColorWHITE);
     SkPaint paint;
     paint.setColor(SK_ColorBLACK);
     canvas->drawRect(SkRect::MakeXYWH(5, 5, 10, 10), paint);
 }

 static sk_sp<SkImage> create_test_image() {
     SkBitmap bm;
     bm.allocN32Pixels(20, 20, true);
     SkCanvas canvas(bm);
     draw_image_test_pattern(&canvas);

     return SkImage::MakeFromBitmap(bm);
 }

 static sk_sp<SkData> create_test_data(SkEncodedImageFormat format) {
     auto image = create_test_image();
     return sk_sp<SkData>(image->encode(format, 100));
 }

 DEF_GPUTEST(CrossContextImage_SameContext, reporter, /*factory*/) {
     GrContextFactory factory;
     sk_sp<SkImage> testImage = create_test_image();

     // Test both PNG and JPG, to exercise GPU YUV conversion
     for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
         sk_sp<SkData> encoded = create_test_data(format);

         for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
             GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
             if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
                 continue;
             }

             ContextInfo info = factory.getContextInfo(ctxType);
             if (!info.grContext()) {
                 continue;
             }

             auto ccid = SkCrossContextImageData::MakeFromEncoded(info.grContext(), encoded,
                                                                  nullptr);
             REPORTER_ASSERT(reporter, ccid != nullptr);

             auto image = SkImage::MakeFromCrossContextImageData(info.grContext(), std::move(ccid));
             REPORTER_ASSERT(reporter, image != nullptr);

             // JPEG encode -> decode won't round trip the image perfectly
             assert_equal(reporter, testImage.get(), image.get(),
                          SkEncodedImageFormat::kJPEG == format ? 2 : 0);
         }
     }
 }

 DEF_GPUTEST(CrossContextImage_SharedContextSameThread, reporter, /*factory*/) {
     GrContextFactory factory;
     sk_sp<SkImage> testImage = create_test_image();

     // Test both PNG and JPG, to exercise GPU YUV conversion
     for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
         sk_sp<SkData> encoded = create_test_data(format);

         for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
             GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
             if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
                 continue;
             }

             ContextInfo info = factory.getContextInfo(ctxType);
             if (!info.grContext()) {
                 continue;
             }
             auto ccid = SkCrossContextImageData::MakeFromEncoded(info.grContext(), encoded,
                                                                  nullptr);
             REPORTER_ASSERT(reporter, ccid != nullptr);

             ContextInfo info2 = factory.getSharedContextInfo(info.grContext());
             GrContext* ctx2 = info2.grContext();
             int resourceCountBefore = 0, resourceCountAfter = 0;
             size_t resourceBytesBefore = 0, resourceBytesAfter = 0;
             if (ctx2 && info.grContext()->caps()->crossContextTextureSupport()) {
                 ctx2->getResourceCacheUsage(&resourceCountBefore, &resourceBytesBefore);
             }

             auto image = SkImage::MakeFromCrossContextImageData(ctx2, std::move(ccid));
             REPORTER_ASSERT(reporter, image != nullptr);

             if (ctx2 && info.grContext()->caps()->crossContextTextureSupport()) {
                 // MakeFromCrossContextImageData should have imported the texture back into our
                 // cache, so we should see an uptick. (If we have crossContextTextureSupport,
                 // otherwise we're just handing around a CPU or codec-backed image, so no cache
                 // impact will occur).
                 ctx2->getResourceCacheUsage(&resourceCountAfter, &resourceBytesAfter);
                 REPORTER_ASSERT(reporter, resourceCountAfter == resourceCountBefore + 1);
                 REPORTER_ASSERT(reporter, resourceBytesAfter > resourceBytesBefore);
             }

             // JPEG encode -> decode won't round trip the image perfectly
             assert_equal(reporter, testImage.get(), image.get(),
                          SkEncodedImageFormat::kJPEG == format ? 2 : 0);
         }
     }
 }

 namespace {
 struct CrossContextImage_ThreadContext {
     GrContext* fGrContext;
     sk_gpu_test::TestContext* fTestContext;
     SkSemaphore fSemaphore;
     std::unique_ptr<SkCrossContextImageData> fCCID;
     sk_sp<SkData> fEncoded;
 };
 }

 static void upload_image_thread_proc(void* data) {
     CrossContextImage_ThreadContext* ctx = static_cast<CrossContextImage_ThreadContext*>(data);
     ctx->fTestContext->makeCurrent();
     ctx->fCCID = SkCrossContextImageData::MakeFromEncoded(ctx->fGrContext, ctx->fEncoded, nullptr);
     ctx->fSemaphore.signal();
 }

 DEF_GPUTEST(CrossContextImage_SharedContextOtherThread, reporter, /*factory*/) {
     sk_sp<SkImage> testImage = create_test_image();

     // Test both PNG and JPG, to exercise GPU YUV conversion
     for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
         // Use a new factory for each batch of tests. Otherwise the shared context will still be
         // current on the upload thread when we do the second iteration, and we get undefined
         // behavior.
         GrContextFactory factory;
         sk_sp<SkData> encoded = create_test_data(format);

         for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
             GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
             if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
                 continue;
             }

             // Create two GrContexts in a share group
             ContextInfo info = factory.getContextInfo(ctxType);
             if (!info.grContext()) {
                 continue;
             }
             ContextInfo info2 = factory.getSharedContextInfo(info.grContext());
             if (!info2.grContext()) {
                 continue;
             }

             // Make the first one current (on this thread) again
             info.testContext()->makeCurrent();

             // Bundle up data for the worker thread
             CrossContextImage_ThreadContext ctx;
             ctx.fGrContext = info2.grContext();
             ctx.fTestContext = info2.testContext();
             ctx.fEncoded = encoded;

             SkThread uploadThread(upload_image_thread_proc, &ctx);
             SkAssertResult(uploadThread.start());

             ctx.fSemaphore.wait();
             auto image = SkImage::MakeFromCrossContextImageData(info.grContext(),
                                                                 std::move(ctx.fCCID));
             REPORTER_ASSERT(reporter, image != nullptr);

             // JPEG encode -> decode won't round trip the image perfectly
             assert_equal(reporter, testImage.get(), image.get(),
                          SkEncodedImageFormat::kJPEG == format ? 2 : 0);

             uploadThread.join();
         }
     }
 }

 #endif
	/*
	* Copyright 2017 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 "GrContextFactory.h"
	#include "Resources.h"
	#include "SkAutoPixmapStorage.h"
	#include "SkBitmap.h"
	#include "SkCanvas.h"
	#include "SkCrossContextImageData.h"
	#include "SkSemaphore.h"
	#include "SkSurface.h"
	#include "SkThreadUtils.h"
	#include "Test.h"

	using namespace sk_gpu_test;

	static SkImageInfo read_pixels_info(SkImage* image) {
	return SkImageInfo::MakeN32(image->width(), image->height(), image->alphaType());
	}

	static bool colors_are_close(SkColor a, SkColor b, int error) {
	return SkTAbs((int)SkColorGetR(a) - (int)SkColorGetR(b)) <= error &&
	SkTAbs((int)SkColorGetG(a) - (int)SkColorGetG(b)) <= error &&
	SkTAbs((int)SkColorGetB(a) - (int)SkColorGetB(b)) <= error;
	}

	static void assert_equal(skiatest::Reporter* reporter, SkImage* a, SkImage* b, int error) {
	REPORTER_ASSERT(reporter, a->width() == b->width());
	REPORTER_ASSERT(reporter, a->height() == b->height());

	SkAutoPixmapStorage pmapA, pmapB;
	pmapA.alloc(read_pixels_info(a));
	pmapB.alloc(read_pixels_info(b));

	REPORTER_ASSERT(reporter, a->readPixels(pmapA, 0, 0));
	REPORTER_ASSERT(reporter, b->readPixels(pmapB, 0, 0));

	for (int y = 0; y < a->height(); ++y) {
	for (int x = 0; x < a->width(); ++x) {
	SkColor ca = pmapA.getColor(x, y);
	SkColor cb = pmapB.getColor(x, y);
	if (!error) {
	if (ca != cb) {
	ERRORF(reporter, "Expected 0x%08x but got 0x%08x at (%d, %d)", ca, cb, x, y);
	return;
	}
	} else {
	if (!colors_are_close(ca, cb, error)) {
	ERRORF(reporter, "Expected 0x%08x +-%d but got 0x%08x at (%d, %d)",
	ca, error, cb, x, y);
	return;
	}
	}
	}
	}
	}

	static void draw_image_test_pattern(SkCanvas* canvas) {
	canvas->clear(SK_ColorWHITE);
	SkPaint paint;
	paint.setColor(SK_ColorBLACK);
	canvas->drawRect(SkRect::MakeXYWH(5, 5, 10, 10), paint);
	}

	static sk_sp<SkImage> create_test_image() {
	SkBitmap bm;
	bm.allocN32Pixels(20, 20, true);
	SkCanvas canvas(bm);
	draw_image_test_pattern(&canvas);

	return SkImage::MakeFromBitmap(bm);
	}

	static sk_sp<SkData> create_test_data(SkEncodedImageFormat format) {
	auto image = create_test_image();
	return sk_sp<SkData>(image->encode(format, 100));
	}

	DEF_GPUTEST(CrossContextImage_SameContext, reporter, /factory/) {
	GrContextFactory factory;
	sk_sp<SkImage> testImage = create_test_image();

	// Test both PNG and JPG, to exercise GPU YUV conversion
	for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
	sk_sp<SkData> encoded = create_test_data(format);

	for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
	GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
	if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
	continue;
	}

	ContextInfo info = factory.getContextInfo(ctxType);
	if (!info.grContext()) {
	continue;
	}

	auto ccid = SkCrossContextImageData::MakeFromEncoded(info.grContext(), encoded,
	nullptr);
	REPORTER_ASSERT(reporter, ccid != nullptr);

	auto image = SkImage::MakeFromCrossContextImageData(info.grContext(), std::move(ccid));
	REPORTER_ASSERT(reporter, image != nullptr);

	// JPEG encode -> decode won't round trip the image perfectly
	assert_equal(reporter, testImage.get(), image.get(),
	SkEncodedImageFormat::kJPEG == format ? 2 : 0);
	}
	}
	}

	DEF_GPUTEST(CrossContextImage_SharedContextSameThread, reporter, /factory/) {
	GrContextFactory factory;
	sk_sp<SkImage> testImage = create_test_image();

	// Test both PNG and JPG, to exercise GPU YUV conversion
	for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
	sk_sp<SkData> encoded = create_test_data(format);

	for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
	GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
	if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
	continue;
	}

	ContextInfo info = factory.getContextInfo(ctxType);
	if (!info.grContext()) {
	continue;
	}
	auto ccid = SkCrossContextImageData::MakeFromEncoded(info.grContext(), encoded,
	nullptr);
	REPORTER_ASSERT(reporter, ccid != nullptr);

	ContextInfo info2 = factory.getSharedContextInfo(info.grContext());
	GrContext* ctx2 = info2.grContext();
	int resourceCountBefore = 0, resourceCountAfter = 0;
	size_t resourceBytesBefore = 0, resourceBytesAfter = 0;
	if (ctx2 && info.grContext()->caps()->crossContextTextureSupport()) {
	ctx2->getResourceCacheUsage(&resourceCountBefore, &resourceBytesBefore);
	}

	auto image = SkImage::MakeFromCrossContextImageData(ctx2, std::move(ccid));
	REPORTER_ASSERT(reporter, image != nullptr);

	if (ctx2 && info.grContext()->caps()->crossContextTextureSupport()) {
	// MakeFromCrossContextImageData should have imported the texture back into our
	// cache, so we should see an uptick. (If we have crossContextTextureSupport,
	// otherwise we're just handing around a CPU or codec-backed image, so no cache
	// impact will occur).
	ctx2->getResourceCacheUsage(&resourceCountAfter, &resourceBytesAfter);
	REPORTER_ASSERT(reporter, resourceCountAfter == resourceCountBefore + 1);
	REPORTER_ASSERT(reporter, resourceBytesAfter > resourceBytesBefore);
	}

	// JPEG encode -> decode won't round trip the image perfectly
	assert_equal(reporter, testImage.get(), image.get(),
	SkEncodedImageFormat::kJPEG == format ? 2 : 0);
	}
	}
	}

	namespace {
	struct CrossContextImage_ThreadContext {
	GrContext* fGrContext;
	sk_gpu_test::TestContext* fTestContext;
	SkSemaphore fSemaphore;
	std::unique_ptr<SkCrossContextImageData> fCCID;
	sk_sp<SkData> fEncoded;
	};
	}

	static void upload_image_thread_proc(void* data) {
	CrossContextImage_ThreadContext* ctx = static_cast<CrossContextImage_ThreadContext*>(data);
	ctx->fTestContext->makeCurrent();
	ctx->fCCID = SkCrossContextImageData::MakeFromEncoded(ctx->fGrContext, ctx->fEncoded, nullptr);
	ctx->fSemaphore.signal();
	}

	DEF_GPUTEST(CrossContextImage_SharedContextOtherThread, reporter, /factory/) {
	sk_sp<SkImage> testImage = create_test_image();

	// Test both PNG and JPG, to exercise GPU YUV conversion
	for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
	// Use a new factory for each batch of tests. Otherwise the shared context will still be
	// current on the upload thread when we do the second iteration, and we get undefined
	// behavior.
	GrContextFactory factory;
	sk_sp<SkData> encoded = create_test_data(format);

	for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
	GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
	if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
	continue;
	}

	// Create two GrContexts in a share group
	ContextInfo info = factory.getContextInfo(ctxType);
	if (!info.grContext()) {
	continue;
	}
	ContextInfo info2 = factory.getSharedContextInfo(info.grContext());
	if (!info2.grContext()) {
	continue;
	}

	// Make the first one current (on this thread) again
	info.testContext()->makeCurrent();

	// Bundle up data for the worker thread
	CrossContextImage_ThreadContext ctx;
	ctx.fGrContext = info2.grContext();
	ctx.fTestContext = info2.testContext();
	ctx.fEncoded = encoded;

	SkThread uploadThread(upload_image_thread_proc, &ctx);
	SkAssertResult(uploadThread.start());

	ctx.fSemaphore.wait();
	auto image = SkImage::MakeFromCrossContextImageData(info.grContext(),
	std::move(ctx.fCCID));
	REPORTER_ASSERT(reporter, image != nullptr);

	// JPEG encode -> decode won't round trip the image perfectly
	assert_equal(reporter, testImage.get(), image.get(),
	SkEncodedImageFormat::kJPEG == format ? 2 : 0);

	uploadThread.join();
	}
	}
	}

	#endif