TestUtils.h File Reference

#include "include/core/SkColor.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrTypes.h"
#include "src/gpu/SkBackingFit.h"
#include "src/gpu/ganesh/GrImageInfo.h"
#include "src/gpu/ganesh/GrPixmap.h"
#include <cstdint>
#include <functional>
#include <memory>

Go to the source code of this file.

Namespaces
namespace	skiatest
namespace	skgpu
namespace	skgpu::ganesh

Typedefs
typedef uint32_t	GrColor
using	ComparePixmapsErrorReporter = void(int x, int y, const float diffs[4])

Functions
void	TestReadPixels (skiatest::Reporter *, GrDirectContext *, skgpu::ganesh::SurfaceContext *, uint32_t expectedPixelValues[], const char *testName)
void	TestWritePixels (skiatest::Reporter *, GrDirectContext *, skgpu::ganesh::SurfaceContext *, bool expectedToWork, const char *testName)
void	TestCopyFromSurface (skiatest::Reporter *, GrDirectContext *, sk_sp< GrSurfaceProxy > proxy, GrSurfaceOrigin origin, GrColorType colorType, uint32_t expectedPixelValues[], const char *testName)
bool	ComparePixels (const GrCPixmap &a, const GrCPixmap &b, const float tolRGBA[4], std::function< ComparePixmapsErrorReporter > &error)
bool	CheckSolidPixels (const SkColor4f &col, const SkPixmap &pixmap, const float tolRGBA[4], std::function< ComparePixmapsErrorReporter > &error)
void	CheckSingleThreadedProxyRefs (skiatest::Reporter *reporter, GrSurfaceProxy *proxy, int32_t expectedProxyRefs, int32_t expectedBackingRefs)
std::unique_ptr< skgpu::ganesh::SurfaceContext >	CreateSurfaceContext (GrRecordingContext *, const GrImageInfo &, SkBackingFit=SkBackingFit::kExact, GrSurfaceOrigin=kTopLeft_GrSurfaceOrigin, GrRenderable=GrRenderable::kNo, int sampleCount=1, skgpu::Mipmapped=skgpu::Mipmapped::kNo, GrProtected=GrProtected::kNo, skgpu::Budgeted=skgpu::Budgeted::kYes)

Typedef Documentation

ComparePixmapsErrorReporter

using ComparePixmapsErrorReporter = void(int x, int y, const float diffs[4])

Used by compare_pixels.

Definition at line 61 of file TestUtils.h.

GrColor

typedef uint32_t GrColor

Definition at line 33 of file TestUtils.h.

Function Documentation

CheckSingleThreadedProxyRefs()

void CheckSingleThreadedProxyRefs	(	skiatest::Reporter *	reporter,
		GrSurfaceProxy *	proxy,
		int32_t	expectedProxyRefs,
		int32_t	expectedBackingRefs
	)

Checks the ref cnt on a proxy and its backing store. This is only valid if the proxy and the resource are both used on a single thread.

Definition at line 231 of file TestUtils.cpp.

                                                               {
    int32_t actualBackingRefs = proxy->testingOnly_getBackingRefCnt();
 
    REPORTER_ASSERT(reporter, proxy->refCntGreaterThan(expectedProxyRefs - 1) &&
                              !proxy->refCntGreaterThan(expectedProxyRefs));
    REPORTER_ASSERT(reporter, actualBackingRefs == expectedBackingRefs);
}

CheckSolidPixels()

bool CheckSolidPixels	(	const SkColor4f &	col,
		const SkPixmap &	pixmap,
		const float	tolRGBA[4],
		std::function< ComparePixmapsErrorReporter > &	error
	)

Convenience version that checks that 'pixmap' is a solid field of 'col'

Definition at line 191 of file TestUtils.cpp.

                                                                       {
    size_t floatBpp = GrColorTypeBytesPerPixel(GrColorType::kRGBA_F32);
 
    // First convert 'col' to be compatible with 'pixmap'
    GrPixmap colorPixmap;
    {
        sk_sp<SkColorSpace> srcCS = SkColorSpace::MakeSRGBLinear();
        GrImageInfo srcInfo(GrColorType::kRGBA_F32,
                            kUnpremul_SkAlphaType,
                            std::move(srcCS),
                            {1, 1});
        GrCPixmap srcPixmap(srcInfo, col.vec(), floatBpp);
        GrImageInfo dstInfo =
                srcInfo.makeAlphaType(pixmap.alphaType()).makeColorSpace(pixmap.refColorSpace());
        colorPixmap = GrPixmap::Allocate(dstInfo);
        SkAssertResult(GrConvertPixels(colorPixmap, srcPixmap));
    }
 
    size_t floatRowBytes = floatBpp * pixmap.width();
    std::unique_ptr<char[]> floatB(new char[floatRowBytes * pixmap.height()]);
    // Then convert 'pixmap' to RGBA_F32
    GrPixmap f32Pixmap = GrPixmap::Allocate(pixmap.info().makeColorType(kRGBA_F32_SkColorType));
    SkAssertResult(GrConvertPixels(f32Pixmap, pixmap));
 
    for (int y = 0; y < f32Pixmap.height(); ++y) {
        for (int x = 0; x < f32Pixmap.width(); ++x) {
            auto rgbaA = SkTAddOffset<const float>(f32Pixmap.addr(),
                                                   f32Pixmap.rowBytes()*y + floatBpp*x);
            auto rgbaB = static_cast<const float*>(colorPixmap.addr());
            if (!compare_colors(x, y, rgbaA, rgbaB, tolRGBA, error)) {
                return false;
            }
        }
    }
    return true;
}

ComparePixels()

bool ComparePixels	(	const GrCPixmap &	a,
		const GrCPixmap &	b,
		const float	tolRGBA[4],
		std::function< ComparePixmapsErrorReporter > &	error
	)

Compares pixels pointed to by 'a' to pixels pointed to by 'b'.

If the pixmaps have different dimensions error is called with negative coordinate values and zero diffs and no comparisons are made.

Before comparison pixels are converted to a common color type, alpha type, and color space. The color type is always 32 bit float. The alpha type is premul if one of the pixmaps is premul and the other is unpremul. The color space is linear sRGB if the pixmaps have different colorspaces, otherwise their common color space is used.

'tolRGBA' expresses the allowed difference between pixels in the comparison space per channel. If pixel components differ more than by 'tolRGBA' in absolute value in any channel then 'error' is called with the coordinate and difference in the comparison space (B - A).

The function quits after a single error is reported and returns false if 'error' was called and true otherwise.

Definition at line 142 of file TestUtils.cpp.

                                                                    {
    if (a.dimensions() != b.dimensions()) {
        static constexpr float kEmptyDiffs[4] = {};
        error(-1, -1, kEmptyDiffs);
        return false;
    }
 
    SkAlphaType floatAlphaType = a.alphaType();
    // If one is premul and the other is unpremul we do the comparison in premul space.
    if ((a.alphaType() == kPremul_SkAlphaType   || b.alphaType() == kPremul_SkAlphaType) &&
        (a.alphaType() == kUnpremul_SkAlphaType || b.alphaType() == kUnpremul_SkAlphaType)) {
        floatAlphaType = kPremul_SkAlphaType;
    }
    sk_sp<SkColorSpace> floatCS;
    if (SkColorSpace::Equals(a.colorSpace(), b.colorSpace())) {
        floatCS = a.refColorSpace();
    } else {
        floatCS = SkColorSpace::MakeSRGBLinear();
    }
    GrImageInfo floatInfo(GrColorType::kRGBA_F32,
                          floatAlphaType,
                          std::move(floatCS),
                          a.dimensions());
 
    GrPixmap floatA = GrPixmap::Allocate(floatInfo);
    GrPixmap floatB = GrPixmap::Allocate(floatInfo);
    SkAssertResult(GrConvertPixels(floatA, a));
    SkAssertResult(GrConvertPixels(floatB, b));
 
    SkASSERT(floatA.rowBytes() == floatB.rowBytes());
    auto at = [rb = floatA.rowBytes()](const void* base, int x, int y) {
        return SkTAddOffset<const float>(base, y*rb + x*sizeof(float)*4);
    };
 
    for (int y = 0; y < floatA.height(); ++y) {
        for (int x = 0; x < floatA.width(); ++x) {
            const float* rgbaA = at(floatA.addr(), x, y);
            const float* rgbaB = at(floatB.addr(), x, y);
            if (!compare_colors(x, y, rgbaA, rgbaB, tolRGBA, error)) {
                return false;
            }
        }
    }
    return true;
}

CreateSurfaceContext()

std::unique_ptr< skgpu::ganesh::SurfaceContext > CreateSurfaceContext	(	GrRecordingContext *	rContext,
		const GrImageInfo &	info,
		SkBackingFit	fit = SkBackingFit::kExact,
		GrSurfaceOrigin	origin = kTopLeft_GrSurfaceOrigin,
		GrRenderable	renderable = GrRenderable::kNo,
		int	sampleCount = 1,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		GrProtected	isProtected = GrProtected::kNo,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Definition at line 242 of file TestUtils.cpp.

                                                                                            {
    GrBackendFormat format = rContext->priv().caps()->getDefaultBackendFormat(info.colorType(),
                                                                              renderable);
    return rContext->priv().makeSC(info,
                                   format,
                                   /*label=*/{},
                                   fit,
                                   origin,
                                   renderable,
                                   sampleCount,
                                   mipmapped,
                                   isProtected,
                                   budgeted);
}

TestCopyFromSurface()

void TestCopyFromSurface	(	skiatest::Reporter *	reporter,
		GrDirectContext *	dContext,
		sk_sp< GrSurfaceProxy >	proxy,
		GrSurfaceOrigin	origin,
		GrColorType	colorType,
		uint32_t	expectedPixelValues[],
		const char *	testName
	)

Definition at line 98 of file TestUtils.cpp.

                                               {
    auto copy = GrSurfaceProxy::Copy(dContext,
                                     std::move(proxy),
                                     origin,
                                     skgpu::Mipmapped::kNo,
                                     SkBackingFit::kExact,
                                     skgpu::Budgeted::kYes,
                                     /*label=*/"CopyFromSurface_Test");
    SkASSERT(copy && copy->asTextureProxy());
    auto swizzle = dContext->priv().caps()->getReadSwizzle(copy->backendFormat(), colorType);
    GrSurfaceProxyView view(std::move(copy), origin, swizzle);
    auto dstContext = dContext->priv().makeSC(std::move(view),
                                              {colorType, kPremul_SkAlphaType, nullptr});
    SkASSERT(dstContext);
 
    TestReadPixels(reporter, dContext, dstContext.get(), expectedPixelValues, testName);
}

TestReadPixels()

void TestReadPixels	(	skiatest::Reporter *	reporter,
		GrDirectContext *	dContext,
		skgpu::ganesh::SurfaceContext *	srcContext,
		uint32_t	expectedPixelValues[],
		const char *	testName
	)

Definition at line 39 of file TestUtils.cpp.

                                          {
    int pixelCnt = srcContext->width() * srcContext->height();
    SkImageInfo ii = SkImageInfo::Make(srcContext->dimensions(),
                                       kRGBA_8888_SkColorType,
                                       kPremul_SkAlphaType);
    SkAutoPixmapStorage pm;
    pm.alloc(ii);
    pm.erase(SK_ColorTRANSPARENT);
 
    bool read = srcContext->readPixels(dContext, pm, {0, 0});
    if (!read) {
        ERRORF(reporter, "%s: Error reading from texture.", testName);
    }
 
    for (int i = 0; i < pixelCnt; ++i) {
        if (pm.addr32()[i] != expectedPixelValues[i]) {
            ERRORF(reporter, "%s: Error, pixel value %d should be 0x%08x, got 0x%08x.",
                   testName, i, expectedPixelValues[i], pm.addr32()[i]);
            break;
        }
    }
}

TestWritePixels()

void TestWritePixels	(	skiatest::Reporter *	reporter,
		GrDirectContext *	dContext,
		skgpu::ganesh::SurfaceContext *	dstContext,
		bool	expectedToWork,
		const char *	testName
	)

Definition at line 66 of file TestUtils.cpp.

                                           {
    SkImageInfo ii = SkImageInfo::Make(dstContext->dimensions(),
                                       kRGBA_8888_SkColorType,
                                       kPremul_SkAlphaType);
    SkAutoPixmapStorage pm;
    pm.alloc(ii);
    for (int y = 0; y < dstContext->height(); ++y) {
        for (int x = 0; x < dstContext->width(); ++x) {
            *pm.writable_addr32(x, y) = SkColorToPremulGrColor(SkColorSetARGB(2*y, x, y, x + y));
        }
    }
 
    bool write = dstContext->writePixels(dContext, pm, {0, 0});
    if (!write) {
        if (expectedToWork) {
            ERRORF(reporter, "%s: Error writing to texture.", testName);
        }
        return;
    }
 
    if (write && !expectedToWork) {
        ERRORF(reporter, "%s: writePixels succeeded when it wasn't supposed to.", testName);
        return;
    }
 
    TestReadPixels(reporter, dContext, dstContext, pm.writable_addr32(0, 0), testName);
}