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++; } } } } } } }