tests/GpuBitmapCopyTest.cpp - platform/external/skia - Gitiles


 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #if SK_SUPPORT_GPU

 #include "GrContext.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColor.h"
 #include "SkGpuDevice.h"
 #include "SkPaint.h"
 #include "SkPixelRef.h"
 #include "SkRect.h"
 #include "Test.h"

 static const char* boolStr(bool value) {
     return value ? "true" : "false";
 }

 // these are in the same order as the SkBitmap::Config enum
 static const char* gConfigName[] = {
     "None", "4444", "8888"
 };

 struct Pair {
     SkBitmap::Config    fConfig;
     const char*         fValid;
 };

 extern bool getUpperLeftFromOffset(const SkBitmap& bm, int* x, int* y);
 extern size_t getSubOffset(const SkBitmap& bm, int x, int y);

 /**
  *  Tests that getUpperLeftFromOffset and getSubOffset agree with each other.
  */
 static void TestSubsetHelpers(skiatest::Reporter* reporter, const SkBitmap& bitmap){
     int x, y;
     bool upperLeft = getUpperLeftFromOffset(bitmap, &x, &y);
     REPORTER_ASSERT(reporter, upperLeft);
     REPORTER_ASSERT(reporter, getSubOffset(bitmap, x, y) == bitmap.pixelRefOffset());
 }

 /**
  *  Check to ensure that copying a GPU-backed SkBitmap behaved as expected.
  *  @param reporter Used to report failures.
  *  @param desiredConfig Config being copied to. If the copy succeeded, dst must have this Config.
  *  @param success True if the copy succeeded.
  *  @param src A GPU-backed SkBitmap that had copyTo or deepCopyTo called on it.
  *  @param dst SkBitmap that was copied to.
  *  @param deepCopy True if deepCopyTo was used; false if copyTo was used.
  *  @param subset Portion of src's SkPixelRef that src represents. dst should represent the same
  *      portion after the copy. Pass NULL for all pixels.
  */
 static void TestIndividualCopy(skiatest::Reporter* reporter, const SkBitmap::Config desiredConfig,
                                const bool success, const SkBitmap& src, const SkBitmap& dst,
                                const bool deepCopy = true, const SkIRect* subset = NULL) {
     if (success) {
         REPORTER_ASSERT(reporter, src.width() == dst.width());
         REPORTER_ASSERT(reporter, src.height() == dst.height());
         REPORTER_ASSERT(reporter, dst.config() == desiredConfig);
         if (src.config() == dst.config()) {
             // FIXME: When calling copyTo (so deepCopy is false here), sometimes we copy the pixels
             // exactly, in which case the IDs should be the same, but sometimes we do a bitmap draw,
             // in which case the IDs should not be the same. Is there any way to determine which is
             // the case at this point?
             if (deepCopy) {
                 REPORTER_ASSERT(reporter, src.getGenerationID() == dst.getGenerationID());
             }
             REPORTER_ASSERT(reporter, src.pixelRef() != NULL && dst.pixelRef() != NULL);

             // Do read backs and make sure that the two are the same.
             SkBitmap srcReadBack, dstReadBack;
             {
                 SkASSERT(src.getTexture() != NULL);
                 bool readBack = src.pixelRef()->readPixels(&srcReadBack, subset);
                 REPORTER_ASSERT(reporter, readBack);
             }
             if (dst.getTexture() != NULL) {
                 bool readBack = dst.pixelRef()->readPixels(&dstReadBack, subset);
                 REPORTER_ASSERT(reporter, readBack);
             } else {
                 // If dst is not a texture, do a copy instead, to the same config as srcReadBack.
                 bool copy = dst.copyTo(&dstReadBack, srcReadBack.config());
                 REPORTER_ASSERT(reporter, copy);
             }

             SkAutoLockPixels srcLock(srcReadBack);
             SkAutoLockPixels dstLock(dstReadBack);
             REPORTER_ASSERT(reporter, srcReadBack.readyToDraw() && dstReadBack.readyToDraw());

             const char* srcP = static_cast<const char*>(srcReadBack.getAddr(0, 0));
             const char* dstP = static_cast<const char*>(dstReadBack.getAddr(0, 0));
             REPORTER_ASSERT(reporter, srcP != dstP);

             REPORTER_ASSERT(reporter, !memcmp(srcP, dstP, srcReadBack.getSize()));
         } else {
             REPORTER_ASSERT(reporter, src.getGenerationID() != dst.getGenerationID());
         }

         // If the copy used a subset, test the pixel offset calculation functions.
         if (subset != NULL) {
             TestSubsetHelpers(reporter, dst);
         }
     } else {
         // dst should be unchanged from its initial state
         REPORTER_ASSERT(reporter, dst.config() == SkBitmap::kNo_Config);
         REPORTER_ASSERT(reporter, dst.width() == 0);
         REPORTER_ASSERT(reporter, dst.height() == 0);
     }

 }

 // Stripped down version of TestBitmapCopy that checks basic fields (width, height, config, genID)
 // to ensure that they were copied properly.
 static void TestGpuBitmapCopy(skiatest::Reporter* reporter, GrContext* grContext) {
 #ifdef SK_BUILD_FOR_ANDROID // https://code.google.com/p/skia/issues/detail?id=753
     return;
 #endif
     if (NULL == grContext) {
         return;
     }
     static const Pair gPairs[] = {
         { SkBitmap::kNo_Config,         "000"  },
         { SkBitmap::kARGB_4444_Config,  "011"  },
         { SkBitmap::kARGB_8888_Config,  "011"  },
     };

     const int W = 20;
     const int H = 33;

     for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
         SkBitmap src, dst;

         SkGpuDevice* device = SkNEW_ARGS(SkGpuDevice, (grContext, gPairs[i].fConfig, W, H));
         SkAutoUnref aur(device);
         src = device->accessBitmap(false);
         device->clear(SK_ColorWHITE);

         // Draw something different to the same portion of the bitmap that we will extract as a
         // subset, so that comparing the pixels of the subset will be meaningful.
         SkIRect subsetRect = SkIRect::MakeLTRB(W/2, H/2, W, H);
         SkCanvas drawingCanvas(device);
         SkPaint paint;
         paint.setColor(SK_ColorRED);
         drawingCanvas.drawRect(SkRect::MakeFromIRect(subsetRect), paint);

         // Extract a subset. If this succeeds we will test copying the subset.
         SkBitmap subset;
         const bool extracted = src.extractSubset(&subset, subsetRect);
         if (extracted) {
             TestSubsetHelpers(reporter, subset);
         }

         for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
             dst.reset();
             bool success = src.deepCopyTo(&dst, gPairs[j].fConfig);
             bool expected = gPairs[i].fValid[j] != '0';
             if (success != expected) {
                 SkString str;
                 str.printf("SkBitmap::deepCopyTo from %s to %s. expected %s returned %s",
                            gConfigName[i], gConfigName[j], boolStr(expected),
                            boolStr(success));
                 reporter->reportFailed(str);
             }

             bool canSucceed = src.canCopyTo(gPairs[j].fConfig);
             if (success != canSucceed) {
                 SkString str;
                 str.printf("SkBitmap::deepCopyTo from %s to %s returned %s,"
                            "but canCopyTo returned %s",
                            gConfigName[i], gConfigName[j], boolStr(success),
                            boolStr(canSucceed));
                 reporter->reportFailed(str);
             }

             TestIndividualCopy(reporter, gPairs[j].fConfig, success, src, dst);

             // Test copying the subset bitmap, using both copyTo and deepCopyTo.
             if (extracted) {
                 SkBitmap subsetCopy;
                 success = subset.copyTo(&subsetCopy, gPairs[j].fConfig);
                 REPORTER_ASSERT(reporter, success == expected);
                 REPORTER_ASSERT(reporter, success == canSucceed);
                 TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, false,
                                    &subsetRect);

                 // Reset the bitmap so that a failed copyTo will leave it in the expected state.
                 subsetCopy.reset();
                 success = subset.deepCopyTo(&subsetCopy, gPairs[j].fConfig);
                 REPORTER_ASSERT(reporter, success == expected);
                 REPORTER_ASSERT(reporter, success == canSucceed);
                 TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, true,
                                    &subsetRect);
             }
         } // for (size_t j = ...
     } // for (size_t i = ...
 }

 #include "TestClassDef.h"
 DEFINE_GPUTESTCLASS("GpuBitmapCopy", TestGpuBitmapCopyClass, TestGpuBitmapCopy)

 #endif

	/*
	* Copyright 2012 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#if SK_SUPPORT_GPU

	#include "GrContext.h"
	#include "SkBitmap.h"
	#include "SkCanvas.h"
	#include "SkColor.h"
	#include "SkGpuDevice.h"
	#include "SkPaint.h"
	#include "SkPixelRef.h"
	#include "SkRect.h"
	#include "Test.h"

	static const char* boolStr(bool value) {
	return value ? "true" : "false";
	}

	// these are in the same order as the SkBitmap::Config enum
	static const char* gConfigName[] = {
	"None", "4444", "8888"
	};

	struct Pair {
	SkBitmap::Config fConfig;
	const char* fValid;
	};

	extern bool getUpperLeftFromOffset(const SkBitmap& bm, int* x, int* y);
	extern size_t getSubOffset(const SkBitmap& bm, int x, int y);

	/**
	* Tests that getUpperLeftFromOffset and getSubOffset agree with each other.
	*/
	static void TestSubsetHelpers(skiatest::Reporter* reporter, const SkBitmap& bitmap){
	int x, y;
	bool upperLeft = getUpperLeftFromOffset(bitmap, &x, &y);
	REPORTER_ASSERT(reporter, upperLeft);
	REPORTER_ASSERT(reporter, getSubOffset(bitmap, x, y) == bitmap.pixelRefOffset());
	}

	/**
	* Check to ensure that copying a GPU-backed SkBitmap behaved as expected.
	* @param reporter Used to report failures.
	* @param desiredConfig Config being copied to. If the copy succeeded, dst must have this Config.
	* @param success True if the copy succeeded.
	* @param src A GPU-backed SkBitmap that had copyTo or deepCopyTo called on it.
	* @param dst SkBitmap that was copied to.
	* @param deepCopy True if deepCopyTo was used; false if copyTo was used.
	* @param subset Portion of src's SkPixelRef that src represents. dst should represent the same
	* portion after the copy. Pass NULL for all pixels.
	*/
	static void TestIndividualCopy(skiatest::Reporter* reporter, const SkBitmap::Config desiredConfig,
	const bool success, const SkBitmap& src, const SkBitmap& dst,
	const bool deepCopy = true, const SkIRect* subset = NULL) {
	if (success) {
	REPORTER_ASSERT(reporter, src.width() == dst.width());
	REPORTER_ASSERT(reporter, src.height() == dst.height());
	REPORTER_ASSERT(reporter, dst.config() == desiredConfig);
	if (src.config() == dst.config()) {
	// FIXME: When calling copyTo (so deepCopy is false here), sometimes we copy the pixels
	// exactly, in which case the IDs should be the same, but sometimes we do a bitmap draw,
	// in which case the IDs should not be the same. Is there any way to determine which is
	// the case at this point?
	if (deepCopy) {
	REPORTER_ASSERT(reporter, src.getGenerationID() == dst.getGenerationID());
	}
	REPORTER_ASSERT(reporter, src.pixelRef() != NULL && dst.pixelRef() != NULL);

	// Do read backs and make sure that the two are the same.
	SkBitmap srcReadBack, dstReadBack;
	{
	SkASSERT(src.getTexture() != NULL);
	bool readBack = src.pixelRef()->readPixels(&srcReadBack, subset);
	REPORTER_ASSERT(reporter, readBack);
	}
	if (dst.getTexture() != NULL) {
	bool readBack = dst.pixelRef()->readPixels(&dstReadBack, subset);
	REPORTER_ASSERT(reporter, readBack);
	} else {
	// If dst is not a texture, do a copy instead, to the same config as srcReadBack.
	bool copy = dst.copyTo(&dstReadBack, srcReadBack.config());
	REPORTER_ASSERT(reporter, copy);
	}

	SkAutoLockPixels srcLock(srcReadBack);
	SkAutoLockPixels dstLock(dstReadBack);
	REPORTER_ASSERT(reporter, srcReadBack.readyToDraw() && dstReadBack.readyToDraw());

	const char* srcP = static_cast<const char*>(srcReadBack.getAddr(0, 0));
	const char* dstP = static_cast<const char*>(dstReadBack.getAddr(0, 0));
	REPORTER_ASSERT(reporter, srcP != dstP);

	REPORTER_ASSERT(reporter, !memcmp(srcP, dstP, srcReadBack.getSize()));
	} else {
	REPORTER_ASSERT(reporter, src.getGenerationID() != dst.getGenerationID());
	}

	// If the copy used a subset, test the pixel offset calculation functions.
	if (subset != NULL) {
	TestSubsetHelpers(reporter, dst);
	}
	} else {
	// dst should be unchanged from its initial state
	REPORTER_ASSERT(reporter, dst.config() == SkBitmap::kNo_Config);
	REPORTER_ASSERT(reporter, dst.width() == 0);
	REPORTER_ASSERT(reporter, dst.height() == 0);
	}

	}

	// Stripped down version of TestBitmapCopy that checks basic fields (width, height, config, genID)
	// to ensure that they were copied properly.
	static void TestGpuBitmapCopy(skiatest::Reporter* reporter, GrContext* grContext) {
	#ifdef SK_BUILD_FOR_ANDROID // https://code.google.com/p/skia/issues/detail?id=753
	return;
	#endif
	if (NULL == grContext) {
	return;
	}
	static const Pair gPairs[] = {
	{ SkBitmap::kNo_Config, "000" },
	{ SkBitmap::kARGB_4444_Config, "011" },
	{ SkBitmap::kARGB_8888_Config, "011" },
	};

	const int W = 20;
	const int H = 33;

	for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
	SkBitmap src, dst;

	SkGpuDevice* device = SkNEW_ARGS(SkGpuDevice, (grContext, gPairs[i].fConfig, W, H));
	SkAutoUnref aur(device);
	src = device->accessBitmap(false);
	device->clear(SK_ColorWHITE);

	// Draw something different to the same portion of the bitmap that we will extract as a
	// subset, so that comparing the pixels of the subset will be meaningful.
	SkIRect subsetRect = SkIRect::MakeLTRB(W/2, H/2, W, H);
	SkCanvas drawingCanvas(device);
	SkPaint paint;
	paint.setColor(SK_ColorRED);
	drawingCanvas.drawRect(SkRect::MakeFromIRect(subsetRect), paint);

	// Extract a subset. If this succeeds we will test copying the subset.
	SkBitmap subset;
	const bool extracted = src.extractSubset(&subset, subsetRect);
	if (extracted) {
	TestSubsetHelpers(reporter, subset);
	}

	for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
	dst.reset();
	bool success = src.deepCopyTo(&dst, gPairs[j].fConfig);
	bool expected = gPairs[i].fValid[j] != '0';
	if (success != expected) {
	SkString str;
	str.printf("SkBitmap::deepCopyTo from %s to %s. expected %s returned %s",
	gConfigName[i], gConfigName[j], boolStr(expected),
	boolStr(success));
	reporter->reportFailed(str);
	}

	bool canSucceed = src.canCopyTo(gPairs[j].fConfig);
	if (success != canSucceed) {
	SkString str;
	str.printf("SkBitmap::deepCopyTo from %s to %s returned %s,"
	"but canCopyTo returned %s",
	gConfigName[i], gConfigName[j], boolStr(success),
	boolStr(canSucceed));
	reporter->reportFailed(str);
	}

	TestIndividualCopy(reporter, gPairs[j].fConfig, success, src, dst);

	// Test copying the subset bitmap, using both copyTo and deepCopyTo.
	if (extracted) {
	SkBitmap subsetCopy;
	success = subset.copyTo(&subsetCopy, gPairs[j].fConfig);
	REPORTER_ASSERT(reporter, success == expected);
	REPORTER_ASSERT(reporter, success == canSucceed);
	TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, false,
	&subsetRect);

	// Reset the bitmap so that a failed copyTo will leave it in the expected state.
	subsetCopy.reset();
	success = subset.deepCopyTo(&subsetCopy, gPairs[j].fConfig);
	REPORTER_ASSERT(reporter, success == expected);
	REPORTER_ASSERT(reporter, success == canSucceed);
	TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, true,
	&subsetRect);
	}
	} // for (size_t j = ...
	} // for (size_t i = ...
	}

	#include "TestClassDef.h"
	DEFINE_GPUTESTCLASS("GpuBitmapCopy", TestGpuBitmapCopyClass, TestGpuBitmapCopy)

	#endif