From c74ef795c7282681616decc36a9a81cd1b1b6ec7 Mon Sep 17 00:00:00 2001 From: marha Date: Wed, 27 Feb 2013 10:45:05 +0100 Subject: libX11 mesa pixman xkeyboard-config xkeyboard-config commit 9993f996e75232385b19cc5078f7fecde6b399b9 libX11 commit b687440c28c7da6ee0ae44514d20248db5161606 pixman commit 2156fb51b353867d5a18b734690ca551f74d4fb1 mesa commit f987d23b28491bd7b0552bd9daffa53a8e073c71 --- mesalib/src/mesa/drivers/common/driverfuncs.c | 1 + mesalib/src/mesa/drivers/common/meta.c | 17 +- mesalib/src/mesa/main/context.c | 1 - mesalib/src/mesa/main/dd.h | 4 +- mesalib/src/mesa/main/eval.c | 11 +- mesalib/src/mesa/main/eval.h | 4 +- mesalib/src/mesa/main/extensions.c | 1 + mesalib/src/mesa/main/fbobject.c | 53 ++ mesalib/src/mesa/main/fbobject.h | 4 + mesalib/src/mesa/main/points.c | 3 +- mesalib/src/mesa/main/teximage.c | 6 + mesalib/src/mesa/main/texparam.c | 6 + mesalib/src/mesa/main/texstore.c | 47 +- mesalib/src/mesa/main/texstore.h | 11 + mesalib/src/mesa/main/vtxfmt.c | 10 +- .../src/mesa/state_tracker/st_atom_rasterizer.c | 33 +- mesalib/src/mesa/state_tracker/st_cb_bitmap.c | 13 +- mesalib/src/mesa/state_tracker/st_cb_blit.c | 16 - mesalib/src/mesa/state_tracker/st_cb_blit.h | 7 - .../src/mesa/state_tracker/st_cb_bufferobjects.c | 2 +- mesalib/src/mesa/state_tracker/st_cb_flush.c | 1 - mesalib/src/mesa/state_tracker/st_cb_texture.c | 678 ++++++++++++--------- mesalib/src/mesa/state_tracker/st_context.c | 2 - mesalib/src/mesa/state_tracker/st_context.h | 2 - mesalib/src/mesa/state_tracker/st_draw.c | 2 +- mesalib/src/mesa/state_tracker/st_program.c | 2 +- 26 files changed, 558 insertions(+), 379 deletions(-) (limited to 'mesalib/src/mesa') diff --git a/mesalib/src/mesa/drivers/common/driverfuncs.c b/mesalib/src/mesa/drivers/common/driverfuncs.c index aab61e1a4..43c9de97f 100644 --- a/mesalib/src/mesa/drivers/common/driverfuncs.c +++ b/mesalib/src/mesa/drivers/common/driverfuncs.c @@ -174,6 +174,7 @@ _mesa_init_driver_functions(struct dd_function_table *driver) driver->ValidateFramebuffer = _mesa_validate_framebuffer; driver->BlitFramebuffer = _swrast_BlitFramebuffer; + driver->DiscardFramebuffer = NULL; _mesa_init_texture_barrier_functions(driver); diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c index 4e32b5066..29a209ede 100644 --- a/mesalib/src/mesa/drivers/common/meta.c +++ b/mesalib/src/mesa/drivers/common/meta.c @@ -1910,6 +1910,14 @@ _mesa_meta_BlitFramebuffer(struct gl_context *ctx, GLuint *tmp = malloc(srcW * srcH * sizeof(GLuint)); if (tmp) { + + newTex = alloc_texture(depthTex, srcW, srcH, GL_DEPTH_COMPONENT); + _mesa_ReadPixels(srcX, srcY, srcW, srcH, GL_DEPTH_COMPONENT, + GL_UNSIGNED_INT, tmp); + setup_drawpix_texture(ctx, depthTex, newTex, GL_DEPTH_COMPONENT, + srcW, srcH, GL_DEPTH_COMPONENT, + GL_UNSIGNED_INT, tmp); + /* texcoords (after texture allocation!) */ { verts[0].s = 0.0F; @@ -1928,15 +1936,6 @@ _mesa_meta_BlitFramebuffer(struct gl_context *ctx, if (!blit->DepthFP) init_blit_depth_pixels(ctx); - /* maybe change tex format here */ - newTex = alloc_texture(depthTex, srcW, srcH, GL_DEPTH_COMPONENT); - - _mesa_ReadPixels(srcX, srcY, srcW, srcH, - GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp); - - setup_drawpix_texture(ctx, depthTex, newTex, GL_DEPTH_COMPONENT, srcW, srcH, - GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp); - _mesa_BindProgramARB(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP); _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE); _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c index e5ed97f00..02acfc2aa 100644 --- a/mesalib/src/mesa/main/context.c +++ b/mesalib/src/mesa/main/context.c @@ -1073,7 +1073,6 @@ _mesa_initialize_context(struct gl_context *ctx, case API_OPENGLES2: ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE; ctx->VertexProgram._MaintainTnlProgram = GL_TRUE; - ctx->Point.PointSprite = GL_TRUE; /* always on for ES 2.x */ break; } diff --git a/mesalib/src/mesa/main/dd.h b/mesalib/src/mesa/main/dd.h index 9a75fd954..9c818ccd8 100644 --- a/mesalib/src/mesa/main/dd.h +++ b/mesalib/src/mesa/main/dd.h @@ -604,7 +604,7 @@ struct dd_function_table { /*@}*/ /** - * \name Functions for GL_EXT_framebuffer_{object,blit}. + * \name Functions for GL_EXT_framebuffer_{object,blit,discard}. */ /*@{*/ struct gl_framebuffer * (*NewFramebuffer)(struct gl_context *ctx, GLuint name); @@ -628,6 +628,8 @@ struct dd_function_table { GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + void (*DiscardFramebuffer)(struct gl_context *ctx, + GLenum target, GLsizei numAttachments, const GLenum *attachments); /** * \name Query objects diff --git a/mesalib/src/mesa/main/eval.c b/mesalib/src/mesa/main/eval.c index 44b57929e..b3c284175 100644 --- a/mesalib/src/mesa/main/eval.c +++ b/mesalib/src/mesa/main/eval.c @@ -824,7 +824,8 @@ _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2, void _mesa_install_eval_vtxfmt(struct _glapi_table *disp, - const GLvertexformat *vfmt) + const GLvertexformat *vfmt, + bool beginend) { SET_EvalCoord1f(disp, vfmt->EvalCoord1f); SET_EvalCoord1fv(disp, vfmt->EvalCoord1fv); @@ -833,8 +834,12 @@ _mesa_install_eval_vtxfmt(struct _glapi_table *disp, SET_EvalPoint1(disp, vfmt->EvalPoint1); SET_EvalPoint2(disp, vfmt->EvalPoint2); - SET_EvalMesh1(disp, vfmt->EvalMesh1); - SET_EvalMesh2(disp, vfmt->EvalMesh2); + /* glEvalMesh1 and glEvalMesh2 are not allowed between glBegin and glEnd. + */ + if (!beginend) { + SET_EvalMesh1(disp, vfmt->EvalMesh1); + SET_EvalMesh2(disp, vfmt->EvalMesh2); + } } diff --git a/mesalib/src/mesa/main/eval.h b/mesalib/src/mesa/main/eval.h index 1b6c704ca..cfde53fd6 100644 --- a/mesalib/src/mesa/main/eval.h +++ b/mesalib/src/mesa/main/eval.h @@ -39,6 +39,7 @@ #include "main/mfeatures.h" #include "main/mtypes.h" +#include #define _MESA_INIT_EVAL_VTXFMT(vfmt, impl) \ @@ -76,7 +77,8 @@ extern GLfloat *_mesa_copy_map_points2d(GLenum target, extern void _mesa_install_eval_vtxfmt(struct _glapi_table *disp, - const GLvertexformat *vfmt); + const GLvertexformat *vfmt, + bool beginend); extern void _mesa_init_eval( struct gl_context *ctx ); extern void _mesa_free_eval_data( struct gl_context *ctx ); diff --git a/mesalib/src/mesa/main/extensions.c b/mesalib/src/mesa/main/extensions.c index 04435e0c9..e90a29680 100644 --- a/mesalib/src/mesa/main/extensions.c +++ b/mesalib/src/mesa/main/extensions.c @@ -168,6 +168,7 @@ static const struct extension extension_table[] = { { "GL_EXT_blend_color", o(EXT_blend_color), GLL, 1995 }, { "GL_EXT_blend_equation_separate", o(EXT_blend_equation_separate), GL, 2003 }, { "GL_EXT_blend_func_separate", o(EXT_blend_func_separate), GLL, 1999 }, + { "GL_EXT_discard_framebuffer", o(EXT_framebuffer_object), ES1 | ES2, 2009 }, { "GL_EXT_blend_minmax", o(EXT_blend_minmax), GLL | ES1 | ES2, 1995 }, { "GL_EXT_blend_subtract", o(dummy_true), GLL, 1995 }, { "GL_EXT_clip_volume_hint", o(EXT_clip_volume_hint), GL, 1996 }, diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c index 257f839a6..89bc57509 100644 --- a/mesalib/src/mesa/main/fbobject.c +++ b/mesalib/src/mesa/main/fbobject.c @@ -3310,3 +3310,56 @@ _mesa_InvalidateFramebuffer(GLenum target, GLsizei numAttachments, 0, 0, MAX_VIEWPORT_WIDTH, MAX_VIEWPORT_HEIGHT, "glInvalidateFramebuffer"); } + +void GLAPIENTRY +_mesa_DiscardFramebufferEXT(GLenum target, GLsizei numAttachments, + const GLenum *attachments) +{ + struct gl_framebuffer *fb; + GLint i; + + GET_CURRENT_CONTEXT(ctx); + + fb = get_framebuffer_target(ctx, target); + if (!fb) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glDiscardFramebufferEXT(target %s)", + _mesa_lookup_enum_by_nr(target)); + return; + } + + if (numAttachments < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glDiscardFramebufferEXT(numAttachments < 0)"); + return; + } + + for (i = 0; i < numAttachments; i++) { + switch (attachments[i]) { + case GL_COLOR: + case GL_DEPTH: + case GL_STENCIL: + if (_mesa_is_user_fbo(fb)) + goto invalid_enum; + break; + case GL_COLOR_ATTACHMENT0: + case GL_DEPTH_ATTACHMENT: + case GL_STENCIL_ATTACHMENT: + if (_mesa_is_winsys_fbo(fb)) + goto invalid_enum; + break; + default: + goto invalid_enum; + } + } + + if (ctx->Driver.DiscardFramebuffer) + ctx->Driver.DiscardFramebuffer(ctx, target, numAttachments, attachments); + + return; + +invalid_enum: + _mesa_error(ctx, GL_INVALID_ENUM, + "glDiscardFramebufferEXT(attachment %s)", + _mesa_lookup_enum_by_nr(attachments[i])); +} diff --git a/mesalib/src/mesa/main/fbobject.h b/mesalib/src/mesa/main/fbobject.h index 9207f59c7..ec8b0afe4 100644 --- a/mesalib/src/mesa/main/fbobject.h +++ b/mesalib/src/mesa/main/fbobject.h @@ -214,4 +214,8 @@ extern void GLAPIENTRY _mesa_InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments); +extern void GLAPIENTRY +_mesa_DiscardFramebufferEXT(GLenum target, GLsizei numAttachments, + const GLenum *attachments); + #endif /* FBOBJECT_H */ diff --git a/mesalib/src/mesa/main/points.c b/mesalib/src/mesa/main/points.c index 17786408c..c925d4cfd 100644 --- a/mesalib/src/mesa/main/points.c +++ b/mesalib/src/mesa/main/points.c @@ -253,7 +253,8 @@ _mesa_init_point(struct gl_context *ctx) * In a core context, the state will default to true, and the setters and * getters are disabled. */ - ctx->Point.PointSprite = (ctx->API == API_OPENGL_CORE); + ctx->Point.PointSprite = (ctx->API == API_OPENGL_CORE || + ctx->API == API_OPENGLES2); ctx->Point.SpriteRMode = GL_ZERO; /* GL_NV_point_sprite (only!) */ ctx->Point.SpriteOrigin = GL_UPPER_LEFT; /* GL_ARB_point_sprite */ diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c index f8f517a42..f0de0fb49 100644 --- a/mesalib/src/mesa/main/teximage.c +++ b/mesalib/src/mesa/main/teximage.c @@ -3187,6 +3187,12 @@ _mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image) return; } + if (!image) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glEGLImageTargetTexture2D(image=%p)", image); + return; + } + if (ctx->NewState & _NEW_PIXEL) _mesa_update_state(ctx); diff --git a/mesalib/src/mesa/main/texparam.c b/mesalib/src/mesa/main/texparam.c index b6afd35ba..bc66bb36d 100644 --- a/mesalib/src/mesa/main/texparam.c +++ b/mesalib/src/mesa/main/texparam.c @@ -1444,6 +1444,12 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params ) *params = (GLfloat) obj->Immutable; break; + case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES: + if (!_mesa_is_gles(ctx) || !ctx->Extensions.OES_EGL_image_external) + goto invalid_pname; + *params = obj->RequiredTextureImageUnits; + break; + case GL_TEXTURE_SRGB_DECODE_EXT: if (!ctx->Extensions.EXT_texture_sRGB_decode) goto invalid_pname; diff --git a/mesalib/src/mesa/main/texstore.c b/mesalib/src/mesa/main/texstore.c index 9281aa9ea..0e13d8903 100644 --- a/mesalib/src/mesa/main/texstore.c +++ b/mesalib/src/mesa/main/texstore.c @@ -3791,24 +3791,22 @@ _mesa_get_texstore_func(gl_format format) } -static GLboolean -_mesa_texstore_memcpy(TEXSTORE_PARAMS) +GLboolean +_mesa_texstore_needs_transfer_ops(struct gl_context *ctx, + GLenum baseInternalFormat, + gl_format dstFormat) { GLenum dstType; - /* There are different restrictions depending on the base format... */ + /* There are different rules depending on the base format. */ switch (baseInternalFormat) { case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL: - /* Depth scale and bias are not allowed. */ - if (ctx->Pixel.DepthScale != 1.0f || - ctx->Pixel.DepthBias != 0.0f) { - return GL_FALSE; - } - break; + return ctx->Pixel.DepthScale != 1.0f || + ctx->Pixel.DepthBias != 0.0f; case GL_STENCIL_INDEX: - break; + return GL_FALSE; default: /* Color formats. @@ -3817,10 +3815,20 @@ _mesa_texstore_memcpy(TEXSTORE_PARAMS) */ dstType = _mesa_get_format_datatype(dstFormat); - if (dstType != GL_INT && dstType != GL_UNSIGNED_INT && - ctx->_ImageTransferState) { - return GL_FALSE; - } + return dstType != GL_INT && dstType != GL_UNSIGNED_INT && + ctx->_ImageTransferState; + } +} + + +GLboolean +_mesa_texstore_can_use_memcpy(struct gl_context *ctx, + GLenum baseInternalFormat, gl_format dstFormat, + GLenum srcFormat, GLenum srcType, + const struct gl_pixelstore_attrib *srcPacking) +{ + if (_mesa_texstore_needs_transfer_ops(ctx, baseInternalFormat, dstFormat)) { + return GL_FALSE; } /* The base internal format and the base Mesa format must match. */ @@ -3834,6 +3842,17 @@ _mesa_texstore_memcpy(TEXSTORE_PARAMS) return GL_FALSE; } + return GL_TRUE; +} + +static GLboolean +_mesa_texstore_memcpy(TEXSTORE_PARAMS) +{ + if (!_mesa_texstore_can_use_memcpy(ctx, baseInternalFormat, dstFormat, + srcFormat, srcType, srcPacking)) { + return GL_FALSE; + } + memcpy_texture(ctx, dims, dstFormat, dstRowStride, dstSlices, diff --git a/mesalib/src/mesa/main/texstore.h b/mesalib/src/mesa/main/texstore.h index 7af532d65..75f24bd45 100644 --- a/mesalib/src/mesa/main/texstore.h +++ b/mesalib/src/mesa/main/texstore.h @@ -69,6 +69,17 @@ extern GLboolean _mesa_texstore(TEXSTORE_PARAMS); +extern GLboolean +_mesa_texstore_needs_transfer_ops(struct gl_context *ctx, + GLenum baseInternalFormat, + gl_format dstFormat); + +extern GLboolean +_mesa_texstore_can_use_memcpy(struct gl_context *ctx, + GLenum baseInternalFormat, gl_format dstFormat, + GLenum srcFormat, GLenum srcType, + const struct gl_pixelstore_attrib *srcPacking); + extern GLubyte * _mesa_make_temp_ubyte_image(struct gl_context *ctx, GLuint dims, diff --git a/mesalib/src/mesa/main/vtxfmt.c b/mesalib/src/mesa/main/vtxfmt.c index 347d07d57..8669c4007 100644 --- a/mesalib/src/mesa/main/vtxfmt.c +++ b/mesalib/src/mesa/main/vtxfmt.c @@ -45,7 +45,7 @@ */ static void install_vtxfmt(struct gl_context *ctx, struct _glapi_table *tab, - const GLvertexformat *vfmt) + const GLvertexformat *vfmt, bool beginend) { assert(ctx->Version > 0); @@ -62,7 +62,7 @@ install_vtxfmt(struct gl_context *ctx, struct _glapi_table *tab, } if (ctx->API == API_OPENGL_COMPAT) { - _mesa_install_eval_vtxfmt(tab, vfmt); + _mesa_install_eval_vtxfmt(tab, vfmt, beginend); } if (ctx->API != API_OPENGL_CORE && ctx->API != API_OPENGLES2) { @@ -251,9 +251,9 @@ install_vtxfmt(struct gl_context *ctx, struct _glapi_table *tab, void _mesa_install_exec_vtxfmt(struct gl_context *ctx, const GLvertexformat *vfmt) { - install_vtxfmt( ctx, ctx->Exec, vfmt ); + install_vtxfmt(ctx, ctx->Exec, vfmt, false); if (ctx->BeginEnd) - install_vtxfmt( ctx, ctx->BeginEnd, vfmt ); + install_vtxfmt(ctx, ctx->BeginEnd, vfmt, true); } @@ -265,7 +265,7 @@ void _mesa_install_save_vtxfmt(struct gl_context *ctx, const GLvertexformat *vfmt) { if (_mesa_is_desktop_gl(ctx)) - install_vtxfmt( ctx, ctx->Save, vfmt ); + install_vtxfmt(ctx, ctx->Save, vfmt, false); } diff --git a/mesalib/src/mesa/state_tracker/st_atom_rasterizer.c b/mesalib/src/mesa/state_tracker/st_atom_rasterizer.c index f20df9e9b..0e2a152cd 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_rasterizer.c +++ b/mesalib/src/mesa/state_tracker/st_atom_rasterizer.c @@ -84,11 +84,10 @@ static void update_raster_state( struct st_context *st ) /* _NEW_LIGHT */ - if (ctx->Light.ShadeModel == GL_FLAT) - raster->flatshade = 1; - - if (ctx->Light.ProvokingVertex == GL_FIRST_VERTEX_CONVENTION_EXT) - raster->flatshade_first = 1; + raster->flatshade = ctx->Light.ShadeModel == GL_FLAT; + + raster->flatshade_first = ctx->Light.ProvokingVertex == + GL_FIRST_VERTEX_CONVENTION_EXT; /* _NEW_LIGHT | _NEW_PROGRAM */ raster->light_twoside = ctx->VertexProgram._TwoSideEnabled; @@ -135,32 +134,23 @@ static void update_raster_state( struct st_context *st ) /* _NEW_POLYGON */ - if (ctx->Polygon.OffsetUnits != 0.0 || - ctx->Polygon.OffsetFactor != 0.0) { - raster->offset_point = ctx->Polygon.OffsetPoint; - raster->offset_line = ctx->Polygon.OffsetLine; - raster->offset_tri = ctx->Polygon.OffsetFill; - } - if (ctx->Polygon.OffsetPoint || ctx->Polygon.OffsetLine || ctx->Polygon.OffsetFill) { + raster->offset_point = ctx->Polygon.OffsetPoint; + raster->offset_line = ctx->Polygon.OffsetLine; + raster->offset_tri = ctx->Polygon.OffsetFill; raster->offset_units = ctx->Polygon.OffsetUnits; raster->offset_scale = ctx->Polygon.OffsetFactor; } - if (ctx->Polygon.SmoothFlag) - raster->poly_smooth = 1; - - if (ctx->Polygon.StippleFlag) - raster->poly_stipple_enable = 1; + raster->poly_smooth = ctx->Polygon.SmoothFlag; + raster->poly_stipple_enable = ctx->Polygon.StippleFlag; /* _NEW_POINT */ raster->point_size = ctx->Point.Size; - - if (!ctx->Point.PointSprite && ctx->Point.SmoothFlag) - raster->point_smooth = 1; + raster->point_smooth = !ctx->Point.PointSprite && ctx->Point.SmoothFlag; /* _NEW_POINT | _NEW_PROGRAM */ @@ -233,8 +223,7 @@ static void update_raster_state( struct st_context *st ) raster->multisample = ctx->Multisample._Enabled; /* _NEW_SCISSOR */ - if (ctx->Scissor.Enabled) - raster->scissor = 1; + raster->scissor = ctx->Scissor.Enabled; /* _NEW_FRAG_CLAMP */ raster->clamp_fragment_color = !st->clamp_frag_color_in_shader && diff --git a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c index 63dbdb29b..36fffe90d 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c +++ b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c @@ -675,11 +675,12 @@ st_flush_bitmap_cache(struct st_context *st) * \return GL_TRUE for success, GL_FALSE if bitmap is too large, etc. */ static GLboolean -accum_bitmap(struct st_context *st, +accum_bitmap(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei height, const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap ) { + struct st_context *st = ctx->st; struct bitmap_cache *cache = st->bitmap.cache; int px = -999, py = -999; const GLfloat z = st->ctx->Current.RasterPos[2]; @@ -729,9 +730,17 @@ accum_bitmap(struct st_context *st, /* create the transfer if needed */ create_cache_trans(st); + /* PBO source... */ + bitmap = _mesa_map_pbo_source(ctx, unpack, bitmap); + if (!bitmap) { + return FALSE; + } + unpack_bitmap(st, px, py, width, height, unpack, bitmap, cache->buffer, BITMAP_CACHE_WIDTH); + _mesa_unmap_pbo_source(ctx, unpack); + return GL_TRUE; /* accumulated */ } @@ -764,7 +773,7 @@ st_Bitmap(struct gl_context *ctx, GLint x, GLint y, semantic_indexes); } - if (UseBitmapCache && accum_bitmap(st, x, y, width, height, unpack, bitmap)) + if (UseBitmapCache && accum_bitmap(ctx, x, y, width, height, unpack, bitmap)) return; pt = make_bitmap_texture(ctx, width, height, unpack, bitmap); diff --git a/mesalib/src/mesa/state_tracker/st_cb_blit.c b/mesalib/src/mesa/state_tracker/st_cb_blit.c index ddef2707a..c463e3b04 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_blit.c +++ b/mesalib/src/mesa/state_tracker/st_cb_blit.c @@ -41,25 +41,9 @@ #include "st_cb_fbo.h" #include "st_atom.h" -#include "util/u_blit.h" #include "util/u_format.h" -void -st_init_blit(struct st_context *st) -{ - st->blit = util_create_blit(st->pipe, st->cso_context); -} - - -void -st_destroy_blit(struct st_context *st) -{ - util_destroy_blit(st->blit); - st->blit = NULL; -} - - static void st_BlitFramebuffer(struct gl_context *ctx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, diff --git a/mesalib/src/mesa/state_tracker/st_cb_blit.h b/mesalib/src/mesa/state_tracker/st_cb_blit.h index eb6089e47..159c6ca8d 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_blit.h +++ b/mesalib/src/mesa/state_tracker/st_cb_blit.h @@ -35,13 +35,6 @@ struct dd_function_table; struct st_context; - -extern void -st_init_blit(struct st_context *st); - -extern void -st_destroy_blit(struct st_context *st); - extern void st_init_blit_functions(struct dd_function_table *functions); diff --git a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c index d5167352c..8ff32c842 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c +++ b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c @@ -232,7 +232,7 @@ st_bufferobj_data(struct gl_context *ctx, pipe_resource_reference( &st_obj->buffer, NULL ); if (ST_DEBUG & DEBUG_BUFFER) { - debug_printf("Create buffer size %lu bind 0x%x\n", size, bind); + debug_printf("Create buffer size %td bind 0x%x\n", size, bind); } if (size != 0) { diff --git a/mesalib/src/mesa/state_tracker/st_cb_flush.c b/mesalib/src/mesa/state_tracker/st_cb_flush.c index b569e3b3c..b11004718 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_flush.c +++ b/mesalib/src/mesa/state_tracker/st_cb_flush.c @@ -44,7 +44,6 @@ #include "pipe/p_defines.h" #include "pipe/p_screen.h" #include "util/u_gen_mipmap.h" -#include "util/u_blit.h" /** Check if we have a front color buffer and if it's been drawn to. */ diff --git a/mesalib/src/mesa/state_tracker/st_cb_texture.c b/mesalib/src/mesa/state_tracker/st_cb_texture.c index f8ff024db..c922a3164 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_texture.c +++ b/mesalib/src/mesa/state_tracker/st_cb_texture.c @@ -59,7 +59,6 @@ #include "util/u_inlines.h" #include "pipe/p_shader_tokens.h" #include "util/u_tile.h" -#include "util/u_blit.h" #include "util/u_format.h" #include "util/u_surface.h" #include "util/u_sampler.h" @@ -539,14 +538,274 @@ prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage, } +/** + * Return a writemask for the gallium blit. The parameters can be base + * formats or "format" from glDrawPixels/glTexImage/glGetTexImage. + */ +static unsigned +get_blit_mask(GLenum srcFormat, GLenum dstFormat) +{ + switch (dstFormat) { + case GL_DEPTH_STENCIL: + switch (srcFormat) { + case GL_DEPTH_STENCIL: + return PIPE_MASK_ZS; + case GL_DEPTH_COMPONENT: + return PIPE_MASK_Z; + case GL_STENCIL_INDEX: + return PIPE_MASK_S; + default: + assert(0); + return 0; + } + + case GL_DEPTH_COMPONENT: + switch (srcFormat) { + case GL_DEPTH_STENCIL: + case GL_DEPTH_COMPONENT: + return PIPE_MASK_Z; + default: + assert(0); + return 0; + } + + case GL_STENCIL_INDEX: + switch (srcFormat) { + case GL_STENCIL_INDEX: + return PIPE_MASK_S; + default: + assert(0); + return 0; + } + + default: + return PIPE_MASK_RGBA; + } +} + + +static void +st_TexSubImage(struct gl_context *ctx, GLuint dims, + struct gl_texture_image *texImage, + GLint xoffset, GLint yoffset, GLint zoffset, + GLint width, GLint height, GLint depth, + GLenum format, GLenum type, const void *pixels, + const struct gl_pixelstore_attrib *unpack) +{ + struct st_context *st = st_context(ctx); + struct st_texture_image *stImage = st_texture_image(texImage); + struct st_texture_object *stObj = st_texture_object(texImage->TexObject); + struct pipe_context *pipe = st->pipe; + struct pipe_screen *screen = pipe->screen; + struct pipe_resource *dst = stImage->pt; + struct pipe_resource *src = NULL; + struct pipe_resource src_templ; + struct pipe_transfer *transfer; + struct pipe_blit_info blit; + enum pipe_format src_format, dst_format; + gl_format mesa_src_format; + GLenum gl_target = texImage->TexObject->Target; + unsigned bind; + GLubyte *map; + + if (!dst) { + goto fallback; + } + + /* XXX Fallback for depth-stencil formats due to an incomplete stencil + * blit implementation in some drivers. */ + if (format == GL_DEPTH_STENCIL) { + goto fallback; + } + + /* If the base internal format and the texture format don't match, + * we can't use blit-based TexSubImage. */ + if (texImage->_BaseFormat != + _mesa_get_format_base_format(texImage->TexFormat)) { + goto fallback; + } + + /* See if the texture format already matches the format and type, + * in which case the memcpy-based fast path will likely be used and + * we don't have to blit. */ + if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, + type, unpack->SwapBytes)) { + goto fallback; + } + + if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) + bind = PIPE_BIND_DEPTH_STENCIL; + else + bind = PIPE_BIND_RENDER_TARGET; + + /* See if the destination format is supported. + * For luminance and intensity, only the red channel is stored there. */ + dst_format = util_format_linear(dst->format); + dst_format = util_format_luminance_to_red(dst_format); + dst_format = util_format_intensity_to_red(dst_format); + + if (!dst_format || + !screen->is_format_supported(screen, dst_format, dst->target, + dst->nr_samples, bind)) { + goto fallback; + } + + /* Choose the source format. */ + src_format = st_choose_matching_format(screen, PIPE_BIND_SAMPLER_VIEW, + format, type, unpack->SwapBytes); + if (!src_format) { + goto fallback; + } + + mesa_src_format = st_pipe_format_to_mesa_format(src_format); + + /* There is no reason to do this if we cannot use memcpy for the temporary + * source texture at least. This also takes transfer ops into account, + * etc. */ + if (!_mesa_texstore_can_use_memcpy(ctx, + _mesa_get_format_base_format(mesa_src_format), + mesa_src_format, format, type, unpack)) { + goto fallback; + } + + /* TexSubImage only sets a single cubemap face. */ + if (gl_target == GL_TEXTURE_CUBE_MAP) { + gl_target = GL_TEXTURE_2D; + } + + /* Initialize the source texture description. */ + memset(&src_templ, 0, sizeof(src_templ)); + src_templ.target = gl_target_to_pipe(gl_target); + src_templ.format = src_format; + src_templ.bind = PIPE_BIND_SAMPLER_VIEW; + src_templ.usage = PIPE_USAGE_STAGING; + + st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, + &src_templ.width0, &src_templ.height0, + &src_templ.depth0, &src_templ.array_size); + + /* Check for NPOT texture support. */ + if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) && + (!util_is_power_of_two(src_templ.width0) || + !util_is_power_of_two(src_templ.height0) || + !util_is_power_of_two(src_templ.depth0))) { + goto fallback; + } + + /* Create the source texture. */ + src = screen->resource_create(screen, &src_templ); + if (!src) { + goto fallback; + } + + /* Map source pixels. */ + pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth, + format, type, pixels, unpack, + "glTexSubImage"); + if (!pixels) { + /* This is a GL error. */ + pipe_resource_reference(&src, NULL); + return; + } + + /* From now on, we need the gallium representation of dimensions. */ + if (gl_target == GL_TEXTURE_1D_ARRAY) { + depth = height; + height = 1; + } + + map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0, + width, height, depth, &transfer); + if (!map) { + _mesa_unmap_teximage_pbo(ctx, unpack); + pipe_resource_reference(&src, NULL); + goto fallback; + } + + /* Upload pixels (just memcpy). */ + { + const uint bytesPerRow = width * util_format_get_blocksize(src_format); + GLuint row, slice; + + for (slice = 0; slice < depth; slice++) { + if (gl_target == GL_TEXTURE_1D_ARRAY) { + /* 1D array textures. + * We need to convert gallium coords to GL coords. + */ + GLvoid *src = _mesa_image_address3d(unpack, pixels, + width, depth, format, + type, 0, slice, 0); + memcpy(map, src, bytesPerRow); + } + else { + ubyte *slice_map = map; + + for (row = 0; row < height; row++) { + GLvoid *src = _mesa_image_address3d(unpack, pixels, + width, height, format, + type, slice, row, 0); + memcpy(slice_map, src, bytesPerRow); + slice_map += transfer->stride; + } + } + map += transfer->layer_stride; + } + } + + pipe_transfer_unmap(pipe, transfer); + _mesa_unmap_teximage_pbo(ctx, unpack); + + /* Blit. */ + blit.src.resource = src; + blit.src.level = 0; + blit.src.format = src_format; + blit.dst.resource = dst; + blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level; + blit.dst.format = dst_format; + blit.src.box.x = blit.src.box.y = blit.src.box.z = 0; + blit.dst.box.x = xoffset; + blit.dst.box.y = yoffset; + blit.dst.box.z = zoffset + texImage->Face; + blit.src.box.width = blit.dst.box.width = width; + blit.src.box.height = blit.dst.box.height = height; + blit.src.box.depth = blit.dst.box.depth = depth; + blit.mask = get_blit_mask(format, texImage->_BaseFormat); + blit.filter = PIPE_TEX_FILTER_NEAREST; + blit.scissor_enable = FALSE; + + st->pipe->blit(st->pipe, &blit); + + pipe_resource_reference(&src, NULL); + return; + +fallback: + _mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset, + width, height, depth, format, type, pixels, + unpack); +} + static void st_TexImage(struct gl_context * ctx, GLuint dims, struct gl_texture_image *texImage, GLenum format, GLenum type, const void *pixels, const struct gl_pixelstore_attrib *unpack) { + assert(dims == 1 || dims == 2 || dims == 3); + prep_teximage(ctx, texImage, format, type); - _mesa_store_teximage(ctx, dims, texImage, format, type, pixels, unpack); + + if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0) + return; + + /* allocate storage for texture data */ + if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims); + return; + } + + st_TexSubImage(ctx, dims, texImage, 0, 0, 0, + texImage->Width, texImage->Height, texImage->Depth, + format, type, pixels, unpack); } @@ -584,9 +843,9 @@ st_GetTexImage(struct gl_context * ctx, struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; struct pipe_screen *screen = pipe->screen; - const GLuint width = texImage->Width; - const GLuint height = texImage->Height; - const GLuint depth = texImage->Depth; + GLuint width = texImage->Width; + GLuint height = texImage->Height; + GLuint depth = texImage->Depth; struct st_texture_image *stImage = st_texture_image(texImage); struct pipe_resource *src = st_texture_object(texImage->TexObject)->pt; struct pipe_resource *dst = NULL; @@ -718,6 +977,12 @@ st_GetTexImage(struct gl_context * ctx, goto fallback; } + /* From now on, we need the gallium representation of dimensions. */ + if (gl_target == GL_TEXTURE_1D_ARRAY) { + depth = height; + height = 1; + } + blit.src.resource = src; blit.src.level = texImage->Level; blit.src.format = src_format; @@ -731,7 +996,7 @@ st_GetTexImage(struct gl_context * ctx, blit.src.box.width = blit.dst.box.width = width; blit.src.box.height = blit.dst.box.height = height; blit.src.box.depth = blit.dst.box.depth = depth; - blit.mask = PIPE_MASK_RGBA; + blit.mask = get_blit_mask(texImage->_BaseFormat, format); blit.filter = PIPE_TEX_FILTER_NEAREST; blit.scissor_enable = FALSE; @@ -756,14 +1021,25 @@ st_GetTexImage(struct gl_context * ctx, GLuint row, slice; for (slice = 0; slice < depth; slice++) { - ubyte *slice_map = map; - - for (row = 0; row < height; row++) { + if (gl_target == GL_TEXTURE_1D_ARRAY) { + /* 1D array textures. + * We need to convert gallium coords to GL coords. + */ GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, - width, height, format, - type, slice, row, 0); - memcpy(dest, slice_map, bytesPerRow); - slice_map += tex_xfer->stride; + width, depth, format, + type, 0, slice, 0); + memcpy(dest, map, bytesPerRow); + } + else { + ubyte *slice_map = map; + + for (row = 0; row < height; row++) { + GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, + width, height, format, + type, slice, row, 0); + memcpy(dest, slice_map, bytesPerRow); + slice_map += tex_xfer->stride; + } } map += tex_xfer->layer_stride; } @@ -780,22 +1056,38 @@ st_GetTexImage(struct gl_context * ctx, goto end; } + if (ST_DEBUG & DEBUG_FALLBACK) + debug_printf("%s: fallback format translation\n", __FUNCTION__); + for (slice = 0; slice < depth; slice++) { - for (row = 0; row < height; row++) { - const GLbitfield transferOps = 0x0; /* bypassed for glGetTexImage() */ + if (gl_target == GL_TEXTURE_1D_ARRAY) { + /* 1D array textures. + * We need to convert gallium coords to GL coords. + */ GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, - width, height, format, - type, slice, row, 0); - - if (ST_DEBUG & DEBUG_FALLBACK) - debug_printf("%s: fallback format translation\n", __FUNCTION__); + width, depth, format, + type, 0, slice, 0); /* get float[4] rgba row from surface */ - pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1, + pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1, dst_format, rgba); _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format, - type, dest, &ctx->Pack, transferOps); + type, dest, &ctx->Pack, 0); + } + else { + for (row = 0; row < height; row++) { + GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, + width, height, format, + type, slice, row, 0); + + /* get float[4] rgba row from surface */ + pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1, + dst_format, rgba); + + _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba, format, + type, dest, &ctx->Pack, 0); + } } map += tex_xfer->layer_stride; } @@ -979,110 +1271,6 @@ fallback_copy_texsubimage(struct gl_context *ctx, } - -/** - * If the format of the src renderbuffer and the format of the dest - * texture are compatible (in terms of blitting), return a TGSI writemask - * to be used during the blit. - * If the src/dest are incompatible, return 0. - */ -static unsigned -compatible_src_dst_formats(struct gl_context *ctx, - const struct gl_renderbuffer *src, - const struct gl_texture_image *dst) -{ - /* Get logical base formats for the src and dest. - * That is, use the user-requested formats and not the actual, device- - * chosen formats. - * For example, the user may have requested an A8 texture but the - * driver may actually be using an RGBA texture format. When we - * copy/blit to that texture, we only want to copy the Alpha channel - * and not the RGB channels. - * - * Similarly, when the src FBO was created an RGB format may have been - * requested but the driver actually chose an RGBA format. In that case, - * we don't want to copy the undefined Alpha channel to the dest texture - * (it should be 1.0). - */ - const GLenum srcFormat = _mesa_base_fbo_format(ctx, src->InternalFormat); - const GLenum dstFormat = _mesa_base_tex_format(ctx, dst->InternalFormat); - - /** - * XXX when we have red-only and red/green renderbuffers we'll need - * to add more cases here (or implement a general-purpose routine that - * queries the existance of the R,G,B,A channels in the src and dest). - */ - if (srcFormat == dstFormat) { - /* This is the same as matching_base_formats, which should - * always pass, as it did previously. - */ - return TGSI_WRITEMASK_XYZW; - } - else if (srcFormat == GL_RGB && dstFormat == GL_RGBA) { - /* Make sure that A in the dest is 1. The actual src format - * may be RGBA and have undefined A values. - */ - return TGSI_WRITEMASK_XYZ; - } - else if (srcFormat == GL_RGBA && dstFormat == GL_RGB) { - /* Make sure that A in the dest is 1. The actual dst format - * may be RGBA and will need A=1 to provide proper alpha values - * when sampled later. - */ - return TGSI_WRITEMASK_XYZ; - } - else { - if (ST_DEBUG & DEBUG_FALLBACK) - debug_printf("%s failed for src %s, dst %s\n", - __FUNCTION__, - _mesa_lookup_enum_by_nr(srcFormat), - _mesa_lookup_enum_by_nr(dstFormat)); - - /* Otherwise fail. - */ - return 0; - } -} - - -/** - * Do pipe->blit. Return FALSE if the blitting is unsupported - * for the given formats. - */ -static GLboolean -st_pipe_blit(struct pipe_context *pipe, struct pipe_blit_info *blit) -{ - struct pipe_screen *screen = pipe->screen; - unsigned dst_usage; - - if (util_format_is_depth_or_stencil(blit->dst.format)) { - dst_usage = PIPE_BIND_DEPTH_STENCIL; - } - else { - dst_usage = PIPE_BIND_RENDER_TARGET; - } - - /* try resource_copy_region in case the format is not supported - * for rendering */ - if (util_try_blit_via_copy_region(pipe, blit)) { - return GL_TRUE; /* done */ - } - - /* check the format support */ - if (!screen->is_format_supported(screen, blit->src.format, - PIPE_TEXTURE_2D, 0, - PIPE_BIND_SAMPLER_VIEW) || - !screen->is_format_supported(screen, blit->dst.format, - PIPE_TEXTURE_2D, 0, - dst_usage)) { - return GL_FALSE; - } - - pipe->blit(pipe, blit); - return GL_TRUE; -} - - /** * Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible. * Note that the region to copy has already been clipped so we know we @@ -1098,36 +1286,57 @@ st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, GLint srcX, GLint srcY, GLsizei width, GLsizei height) { struct st_texture_image *stImage = st_texture_image(texImage); - const GLenum texBaseFormat = texImage->_BaseFormat; + struct st_texture_object *stObj = st_texture_object(texImage->TexObject); struct st_renderbuffer *strb = st_renderbuffer(rb); struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; struct pipe_screen *screen = pipe->screen; - enum pipe_format dest_format, src_format; - GLuint color_writemask; - struct pipe_surface *dest_surface = NULL; + struct pipe_blit_info blit; + enum pipe_format dst_format; GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP); - struct pipe_surface surf_tmpl; - unsigned dst_usage; - unsigned blit_mask; + unsigned bind; GLint srcY0, srcY1, yStep; - /* make sure finalize_textures has been called? - */ - if (0) st_validate_state(st); - if (!strb || !strb->surface || !stImage->pt) { debug_printf("%s: null strb or stImage\n", __FUNCTION__); return; } - assert(strb); - assert(strb->surface); - assert(stImage->pt); + if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat, + texImage->TexFormat)) { + goto fallback; + } + + /* The base internal format must match the mesa format, so make sure + * e.g. an RGB internal format is really allocated as RGB and not as RGBA. + */ + if (texImage->_BaseFormat != + _mesa_get_format_base_format(texImage->TexFormat) || + rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) { + goto fallback; + } + + /* Choose the destination format to match the TexImage behavior. */ + dst_format = util_format_linear(stImage->pt->format); + dst_format = util_format_luminance_to_red(dst_format); + dst_format = util_format_intensity_to_red(dst_format); - src_format = strb->surface->format; - dest_format = stImage->pt->format; + /* See if the destination format is supported. */ + if (texImage->_BaseFormat == GL_DEPTH_STENCIL || + texImage->_BaseFormat == GL_DEPTH_COMPONENT) { + bind = PIPE_BIND_DEPTH_STENCIL; + } + else { + bind = PIPE_BIND_RENDER_TARGET; + } + if (!dst_format || + !screen->is_format_supported(screen, dst_format, stImage->pt->target, + stImage->pt->nr_samples, bind)) { + goto fallback; + } + + /* Y flipping for the main framebuffer. */ if (do_flip) { srcY1 = strb->Base.Height - srcY - height; srcY0 = srcY1 + height; @@ -1139,165 +1348,56 @@ st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, yStep = 1; } - if (ctx->_ImageTransferState) { - goto fallback; - } - - /* Compressed and subsampled textures aren't supported for blitting. */ - if (!util_format_is_plain(dest_format)) { - goto fallback; - } - - /* Set the blit writemask. */ - switch (texBaseFormat) { - case GL_DEPTH_STENCIL: - switch (strb->Base._BaseFormat) { - case GL_DEPTH_STENCIL: - blit_mask = PIPE_MASK_ZS; - break; - case GL_DEPTH_COMPONENT: - blit_mask = PIPE_MASK_Z; - break; - case GL_STENCIL_INDEX: - blit_mask = PIPE_MASK_S; - break; - default: - assert(0); - return; - } - dst_usage = PIPE_BIND_DEPTH_STENCIL; - break; - - case GL_DEPTH_COMPONENT: - blit_mask = PIPE_MASK_Z; - dst_usage = PIPE_BIND_DEPTH_STENCIL; - break; - - default: - /* Colorbuffers. - * - * Determine if the src framebuffer and dest texture have the same - * base format. We need this to detect a case such as the framebuffer - * being GL_RGBA but the texture being GL_RGB. If the actual hardware - * texture format stores RGBA we need to set A=1 (overriding the - * framebuffer's alpha values). - * - * XXX util_blit_pixels doesn't support MSAA resolve, so always use - * pipe->blit - */ - if (texBaseFormat == strb->Base._BaseFormat || - strb->texture->nr_samples > 1) { - blit_mask = PIPE_MASK_RGBA; - } - else { - blit_mask = 0; - } - dst_usage = PIPE_BIND_RENDER_TARGET; - } - /* Blit the texture. * This supports flipping, format conversions, and downsampling. */ - if (blit_mask) { - /* If stImage->pt is an independent image (not a pointer into a full - * mipmap) stImage->pt.last_level will be zero and we need to use that - * as the dest level. - */ - unsigned dstLevel = MIN2(stImage->base.Level, stImage->pt->last_level); - struct pipe_blit_info blit; - - memset(&blit, 0, sizeof(blit)); - blit.src.resource = strb->texture; - blit.src.format = src_format; - blit.src.level = strb->surface->u.tex.level; - blit.src.box.x = srcX; - blit.src.box.y = srcY0; - blit.src.box.z = strb->surface->u.tex.first_layer; - blit.src.box.width = width; - blit.src.box.height = srcY1 - srcY0; - blit.src.box.depth = 1; - blit.dst.resource = stImage->pt; - blit.dst.format = dest_format; - blit.dst.level = dstLevel; - blit.dst.box.x = destX; - blit.dst.box.y = destY; - blit.dst.box.z = stImage->base.Face + destZ; - blit.dst.box.width = width; - blit.dst.box.height = height; - blit.dst.box.depth = 1; - blit.mask = blit_mask; - blit.filter = PIPE_TEX_FILTER_NEAREST; - - /* 1D array textures need special treatment. - * Blit rows from the source to layers in the destination. */ - if (texImage->TexObject->Target == GL_TEXTURE_1D_ARRAY) { - int y, layer; - - for (y = srcY0, layer = 0; layer < height; y += yStep, layer++) { - blit.src.box.y = y; - blit.src.box.height = 1; - blit.dst.box.y = 0; - blit.dst.box.height = 1; - blit.dst.box.z = destY + layer; - - if (!st_pipe_blit(pipe, &blit)) { - goto fallback; - } - } - } - else { - /* All the other texture targets. */ - if (!st_pipe_blit(pipe, &blit)) { - goto fallback; - } - } - return; - } + memset(&blit, 0, sizeof(blit)); + blit.src.resource = strb->texture; + blit.src.format = util_format_linear(strb->surface->format); + blit.src.level = strb->surface->u.tex.level; + blit.src.box.x = srcX; + blit.src.box.y = srcY0; + blit.src.box.z = strb->surface->u.tex.first_layer; + blit.src.box.width = width; + blit.src.box.height = srcY1 - srcY0; + blit.src.box.depth = 1; + blit.dst.resource = stImage->pt; + blit.dst.format = dst_format; + blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level; + blit.dst.box.x = destX; + blit.dst.box.y = destY; + blit.dst.box.z = stImage->base.Face + destZ; + blit.dst.box.width = width; + blit.dst.box.height = height; + blit.dst.box.depth = 1; + blit.mask = get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat); + blit.filter = PIPE_TEX_FILTER_NEAREST; - /* try u_blit */ + /* 1D array textures need special treatment. + * Blit rows from the source to layers in the destination. */ if (texImage->TexObject->Target == GL_TEXTURE_1D_ARRAY) { - /* u_blit cannot copy 1D array textures as required by CopyTexSubImage */ - goto fallback; - } + int y, layer; - color_writemask = compatible_src_dst_formats(ctx, &strb->Base, texImage); + for (y = srcY0, layer = 0; layer < height; y += yStep, layer++) { + blit.src.box.y = y; + blit.src.box.height = 1; + blit.dst.box.y = 0; + blit.dst.box.height = 1; + blit.dst.box.z = destY + layer; - if (!color_writemask || - !screen->is_format_supported(screen, src_format, - PIPE_TEXTURE_2D, 0, - PIPE_BIND_SAMPLER_VIEW) || - !screen->is_format_supported(screen, dest_format, - PIPE_TEXTURE_2D, 0, - dst_usage)) { - goto fallback; + pipe->blit(pipe, &blit); + } + } + else { + /* All the other texture targets. */ + pipe->blit(pipe, &blit); } - - memset(&surf_tmpl, 0, sizeof(surf_tmpl)); - surf_tmpl.format = util_format_linear(stImage->pt->format); - surf_tmpl.u.tex.level = stImage->base.Level; - surf_tmpl.u.tex.first_layer = stImage->base.Face + destZ; - surf_tmpl.u.tex.last_layer = stImage->base.Face + destZ; - - dest_surface = pipe->create_surface(pipe, stImage->pt, - &surf_tmpl); - util_blit_pixels(st->blit, - strb->texture, - strb->surface->u.tex.level, - srcX, srcY0, - srcX + width, srcY1, - strb->surface->u.tex.first_layer, - dest_surface, - destX, destY, - destX + width, destY + height, - 0.0, PIPE_TEX_MIPFILTER_NEAREST, - color_writemask, 0); - pipe_surface_reference(&dest_surface, NULL); return; fallback: /* software fallback */ fallback_copy_texsubimage(ctx, - strb, stImage, texBaseFormat, + strb, stImage, texImage->_BaseFormat, destX, destY, destZ, srcX, srcY, width, height); } @@ -1635,7 +1735,7 @@ st_init_texture_functions(struct dd_function_table *functions) functions->ChooseTextureFormat = st_ChooseTextureFormat; functions->QuerySamplesForFormat = st_QuerySamplesForFormat; functions->TexImage = st_TexImage; - functions->TexSubImage = _mesa_store_texsubimage; + functions->TexSubImage = st_TexSubImage; functions->CompressedTexSubImage = _mesa_store_compressed_texsubimage; functions->CopyTexSubImage = st_CopyTexSubImage; functions->GenerateMipmap = st_generate_mipmap; diff --git a/mesalib/src/mesa/state_tracker/st_context.c b/mesalib/src/mesa/state_tracker/st_context.c index 676fc069d..f9a584ba0 100644 --- a/mesalib/src/mesa/state_tracker/st_context.c +++ b/mesalib/src/mesa/state_tracker/st_context.c @@ -146,7 +146,6 @@ st_create_context_priv( struct gl_context *ctx, struct pipe_context *pipe, st_init_clear(st); st_init_draw( st ); st_init_generate_mipmap(st); - st_init_blit(st); if(pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES)) st->internal_target = PIPE_TEXTURE_2D; @@ -242,7 +241,6 @@ static void st_destroy_context_priv( struct st_context *st ) st_destroy_atoms( st ); st_destroy_draw( st ); st_destroy_generate_mipmap(st); - st_destroy_blit(st); st_destroy_clear(st); st_destroy_bitmap(st); st_destroy_drawpix(st); diff --git a/mesalib/src/mesa/state_tracker/st_context.h b/mesalib/src/mesa/state_tracker/st_context.h index 726c64d04..a7b6cb535 100644 --- a/mesalib/src/mesa/state_tracker/st_context.h +++ b/mesalib/src/mesa/state_tracker/st_context.h @@ -34,7 +34,6 @@ #include "main/fbobject.h" struct bitmap_cache; -struct blit_state; struct dd_function_table; struct draw_context; struct draw_stage; @@ -182,7 +181,6 @@ struct st_context enum pipe_texture_target internal_target; struct gen_mipmap_state *gen_mipmap; - struct blit_state *blit; struct cso_context *cso_context; diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c index de62264a1..bff8d9b31 100644 --- a/mesalib/src/mesa/state_tracker/st_draw.c +++ b/mesalib/src/mesa/state_tracker/st_draw.c @@ -283,7 +283,7 @@ st_draw_vbo(struct gl_context *ctx, /* don't trim, restarts might be inside index list */ cso_draw_vbo(st->cso_context, &info); } - else if (u_trim_pipe_prim(info.mode, &info.count)) + else if (u_trim_pipe_prim(prims[i].mode, &info.count)) cso_draw_vbo(st->cso_context, &info); } diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c index a9111b523..f56f7cb1c 100644 --- a/mesalib/src/mesa/state_tracker/st_program.c +++ b/mesalib/src/mesa/state_tracker/st_program.c @@ -1142,7 +1142,7 @@ st_print_shaders(struct gl_context *ctx) static void destroy_program_variants(struct st_context *st, struct gl_program *program) { - if (!program) + if (!program || program == &_mesa_DummyProgram) return; switch (program->Target) { -- cgit v1.2.3