int main( int /*argc*/, char** /*argv*/ )
{
check_texture("data/test_tga_ctc24.tga",
"data/test_tga_ctc24.tga.out");
check_texture("data/test_tga_ctc32.tga",
"data/test_tga_ctc32.tga.out");
check_texture("data/test_tga_utc24.tga",
"data/test_tga_utc24.tga.out");
check_texture("data/test_tga_utc32.tga",
"data/test_tga_utc32.tga.out");
return EXIT_SUCCESS;
}
Bool
NV10EXACheckComposite(int op, PicturePtr src, PicturePtr mask, PicturePtr dst)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(dst->pDrawable->pScreen);
NVPtr pNv = NVPTR(pScrn);
if (!check_pict_op(op)) {
print_fallback_info("pictop", op, src, mask, dst);
return FALSE;
}
if (!check_render_target(dst)) {
print_fallback_info("dst", op, src, mask, dst);
return FALSE;
}
if (!check_texture(pNv, src)) {
print_fallback_info("src", op, src, mask, dst);
return FALSE;
}
if (mask) {
if (!check_texture(pNv, mask)) {
print_fallback_info("mask", op, src,
mask, dst);
return FALSE;
}
if (effective_component_alpha(mask) &&
needs_src(op) && needs_src_alpha(op)) {
print_fallback_info("ca-mask", op, src,
mask, dst);
return FALSE;
}
}
print_fallback_info("Accelerating", op, src, mask, dst);
return TRUE;
}
Bool
NV10EXACheckComposite(int op, PicturePtr src, PicturePtr mask, PicturePtr dst)
{
if (!check_pict_op(op)) {
print_fallback_info("pictop", op, src, mask, dst);
return FALSE;
}
if (!check_render_target(dst)) {
print_fallback_info("dst", op, src, mask, dst);
return FALSE;
}
if (!check_texture(src)) {
print_fallback_info("src", op, src, mask, dst);
return FALSE;
}
if (mask) {
if (!check_texture(mask)) {
print_fallback_info("mask", op, src,
mask, dst);
return FALSE;
}
if (effective_component_alpha(mask) &&
needs_src(op) && needs_src_alpha(op)) {
print_fallback_info("ca-mask", op, src,
mask, dst);
return FALSE;
}
}
print_fallback_info("Accelerating", op, src, mask, dst);
return TRUE;
}
static enum piglit_result
run_test(struct texture_format *src_format, struct texture_format *dst_format)
{
bool pass = true, warn = false;
unsigned src_width, src_height, dst_width, dst_height;
unsigned src_level, dst_level;
GLuint texture[2];
glEnable(GL_TEXTURE_2D);
glGenTextures(2, texture);
src_width = TEX_SIZE * src_format->block_width;
src_height = TEX_SIZE * src_format->block_height;
glBindTexture(GL_TEXTURE_2D, texture[0]);
if (src_format->can_be_reinterpreted) {
src_level = DEFAULT_SRC_LEVEL;
glTexStorage2D(GL_TEXTURE_2D, src_level + 2,
src_format->internal_format,
src_width << src_level, src_height << src_level);
if (src_format->block_width != 1 ||
src_format->block_height != 1) {
/* Compressed */
glCompressedTexSubImage2D(GL_TEXTURE_2D, src_level,
0, 0,
src_width, src_height,
src_format->internal_format,
TEX_SIZE * TEX_SIZE * src_format->bytes,
src_data);
} else {
glTexSubImage2D(GL_TEXTURE_2D, src_level, 0, 0,
src_width, src_height, src_format->format,
src_format->data_type, src_data);
}
} else {
src_level = 0;
/* All non-reintepretable textures are uncompressed */
glTexImage2D(GL_TEXTURE_2D, 0, src_format->internal_format,
src_width, src_height, 0, src_format->format,
src_format->data_type, src_data);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pass &= piglit_check_gl_error(GL_NO_ERROR);
if (!pass)
goto cleanup;
warn |= !check_texture(texture[0], src_level, src_format, src_data);
dst_width = TEX_SIZE * dst_format->block_width;
dst_height = TEX_SIZE * dst_format->block_height;
glBindTexture(GL_TEXTURE_2D, texture[1]);
if (dst_format->can_be_reinterpreted) {
dst_level = DEFAULT_DST_LEVEL;
glTexStorage2D(GL_TEXTURE_2D, dst_level + 2,
dst_format->internal_format,
dst_width << dst_level, dst_height << dst_level);
if (dst_format->block_width != 1 ||
dst_format->block_height != 1) {
/* Compressed */
glCompressedTexSubImage2D(GL_TEXTURE_2D, dst_level,
0, 0,
dst_width, dst_height,
dst_format->internal_format,
TEX_SIZE * TEX_SIZE * dst_format->bytes,
dst_data);
} else {
glTexSubImage2D(GL_TEXTURE_2D, dst_level, 0, 0,
dst_width, dst_height, dst_format->format,
dst_format->data_type, dst_data);
}
} else {
dst_level = 0;
/* All non-reintepritable textures are uncompressed */
glTexImage2D(GL_TEXTURE_2D, 0, dst_format->internal_format,
dst_width, dst_height, 0, dst_format->format,
dst_format->data_type, dst_data);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pass &= piglit_check_gl_error(GL_NO_ERROR);
if (!pass)
goto cleanup;
warn |= !check_texture(texture[1], dst_level, dst_format, dst_data);
glCopyImageSubData(texture[0], GL_TEXTURE_2D, src_level,
src_width / 4, src_height / 4, 0,
texture[1], GL_TEXTURE_2D, dst_level,
dst_width / 4, dst_height / 4, 0,
src_width / 2, src_height / 2, 1);
pass &= piglit_check_gl_error(GL_NO_ERROR);
glCopyImageSubData(texture[1], GL_TEXTURE_2D, dst_level,
0, dst_height / 2, 0,
texture[1], GL_TEXTURE_2D, dst_level,
dst_width / 2, 0, 0,
dst_width / 2, dst_height / 2, 1);
pass &= piglit_check_gl_error(GL_NO_ERROR);
pass &= check_texture(texture[1], dst_level, dst_format, res_data);
cleanup:
glDeleteTextures(2, texture);
glDisable(GL_TEXTURE_2D);
return pass ? (warn ? PIGLIT_WARN : PIGLIT_PASS) : PIGLIT_FAIL;
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
GrProxyProvider* proxyProvider = ctxInfo.grContext()->priv().proxyProvider();
GrContext* context = ctxInfo.grContext();
GrResourceProvider* resourceProvider = context->priv().resourceProvider();
GrGpu* gpu = context->priv().getGpu();
const GrCaps& caps = *context->priv().caps();
static const int kWidthHeight = 100;
for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
for (auto colorType : { kAlpha_8_SkColorType, kRGBA_8888_SkColorType,
kRGBA_1010102_SkColorType }) {
// External on-screen render target.
// Tests wrapBackendRenderTarget with a GrBackendRenderTarget
// Our test-only function that creates a backend render target doesn't currently support
// sample counts :(.
if (ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType)) {
GrBackendRenderTarget backendRT = gpu->createTestingOnlyBackendRenderTarget(
kWidthHeight, kWidthHeight, SkColorTypeToGrColorType(colorType));
sk_sp<GrSurfaceProxy> sProxy(
proxyProvider->wrapBackendRenderTarget(backendRT, origin, nullptr,
nullptr));
check_surface(reporter, sProxy.get(), origin, kWidthHeight, kWidthHeight,
backendRT.pixelConfig(), SkBudgeted::kNo);
static constexpr int kExpectedNumSamples = 1;
check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
kExpectedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles());
gpu->deleteTestingOnlyBackendRenderTarget(backendRT);
}
for (auto numSamples : {1, 4}) {
GrPixelConfig config = SkColorType2GrPixelConfig(colorType);
SkASSERT(kUnknown_GrPixelConfig != config);
int supportedNumSamples = caps.getRenderTargetSampleCount(numSamples, config);
if (!supportedNumSamples) {
continue;
}
// Test wrapping FBO 0 (with made up properties). This tests sample count and the
// special case where FBO 0 doesn't support window rectangles.
if (GrBackendApi::kOpenGL == ctxInfo.backend()) {
GrGLFramebufferInfo fboInfo;
fboInfo.fFBOID = 0;
fboInfo.fFormat = GR_GL_RGBA8;
static constexpr int kStencilBits = 8;
GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples,
kStencilBits, fboInfo);
backendRT.setPixelConfig(config);
sk_sp<GrSurfaceProxy> sProxy(
proxyProvider->wrapBackendRenderTarget(backendRT, origin, nullptr,
nullptr));
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight,
backendRT.pixelConfig(), SkBudgeted::kNo);
check_rendertarget(reporter, caps, resourceProvider,
sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact, 0);
}
// Tests wrapBackendRenderTarget with a GrBackendTexture
{
GrBackendTexture backendTex =
context->createBackendTexture(kWidthHeight, kWidthHeight,
colorType,
GrMipMapped::kNo,
GrRenderable::kYes);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTextureAsRenderTarget(
backendTex, origin, supportedNumSamples);
if (!sProxy) {
context->deleteBackendTexture(backendTex);
continue; // This can fail on Mesa
}
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight,
backendTex.pixelConfig(), SkBudgeted::kNo);
check_rendertarget(reporter, caps, resourceProvider,
sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles());
context->deleteBackendTexture(backendTex);
}
// Tests wrapBackendTexture that is only renderable
{
GrBackendTexture backendTex =
context->createBackendTexture(kWidthHeight, kWidthHeight,
colorType,
GrMipMapped::kNo,
GrRenderable::kYes);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapRenderableBackendTexture(
backendTex, origin, supportedNumSamples, kBorrow_GrWrapOwnership,
GrWrapCacheable::kNo, nullptr, nullptr);
if (!sProxy) {
context->deleteBackendTexture(backendTex);
continue; // This can fail on Mesa
}
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight,
backendTex.pixelConfig(), SkBudgeted::kNo);
check_rendertarget(reporter, caps, resourceProvider,
sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles());
context->deleteBackendTexture(backendTex);
}
// Tests wrapBackendTexture that is only textureable
{
// Internal offscreen texture
GrBackendTexture backendTex =
context->createBackendTexture(kWidthHeight, kWidthHeight,
colorType,
GrMipMapped::kNo,
GrRenderable::kNo);
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTexture(
backendTex, origin, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
kRead_GrIOType);
if (!sProxy) {
context->deleteBackendTexture(backendTex);
continue;
}
check_surface(reporter, sProxy.get(), origin,
kWidthHeight, kWidthHeight,
backendTex.pixelConfig(), SkBudgeted::kNo);
check_texture(reporter, resourceProvider, sProxy->asTextureProxy(),
SkBackingFit::kExact);
context->deleteBackendTexture(backendTex);
}
}
}
}
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
GrProxyProvider* proxyProvider = ctxInfo.grContext()->priv().proxyProvider();
GrResourceProvider* resourceProvider = ctxInfo.grContext()->priv().resourceProvider();
const GrCaps& caps = *ctxInfo.grContext()->priv().caps();
int attempt = 0; // useful for debugging
for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
for (auto widthHeight : { 100, 128, 1048576 }) {
for (auto config : { kAlpha_8_GrPixelConfig, kRGB_565_GrPixelConfig,
kRGBA_8888_GrPixelConfig, kRGBA_1010102_GrPixelConfig,
kRGB_ETC1_GrPixelConfig }) {
for (auto fit : { SkBackingFit::kExact, SkBackingFit::kApprox }) {
for (auto budgeted : { SkBudgeted::kYes, SkBudgeted::kNo }) {
for (auto numSamples : {1, 4, 16, 128}) {
// We don't have recycling support for compressed textures
if (GrPixelConfigIsCompressed(config) && SkBackingFit::kApprox == fit) {
continue;
}
GrSurfaceDesc desc;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fWidth = widthHeight;
desc.fHeight = widthHeight;
desc.fConfig = config;
desc.fSampleCnt = numSamples;
GrSRGBEncoded srgbEncoded;
GrColorType colorType =
GrPixelConfigToColorTypeAndEncoding(config, &srgbEncoded);
const GrBackendFormat format =
caps.getBackendFormatFromGrColorType(colorType, srgbEncoded);
{
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = resourceProvider->createApproxTexture(
desc, GrResourceProvider::Flags::kNoPendingIO);
} else {
tex = resourceProvider->createTexture(
desc, budgeted, GrResourceProvider::Flags::kNoPendingIO);
}
sk_sp<GrTextureProxy> proxy =
proxyProvider->createProxy(format, desc, origin, fit,
budgeted);
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
// This forces the proxy to compute and cache its
// pre-instantiation size guess. Later, when it is actually
// instantiated, it checks that the instantiated size is <= to
// the pre-computation. If the proxy never computed its
// pre-instantiation size then the check is skipped.
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), origin,
widthHeight, widthHeight, config, budgeted);
int supportedSamples =
caps.getRenderTargetSampleCount(numSamples, config);
check_rendertarget(reporter, caps, resourceProvider,
proxy->asRenderTargetProxy(),
supportedSamples,
fit, caps.maxWindowRectangles());
}
}
desc.fFlags = kNone_GrSurfaceFlags;
{
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = resourceProvider->createApproxTexture(
desc, GrResourceProvider::Flags::kNoPendingIO);
} else {
tex = resourceProvider->createTexture(
desc, budgeted, GrResourceProvider::Flags::kNoPendingIO);
}
sk_sp<GrTextureProxy> proxy(
proxyProvider->createProxy(format, desc, origin, fit,
budgeted));
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
// This forces the proxy to compute and cache its
// pre-instantiation size guess. Later, when it is actually
// instantiated, it checks that the instantiated size is <= to
// the pre-computation. If the proxy never computed its
// pre-instantiation size then the check is skipped.
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), origin,
widthHeight, widthHeight, config, budgeted);
check_texture(reporter, resourceProvider,
proxy->asTextureProxy(), fit);
}
}
attempt++;
}
}
}
}
}
}
}
