fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-20 20:20:18 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge branch 'gallium-new-formats'

Browse source 
Conflicts:
	src/gallium/auxiliary/util/u_format.csv
	src/gallium/auxiliary/util/u_format_access.py
	src/gallium/auxiliary/util/u_format_pack.py
This commit is contained in:
Roland Scheidegger 2010-03-31 16:57:05 +02:00
commit d97f6963ae
53 changed files with 309 additions and 256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/gallium/auxiliary/gallivm/lp_bld_depth.c
View file

@ -495,8 +495,8 @@ lp_build_depth_stencil_test(LLVMBuilderRef builder,
assert(format_desc->block.height == 1); assert(format_desc->block.height == 1);
if (stencil[0].enabled) { if (stencil[0].enabled) {
assert(format_desc->format == PIPE_FORMAT_Z24S8_UNORM || assert(format_desc->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
format_desc->format == PIPE_FORMAT_S8Z24_UNORM); format_desc->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM);
} }
assert(z_swizzle < 4); assert(z_swizzle < 4);

36
src/gallium/auxiliary/util/u_format.csv
View file

@ -80,6 +80,7 @@ PIPE_FORMAT_L16_UNORM , plain, 1, 1, un16, , , , xxx1, r
PIPE_FORMAT_L8_SRGB , plain, 1, 1, un8 , , , , xxx1, srgb PIPE_FORMAT_L8_SRGB , plain, 1, 1, un8 , , , , xxx1, srgb
PIPE_FORMAT_L8A8_SRGB , plain, 1, 1, un8 , un8 , , , xxxy, srgb PIPE_FORMAT_L8A8_SRGB , plain, 1, 1, un8 , un8 , , , xxxy, srgb
PIPE_FORMAT_R8G8B8_SRGB , plain, 1, 1, un8 , un8 , un8 , , xyz1, srgb PIPE_FORMAT_R8G8B8_SRGB , plain, 1, 1, un8 , un8 , un8 , , xyz1, srgb
PIPE_FORMAT_R8G8B8A8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , xyzw, srgb
PIPE_FORMAT_A8B8G8R8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , wzyx, srgb PIPE_FORMAT_A8B8G8R8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , wzyx, srgb
PIPE_FORMAT_X8B8G8R8_SRGB , plain, 1, 1, x8 , un8 , un8 , un8 , wzy1, srgb PIPE_FORMAT_X8B8G8R8_SRGB , plain, 1, 1, x8 , un8 , un8 , un8 , wzy1, srgb
PIPE_FORMAT_B8G8R8A8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , zyxw, srgb PIPE_FORMAT_B8G8R8A8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , zyxw, srgb
@ -92,14 +93,15 @@ PIPE_FORMAT_R8SG8SB8UX8U_NORM , plain, 1, 1, sn8 , sn8 , un8 , x8 , xyz1, r
PIPE_FORMAT_R5SG5SB6U_NORM , plain, 1, 1, sn5 , sn5 , un6 , , xyz1, rgb PIPE_FORMAT_R5SG5SB6U_NORM , plain, 1, 1, sn5 , sn5 , un6 , , xyz1, rgb
# Depth-stencil formats # Depth-stencil formats
PIPE_FORMAT_S8_UNORM , plain, 1, 1, un8 , , , , _x__, zs PIPE_FORMAT_S8_USCALED , plain, 1, 1, u8 , , , , _x__, zs
PIPE_FORMAT_Z16_UNORM , plain, 1, 1, un16, , , , x___, zs PIPE_FORMAT_Z16_UNORM , plain, 1, 1, un16, , , , x___, zs
PIPE_FORMAT_Z32_UNORM , plain, 1, 1, un32, , , , x___, zs PIPE_FORMAT_Z32_UNORM , plain, 1, 1, un32, , , , x___, zs
PIPE_FORMAT_Z32_FLOAT , plain, 1, 1, f32 , , , , x___, zs PIPE_FORMAT_Z32_FLOAT , plain, 1, 1, f32 , , , , x___, zs
PIPE_FORMAT_Z24S8_UNORM , plain, 1, 1, un24, un8 , , , xy__, zs PIPE_FORMAT_Z24_UNORM_S8_USCALED , plain, 1, 1, un24, u8 , , , xy__, zs
PIPE_FORMAT_S8Z24_UNORM , plain, 1, 1, un8 , un24, , , yx__, zs PIPE_FORMAT_S8_USCALED_Z24_UNORM , plain, 1, 1, u8 , un24, , , yx__, zs
PIPE_FORMAT_Z24X8_UNORM , plain, 1, 1, un24, x8 , , , x___, zs PIPE_FORMAT_Z24X8_UNORM , plain, 1, 1, un24, x8 , , , x___, zs
PIPE_FORMAT_X8Z24_UNORM , plain, 1, 1, x8 , un24, , , y___, zs PIPE_FORMAT_X8Z24_UNORM , plain, 1, 1, x8 , un24, , , y___, zs
PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED , plain, 1, 1, f32, u8 , x24 , , xy__, zs
# YUV formats # YUV formats
# http://www.fourcc.org/yuv.php#UYVY # http://www.fourcc.org/yuv.php#UYVY
@ -108,6 +110,15 @@ PIPE_FORMAT_UYVY , subsampled, 2, 1, x32 , , , , xyz
# XXX: u_tile.c's ycbcr_get_tile_rgba actually interprets it as VYUY but the # XXX: u_tile.c's ycbcr_get_tile_rgba actually interprets it as VYUY but the
# intent should be to match D3DFMT_YUY2 # intent should be to match D3DFMT_YUY2
PIPE_FORMAT_YUYV , subsampled, 2, 1, x32 , , , , xyz1, yuv PIPE_FORMAT_YUYV , subsampled, 2, 1, x32 , , , , xyz1, yuv
# same subsampling but with rgb channels
PIPE_FORMAT_R8G8_B8G8_UNORM , subsampled, 2, 1, x32 , , , , xyz1, rgb
PIPE_FORMAT_G8R8_G8B8_UNORM , subsampled, 2, 1, x32 , , , , xyz1, rgb
# some special formats not fitting anywhere else
PIPE_FORMAT_R10G10B10A2_USCALED , plain, 1, 1, u10 , u10 , u10 , u2 , xyzw, rgb
PIPE_FORMAT_R11G11B10_FLOAT , plain, 1, 1, f11 , f11 , f10 , , xyz1, rgb
PIPE_FORMAT_R9G9B9E5_FLOAT , other, 1, 1, x32 , , , , xyz1, rgb
PIPE_FORMAT_R1_UNORM , other, 8, 1, x8 , , , , x001, rgb
# Compressed formats # Compressed formats
# - http://en.wikipedia.org/wiki/S3_Texture_Compression # - http://en.wikipedia.org/wiki/S3_Texture_Compression
@ -123,6 +134,11 @@ PIPE_FORMAT_DXT1_SRGBA , s3tc, 4, 4, x64 , , , , xyzw, sr
PIPE_FORMAT_DXT3_SRGBA , s3tc, 4, 4, x128, , , , xyzw, srgb PIPE_FORMAT_DXT3_SRGBA , s3tc, 4, 4, x128, , , , xyzw, srgb
PIPE_FORMAT_DXT5_SRGBA , s3tc, 4, 4, x128, , , , xyzw, srgb PIPE_FORMAT_DXT5_SRGBA , s3tc, 4, 4, x128, , , , xyzw, srgb
PIPE_FORMAT_RGTC1_UNORM , rgtc, 4, 4, x64, , , , x001, rgb
PIPE_FORMAT_RGTC1_SNORM , rgtc, 4, 4, x64, , , , x001, rgb
PIPE_FORMAT_RGTC2_UNORM , rgtc, 4, 4, x128, , , , xy01, rgb
PIPE_FORMAT_RGTC2_SNORM , rgtc, 4, 4, x128, , , , xy01, rgb
# Straightforward D3D10-like formats (also used for # Straightforward D3D10-like formats (also used for
# vertex buffer element description) # vertex buffer element description)
# #
@ -157,6 +173,10 @@ PIPE_FORMAT_R32_FIXED , plain, 1, 1, h32 , , , , x001, r
PIPE_FORMAT_R32G32_FIXED , plain, 1, 1, h32 , h32 , , , xy01, rgb PIPE_FORMAT_R32G32_FIXED , plain, 1, 1, h32 , h32 , , , xy01, rgb
PIPE_FORMAT_R32G32B32_FIXED , plain, 1, 1, h32 , h32 , h32 , , xyz1, rgb PIPE_FORMAT_R32G32B32_FIXED , plain, 1, 1, h32 , h32 , h32 , , xyz1, rgb
PIPE_FORMAT_R32G32B32A32_FIXED , plain, 1, 1, h32 , h32 , h32 , h32 , xyzw, rgb PIPE_FORMAT_R32G32B32A32_FIXED , plain, 1, 1, h32 , h32 , h32 , h32 , xyzw, rgb
PIPE_FORMAT_R16_FLOAT , plain, 1, 1, f16 , , , , x001, rgb
PIPE_FORMAT_R16G16_FLOAT , plain, 1, 1, f16 , f16 , , , xy01, rgb
PIPE_FORMAT_R16G16B16_FLOAT , plain, 1, 1, f16 , f16 , f16 , , xyz1, rgb
PIPE_FORMAT_R16G16B16A16_FLOAT , plain, 1, 1, f16 , f16 , f16 , f16 , xyzw, rgb
PIPE_FORMAT_R16_UNORM , plain, 1, 1, un16, , , , x001, rgb PIPE_FORMAT_R16_UNORM , plain, 1, 1, un16, , , , x001, rgb
PIPE_FORMAT_R16G16_UNORM , plain, 1, 1, un16, un16, , , xy01, rgb PIPE_FORMAT_R16G16_UNORM , plain, 1, 1, un16, un16, , , xy01, rgb
PIPE_FORMAT_R16G16B16_UNORM , plain, 1, 1, un16, un16, un16, , xyz1, rgb PIPE_FORMAT_R16G16B16_UNORM , plain, 1, 1, un16, un16, un16, , xyz1, rgb

Can't render this file because it contains an unexpected character in line 8 and column 3.

3
src/gallium/auxiliary/util/u_format_access.py
View file

@ -60,6 +60,9 @@ def is_format_supported(format):
channel = format.channels[i] channel = format.channels[i]
if channel.type not in (VOID, UNSIGNED, FLOAT): if channel.type not in (VOID, UNSIGNED, FLOAT):
return False return False
if channel.type == FLOAT:
if channel.size not in (32, 64) or format.is_mixed():
return False
# We can only read a color from a depth/stencil format if the depth channel is present # We can only read a color from a depth/stencil format if the depth channel is present
if format.colorspace == 'zs' and format.swizzles[0] == SWIZZLE_NONE: if format.colorspace == 'zs' and format.swizzles[0] == SWIZZLE_NONE:

12
src/gallium/auxiliary/util/u_format_pack.py
View file

@ -46,11 +46,11 @@ def generate_format_type(format):
'''Generate a structure that describes the format.''' '''Generate a structure that describes the format.'''
print 'union util_format_%s {' % format.short_name() print 'union util_format_%s {' % format.short_name()
if format.is_bitmask(): if format.is_bitmask() or format.short_name() == "r11g11b10_float":
print ' uint%u_t value;' % (format.block_size(),) print ' uint%u_t value;' % (format.block_size(),)
print ' struct {' print ' struct {'
for channel in format.channels: for channel in format.channels:
if format.is_bitmask() and not format.is_array(): if (format.is_bitmask() or format.is_mixed()) and not format.is_array() or format.short_name() == "r11g11b10_float":
if channel.type == VOID: if channel.type == VOID:
if channel.size: if channel.size:
print ' unsigned %s:%u;' % (channel.name, channel.size) print ' unsigned %s:%u;' % (channel.name, channel.size)
@ -58,6 +58,11 @@ def generate_format_type(format):
print ' unsigned %s:%u;' % (channel.name, channel.size) print ' unsigned %s:%u;' % (channel.name, channel.size)
elif channel.type == SIGNED: elif channel.type == SIGNED:
print ' int %s:%u;' % (channel.name, channel.size) print ' int %s:%u;' % (channel.name, channel.size)
elif channel.type == FLOAT:
if channel.size == 32:
print ' float %s;' % (channel.name)
else:
print ' unsigned %s:%u;' % (channel.name, channel.size)
else: else:
assert 0 assert 0
else: else:
@ -107,6 +112,9 @@ def is_format_supported(format):
channel = format.channels[i] channel = format.channels[i]
if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT): if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT):
return False return False
if channel.type == FLOAT:
if channel.size not in (32, 64):
return False
# We can only read a color from a depth/stencil format if the depth channel is present # We can only read a color from a depth/stencil format if the depth channel is present
if format.colorspace == 'zs' and format.swizzles[0] == SWIZZLE_NONE: if format.colorspace == 'zs' and format.swizzles[0] == SWIZZLE_NONE:

2
src/gallium/auxiliary/util/u_format_parse.py
View file

@ -142,6 +142,8 @@ class Format:
def is_mixed(self): def is_mixed(self):
ref_channel = self.channels[0] ref_channel = self.channels[0]
if ref_channel.type == VOID:
ref_channel = self.channels[1]
for channel in self.channels[1:]: for channel in self.channels[1:]:
if channel.type != VOID: if channel.type != VOID:
if channel.type != ref_channel.type: if channel.type != ref_channel.type:

12
src/gallium/auxiliary/util/u_pack_color.h
View file

@ -446,17 +446,17 @@ util_pack_z(enum pipe_format format, double z)
return (uint) (z * 0xffffffff); return (uint) (z * 0xffffffff);
case PIPE_FORMAT_Z32_FLOAT: case PIPE_FORMAT_Z32_FLOAT:
return (uint)z; return (uint)z;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
if (z == 1.0) if (z == 1.0)
return 0xffffff; return 0xffffff;
return (uint) (z * 0xffffff); return (uint) (z * 0xffffff);
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
if (z == 1.0) if (z == 1.0)
return 0xffffff00; return 0xffffff00;
return ((uint) (z * 0xffffff)) << 8; return ((uint) (z * 0xffffff)) << 8;
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
/* this case can get it via util_pack_z_stencil() */ /* this case can get it via util_pack_z_stencil() */
return 0; return 0;
default: default:
@ -477,13 +477,13 @@ util_pack_z_stencil(enum pipe_format format, double z, uint s)
unsigned packed = util_pack_z(format, z); unsigned packed = util_pack_z(format, z);
switch (format) { switch (format) {
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
packed |= s << 24; packed |= s << 24;
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
packed |= s; packed |= s;
break; break;
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
packed |= s; packed |= s;
break; break;
default: default:

20
src/gallium/auxiliary/util/u_tile.c
View file

@ -1036,7 +1036,7 @@ z32_get_tile_rgba(const unsigned *src,
} }
/*** PIPE_FORMAT_Z24S8_UNORM ***/ /*** PIPE_FORMAT_Z24_UNORM_S8_USCALED ***/
/** /**
* Return Z component as four float in [0,1]. Stencil part ignored. * Return Z component as four float in [0,1]. Stencil part ignored.
@ -1063,7 +1063,7 @@ s8z24_get_tile_rgba(const unsigned *src,
} }
/*** PIPE_FORMAT_S8Z24_UNORM ***/ /*** PIPE_FORMAT_S8_USCALED_Z24_UNORM ***/
/** /**
* Return Z component as four float in [0,1]. Stencil part ignored. * Return Z component as four float in [0,1]. Stencil part ignored.
@ -1271,11 +1271,11 @@ pipe_tile_raw_to_rgba(enum pipe_format format,
case PIPE_FORMAT_Z32_UNORM: case PIPE_FORMAT_Z32_UNORM:
z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride); z32_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride); s8z24_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride); z24s8_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
break; break;
@ -1468,11 +1468,11 @@ pipe_put_tile_rgba(struct pipe_context *pipe,
case PIPE_FORMAT_Z32_UNORM: case PIPE_FORMAT_Z32_UNORM:
/*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/ /*z32_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
/*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/ /*s8z24_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
/*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/ /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
break; break;
@ -1525,7 +1525,7 @@ pipe_get_tile_z(struct pipe_context *pipe,
} }
} }
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
{ {
const uint *ptrc const uint *ptrc
@ -1540,7 +1540,7 @@ pipe_get_tile_z(struct pipe_context *pipe,
} }
} }
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
{ {
const uint *ptrc const uint *ptrc
@ -1609,7 +1609,7 @@ pipe_put_tile_z(struct pipe_context *pipe,
} }
} }
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
{ {
uint *pDest = (uint *) (map + y * pt->stride + x*4); uint *pDest = (uint *) (map + y * pt->stride + x*4);
assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE); assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
@ -1636,7 +1636,7 @@ pipe_put_tile_z(struct pipe_context *pipe,
} }
} }
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
{ {
uint *pDest = (uint *) (map + y * pt->stride + x*4); uint *pDest = (uint *) (map + y * pt->stride + x*4);
assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE); assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);

2
src/gallium/docs/d3d11ddi.txt
View file

@ -138,7 +138,7 @@ ClearUnorderedAccessViewUint (D3D11 only)
- Gallium does not support unordered access views (views that can be written to arbitrarily from compute shaders) - Gallium does not support unordered access views (views that can be written to arbitrarily from compute shaders)
CreateBlendState (extended in D3D10.1) -> create_blend_state CreateBlendState (extended in D3D10.1) -> create_blend_state
# D3D10 does not support per-RT blending, only D3D10.1 does # D3D10 does not support per-RT blend modes (but per-RT blending), only D3D10.1 does
- Gallium lacks alpha-to-coverage - Gallium lacks alpha-to-coverage
+ Gallium supports logic ops + Gallium supports logic ops
+ Gallium supports dithering + Gallium supports dithering

4
src/gallium/docs/source/cso/rasterizer.rst
View file

@ -81,8 +81,8 @@ point_quad_rasterization
Determines if points should be rasterized as quads or points. Certain APIs, Determines if points should be rasterized as quads or points. Certain APIs,
like Direct3D, always use quad rasterization for points, regardless of like Direct3D, always use quad rasterization for points, regardless of
whether point sprites are enabled or not. If this state is enabled, point whether point sprites are enabled or not. If this state is enabled, point
smoothing and antialiasing are disabled, and sprite coordinates are not smoothing and antialiasing are disabled. If it is disabled, point sprite
generated. coordinates are not generated.
.. note:: .. note::

12
src/gallium/drivers/cell/ppu/cell_gen_fragment.c
View file

@ -1859,7 +1859,7 @@ gen_depth_stencil(struct cell_context *cell,
spe_comment(f, 0, "Fetch Z/stencil quad from tile"); spe_comment(f, 0, "Fetch Z/stencil quad from tile");
switch(zs_format) { switch(zs_format) {
case PIPE_FORMAT_Z24S8_UNORM: /* fall through */ case PIPE_FORMAT_Z24_UNORM_S8_USCALED: /* fall through */
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
/* prepare mask to extract Z vals from ZS vals */ /* prepare mask to extract Z vals from ZS vals */
spe_load_uint(f, zmask_reg, 0x00ffffff); spe_load_uint(f, zmask_reg, 0x00ffffff);
@ -1880,7 +1880,7 @@ gen_depth_stencil(struct cell_context *cell,
spe_rotmi(f, fbS_reg, fbZS_reg, -24); spe_rotmi(f, fbS_reg, fbZS_reg, -24);
break; break;
case PIPE_FORMAT_S8Z24_UNORM: /* fall through */ case PIPE_FORMAT_S8_USCALED_Z24_UNORM: /* fall through */
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
/* convert fragment Z from [0,1] to 32-bit ints */ /* convert fragment Z from [0,1] to 32-bit ints */
spe_cfltu(f, fragZ_reg, fragZ_reg, 32); spe_cfltu(f, fragZ_reg, fragZ_reg, 32);
@ -1969,12 +1969,12 @@ gen_depth_stencil(struct cell_context *cell,
* fbS_reg has four 8-bit Z values in bits [7..0]. * fbS_reg has four 8-bit Z values in bits [7..0].
*/ */
spe_comment(f, 0, "Store quad's depth/stencil values in tile"); spe_comment(f, 0, "Store quad's depth/stencil values in tile");
if (zs_format == PIPE_FORMAT_Z24S8_UNORM || if (zs_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
zs_format == PIPE_FORMAT_Z24X8_UNORM) { zs_format == PIPE_FORMAT_Z24X8_UNORM) {
spe_shli(f, fbS_reg, fbS_reg, 24); /* fbS = fbS << 24 */ spe_shli(f, fbS_reg, fbS_reg, 24); /* fbS = fbS << 24 */
spe_or(f, fbZS_reg, fbS_reg, fbZ_reg); /* fbZS = fbS | fbZ */ spe_or(f, fbZS_reg, fbS_reg, fbZ_reg); /* fbZS = fbS | fbZ */
} }
else if (zs_format == PIPE_FORMAT_S8Z24_UNORM || else if (zs_format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
zs_format == PIPE_FORMAT_X8Z24_UNORM) { zs_format == PIPE_FORMAT_X8Z24_UNORM) {
spe_shli(f, fbZ_reg, fbZ_reg, 8); /* fbZ = fbZ << 8 */ spe_shli(f, fbZ_reg, fbZ_reg, 8); /* fbZ = fbZ << 8 */
spe_or(f, fbZS_reg, fbS_reg, fbZ_reg); /* fbZS = fbS | fbZ */ spe_or(f, fbZS_reg, fbS_reg, fbZ_reg); /* fbZS = fbS | fbZ */
@ -1985,7 +1985,7 @@ gen_depth_stencil(struct cell_context *cell,
else if (zs_format == PIPE_FORMAT_Z16_UNORM) { else if (zs_format == PIPE_FORMAT_Z16_UNORM) {
spe_move(f, fbZS_reg, fbZ_reg); /* fbZS = fbZ */ spe_move(f, fbZS_reg, fbZ_reg); /* fbZS = fbZ */
} }
else if (zs_format == PIPE_FORMAT_S8_UNORM) { else if (zs_format == PIPE_FORMAT_S8_USCALED) {
ASSERT(0); /* XXX to do */ ASSERT(0); /* XXX to do */
} }
else { else {
@ -2015,7 +2015,7 @@ gen_depth_stencil(struct cell_context *cell,
* code before the fragment shader to cull fragments/quads that are * code before the fragment shader to cull fragments/quads that are
* totally occluded/discarded. * totally occluded/discarded.
* *
* XXX we only support PIPE_FORMAT_S8Z24_UNORM z/stencil buffer right now. * XXX we only support PIPE_FORMAT_S8_USCALED_Z24_UNORM z/stencil buffer right now.
* *
* See the spu_default_fragment_ops() function to see how the per-fragment * See the spu_default_fragment_ops() function to see how the per-fragment
* operations would be done with ordinary C code. * operations would be done with ordinary C code.

2
src/gallium/drivers/cell/ppu/cell_screen.c
View file

@ -147,7 +147,7 @@ cell_is_format_supported( struct pipe_screen *screen,
/* only a few formats are known to work at this time */ /* only a few formats are known to work at this time */
switch (format) { switch (format) {
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_B8G8R8A8_UNORM: case PIPE_FORMAT_B8G8R8A8_UNORM:
case PIPE_FORMAT_I8_UNORM: case PIPE_FORMAT_I8_UNORM:

4
src/gallium/drivers/cell/spu/spu_command.c
View file

@ -337,8 +337,8 @@ cmd_state_framebuffer(const struct cell_command_framebuffer *cmd)
spu.fb.zsize = 4; spu.fb.zsize = 4;
spu.fb.zscale = (float) 0xffffffffu; spu.fb.zscale = (float) 0xffffffffu;
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
spu.fb.zsize = 4; spu.fb.zsize = 4;

4
src/gallium/drivers/cell/spu/spu_per_fragment_op.c
View file

@ -138,13 +138,13 @@ spu_fallback_fragment_ops(uint x, uint y,
if (spu.depth_stencil_alpha.stencil[0].enabled) { if (spu.depth_stencil_alpha.stencil[0].enabled) {
/* do stencil test */ /* do stencil test */
ASSERT(spu.fb.depth_format == PIPE_FORMAT_Z24S8_UNORM); ASSERT(spu.fb.depth_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED);
} }
else if (spu.depth_stencil_alpha.depth.enabled) { else if (spu.depth_stencil_alpha.depth.enabled) {
/* do depth test */ /* do depth test */
ASSERT(spu.fb.depth_format == PIPE_FORMAT_Z24S8_UNORM || ASSERT(spu.fb.depth_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
spu.fb.depth_format == PIPE_FORMAT_Z24X8_UNORM); spu.fb.depth_format == PIPE_FORMAT_Z24X8_UNORM);
vector unsigned int ifragZ; vector unsigned int ifragZ;

4
src/gallium/drivers/i915/i915_screen.c
View file

@ -178,13 +178,13 @@ i915_is_format_supported(struct pipe_screen *screen,
PIPE_FORMAT_L8A8_UNORM, PIPE_FORMAT_L8A8_UNORM,
PIPE_FORMAT_UYVY, PIPE_FORMAT_UYVY,
PIPE_FORMAT_YUYV, PIPE_FORMAT_YUYV,
PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_FORMAT_NONE /* list terminator */ PIPE_FORMAT_NONE /* list terminator */
}; };
static const enum pipe_format surface_supported[] = { static const enum pipe_format surface_supported[] = {
PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_FORMAT_B8G8R8A8_UNORM,
PIPE_FORMAT_B5G6R5_UNORM, PIPE_FORMAT_B5G6R5_UNORM,
PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_FORMAT_NONE /* list terminator */ PIPE_FORMAT_NONE /* list terminator */
}; };
const enum pipe_format *list; const enum pipe_format *list;

2
src/gallium/drivers/i915/i915_state_emit.c
View file

@ -50,7 +50,7 @@ static unsigned translate_format( enum pipe_format format )
static unsigned translate_depth_format( enum pipe_format zformat ) static unsigned translate_depth_format( enum pipe_format zformat )
{ {
switch (zformat) { switch (zformat) {
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
return DEPTH_FRMT_24_FIXED_8_OTHER; return DEPTH_FRMT_24_FIXED_8_OTHER;
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
return DEPTH_FRMT_16_FIXED; return DEPTH_FRMT_16_FIXED;

2
src/gallium/drivers/i915/i915_state_sampler.c
View file

@ -220,7 +220,7 @@ translate_texture_format(enum pipe_format pipeFormat)
case PIPE_FORMAT_RGBA_DXT5: case PIPE_FORMAT_RGBA_DXT5:
return (MAPSURF_COMPRESSED | MT_COMPRESS_DXT4_5); return (MAPSURF_COMPRESSED | MT_COMPRESS_DXT4_5);
#endif #endif
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
return (MAPSURF_32BIT | MT_32BIT_xI824); return (MAPSURF_32BIT | MT_32BIT_xI824);
default: default:
debug_printf("i915: translate_texture_format() bad image format %x\n", debug_printf("i915: translate_texture_format() bad image format %x\n",

2
src/gallium/drivers/i965/brw_misc_state.c
View file

@ -266,7 +266,7 @@ static int emit_depthbuffer(struct brw_context *brw)
cpp = 2; cpp = 2;
break; break;
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
format = BRW_DEPTHFORMAT_D24_UNORM_S8_UINT; format = BRW_DEPTHFORMAT_D24_UNORM_S8_UINT;
cpp = 4; cpp = 4;
break; break;

4
src/gallium/drivers/i965/brw_pipe_clear.c
View file

@ -140,7 +140,7 @@ static void zstencil_clear(struct brw_context *brw,
switch (bsurface->base.format) { switch (bsurface->base.format) {
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
value = ((unsigned)(depth * MASK24) & MASK24); value = ((unsigned)(depth * MASK24) & MASK24);
break; break;
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
@ -153,7 +153,7 @@ static void zstencil_clear(struct brw_context *brw,
switch (bsurface->base.format) { switch (bsurface->base.format) {
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
value = value | (stencil << 24); value = value | (stencil << 24);
break; break;

4
src/gallium/drivers/i965/brw_screen.c
View file

@ -252,7 +252,7 @@ brw_is_format_supported(struct pipe_screen *screen,
/* depth */ /* depth */
PIPE_FORMAT_Z32_FLOAT, PIPE_FORMAT_Z32_FLOAT,
PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_Z24X8_UNORM,
PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_FORMAT_Z16_UNORM, PIPE_FORMAT_Z16_UNORM,
/* signed */ /* signed */
PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8_SNORM,
@ -268,7 +268,7 @@ brw_is_format_supported(struct pipe_screen *screen,
static const enum pipe_format depth_supported[] = { static const enum pipe_format depth_supported[] = {
PIPE_FORMAT_Z32_FLOAT, PIPE_FORMAT_Z32_FLOAT,
PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_Z24X8_UNORM,
PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_FORMAT_Z16_UNORM, PIPE_FORMAT_Z16_UNORM,
PIPE_FORMAT_NONE /* list terminator */ PIPE_FORMAT_NONE /* list terminator */
}; };

2
src/gallium/drivers/i965/brw_screen_texture.c
View file

@ -158,7 +158,7 @@ static GLuint translate_tex_format( enum pipe_format pf )
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
return BRW_SURFACEFORMAT_I16_UNORM; return BRW_SURFACEFORMAT_I16_UNORM;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
return BRW_SURFACEFORMAT_I24X8_UNORM; return BRW_SURFACEFORMAT_I24X8_UNORM;

4
src/gallium/drivers/nv50/nv50_miptree.c
View file

@ -89,14 +89,14 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
case PIPE_FORMAT_Z32_FLOAT: case PIPE_FORMAT_Z32_FLOAT:
tile_flags = 0x4800; tile_flags = 0x4800;
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
tile_flags = 0x1800; tile_flags = 0x1800;
break; break;
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
tile_flags = 0x6c00; tile_flags = 0x6c00;
break; break;
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
tile_flags = 0x2800; tile_flags = 0x2800;
break; break;
case PIPE_FORMAT_R32G32B32A32_FLOAT: case PIPE_FORMAT_R32G32B32A32_FLOAT:

8
src/gallium/drivers/nv50/nv50_screen.c
View file

@ -51,9 +51,9 @@ nv50_screen_is_format_supported(struct pipe_screen *pscreen,
if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) { if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) {
switch (format) { switch (format) {
case PIPE_FORMAT_Z32_FLOAT: case PIPE_FORMAT_Z32_FLOAT:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
return TRUE; return TRUE;
default: default:
break; break;
@ -75,8 +75,8 @@ nv50_screen_is_format_supported(struct pipe_screen *pscreen,
case PIPE_FORMAT_DXT1_RGBA: case PIPE_FORMAT_DXT1_RGBA:
case PIPE_FORMAT_DXT3_RGBA: case PIPE_FORMAT_DXT3_RGBA:
case PIPE_FORMAT_DXT5_RGBA: case PIPE_FORMAT_DXT5_RGBA:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z32_FLOAT: case PIPE_FORMAT_Z32_FLOAT:
case PIPE_FORMAT_R16G16B16A16_SNORM: case PIPE_FORMAT_R16G16B16A16_SNORM:
case PIPE_FORMAT_R16G16B16A16_UNORM: case PIPE_FORMAT_R16G16B16A16_UNORM:

4
src/gallium/drivers/nv50/nv50_state_validate.c
View file

@ -122,13 +122,13 @@ validate_fb(struct nv50_context *nv50)
so_reloc (so, bo, fb->zsbuf->offset, NOUVEAU_BO_VRAM | so_reloc (so, bo, fb->zsbuf->offset, NOUVEAU_BO_VRAM |
NOUVEAU_BO_LOW | NOUVEAU_BO_RDWR, 0, 0); NOUVEAU_BO_LOW | NOUVEAU_BO_RDWR, 0, 0);
switch (fb->zsbuf->format) { switch (fb->zsbuf->format) {
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
so_data(so, NV50TCL_ZETA_FORMAT_S8Z24_UNORM); so_data(so, NV50TCL_ZETA_FORMAT_S8Z24_UNORM);
break; break;
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
so_data(so, NV50TCL_ZETA_FORMAT_X8Z24_UNORM); so_data(so, NV50TCL_ZETA_FORMAT_X8Z24_UNORM);
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
so_data(so, NV50TCL_ZETA_FORMAT_Z24S8_UNORM); so_data(so, NV50TCL_ZETA_FORMAT_Z24S8_UNORM);
break; break;
case PIPE_FORMAT_Z32_FLOAT: case PIPE_FORMAT_Z32_FLOAT:

4
src/gallium/drivers/nv50/nv50_surface.c
View file

@ -60,8 +60,8 @@ nv50_format(enum pipe_format format)
/* only because we require src format == dst format: */ /* only because we require src format == dst format: */
case PIPE_FORMAT_R16G16_SNORM: case PIPE_FORMAT_R16G16_SNORM:
case PIPE_FORMAT_R16G16_UNORM: case PIPE_FORMAT_R16G16_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
return NV50_2D_DST_FORMAT_A8R8G8B8_UNORM; return NV50_2D_DST_FORMAT_A8R8G8B8_UNORM;
case PIPE_FORMAT_L8A8_UNORM: case PIPE_FORMAT_L8A8_UNORM:
case PIPE_FORMAT_B4G4R4A4_UNORM: case PIPE_FORMAT_B4G4R4A4_UNORM:

4
src/gallium/drivers/nv50/nv50_tex.c
View file

@ -62,8 +62,8 @@ static const uint32_t nv50_texture_formats[PIPE_FORMAT_COUNT] =
_(DXT3_RGBA, UNORM, C0, C1, C2, C3, DXT3), _(DXT3_RGBA, UNORM, C0, C1, C2, C3, DXT3),
_(DXT5_RGBA, UNORM, C0, C1, C2, C3, DXT5), _(DXT5_RGBA, UNORM, C0, C1, C2, C3, DXT5),
_MIXED(S8Z24_UNORM, UINT, UNORM, UINT, UINT, C1, C1, C1, ONE, 24_8), _MIXED(S8_USCALED_Z24_UNORM, UINT, UNORM, UINT, UINT, C1, C1, C1, ONE, 24_8),
_MIXED(Z24S8_UNORM, UNORM, UINT, UINT, UINT, C0, C0, C0, ONE, 8_24), _MIXED(Z24_UNORM_S8_USCALED, UNORM, UINT, UINT, UINT, C0, C0, C0, ONE, 8_24),
_(R16G16B16A16_SNORM, UNORM, C0, C1, C2, C3, 16_16_16_16), _(R16G16B16A16_SNORM, UNORM, C0, C1, C2, C3, 16_16_16_16),
_(R16G16B16A16_UNORM, SNORM, C0, C1, C2, C3, 16_16_16_16), _(R16G16B16A16_UNORM, SNORM, C0, C1, C2, C3, 16_16_16_16),

4
src/gallium/drivers/nvfx/nv04_surface_2d.c
View file

@ -25,7 +25,7 @@ nv04_surface_format(enum pipe_format format)
case PIPE_FORMAT_B8G8R8X8_UNORM: case PIPE_FORMAT_B8G8R8X8_UNORM:
case PIPE_FORMAT_B8G8R8A8_UNORM: case PIPE_FORMAT_B8G8R8A8_UNORM:
return NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8; return NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
return NV04_CONTEXT_SURFACES_2D_FORMAT_Y32; return NV04_CONTEXT_SURFACES_2D_FORMAT_Y32;
default: default:
@ -45,7 +45,7 @@ nv04_rect_format(enum pipe_format format)
return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5; return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5;
case PIPE_FORMAT_B8G8R8X8_UNORM: case PIPE_FORMAT_B8G8R8X8_UNORM:
case PIPE_FORMAT_B8G8R8A8_UNORM: case PIPE_FORMAT_B8G8R8A8_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8; return NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8;
default: default:

2
src/gallium/drivers/nvfx/nv30_fragtex.c
View file

@ -63,7 +63,7 @@ nv30_texture_formats[] = {
_(I8_UNORM , L8 , S1, S1, S1, S1, X, X, X, X), _(I8_UNORM , L8 , S1, S1, S1, S1, X, X, X, X),
_(L8A8_UNORM , A8L8 , S1, S1, S1, S1, X, X, X, Y), _(L8A8_UNORM , A8L8 , S1, S1, S1, S1, X, X, X, Y),
_(Z16_UNORM , R5G6B5 , S1, S1, S1, ONE, X, X, X, X), _(Z16_UNORM , R5G6B5 , S1, S1, S1, ONE, X, X, X, X),
_(S8Z24_UNORM , A8R8G8B8, S1, S1, S1, ONE, X, X, X, X), _(S8_USCALED_Z24_UNORM , A8R8G8B8, S1, S1, S1, ONE, X, X, X, X),
_(DXT1_RGB , DXT1 , S1, S1, S1, ONE, X, Y, Z, W), _(DXT1_RGB , DXT1 , S1, S1, S1, ONE, X, Y, Z, W),
_(DXT1_RGBA , DXT1 , S1, S1, S1, S1, X, Y, Z, W), _(DXT1_RGBA , DXT1 , S1, S1, S1, S1, X, Y, Z, W),
_(DXT3_RGBA , DXT3 , S1, S1, S1, S1, X, Y, Z, W), _(DXT3_RGBA , DXT3 , S1, S1, S1, S1, X, Y, Z, W),

2
src/gallium/drivers/nvfx/nv40_fragtex.c
View file

@ -81,7 +81,7 @@ nv40_texture_formats[] = {
_(I8_UNORM , L8 , S1, S1, S1, S1, X, X, X, X, 0, 0, 0, 0), _(I8_UNORM , L8 , S1, S1, S1, S1, X, X, X, X, 0, 0, 0, 0),
_(L8A8_UNORM , A8L8 , S1, S1, S1, S1, X, X, X, Y, 0, 0, 0, 0), _(L8A8_UNORM , A8L8 , S1, S1, S1, S1, X, X, X, Y, 0, 0, 0, 0),
_(Z16_UNORM , Z16 , S1, S1, S1, ONE, X, X, X, X, 0, 0, 0, 0), _(Z16_UNORM , Z16 , S1, S1, S1, ONE, X, X, X, X, 0, 0, 0, 0),
_(S8Z24_UNORM , Z24 , S1, S1, S1, ONE, X, X, X, X, 0, 0, 0, 0), _(S8_USCALED_Z24_UNORM , Z24 , S1, S1, S1, ONE, X, X, X, X, 0, 0, 0, 0),
_(DXT1_RGB , DXT1 , S1, S1, S1, ONE, X, Y, Z, W, 0, 0, 0, 0), _(DXT1_RGB , DXT1 , S1, S1, S1, ONE, X, Y, Z, W, 0, 0, 0, 0),
_(DXT1_RGBA , DXT1 , S1, S1, S1, S1, X, Y, Z, W, 0, 0, 0, 0), _(DXT1_RGBA , DXT1 , S1, S1, S1, S1, X, Y, Z, W, 0, 0, 0, 0),
_(DXT3_RGBA , DXT3 , S1, S1, S1, S1, X, Y, Z, W, 0, 0, 0, 0), _(DXT3_RGBA , DXT3 , S1, S1, S1, S1, X, Y, Z, W, 0, 0, 0, 0),

4
src/gallium/drivers/nvfx/nvfx_screen.c
View file

@ -133,7 +133,7 @@ nvfx_screen_surface_format_supported(struct pipe_screen *pscreen,
} else } else
if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) { if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) {
switch (format) { switch (format) {
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
return TRUE; return TRUE;
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
@ -155,7 +155,7 @@ nvfx_screen_surface_format_supported(struct pipe_screen *pscreen,
case PIPE_FORMAT_I8_UNORM: case PIPE_FORMAT_I8_UNORM:
case PIPE_FORMAT_L8A8_UNORM: case PIPE_FORMAT_L8A8_UNORM:
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_DXT1_RGB: case PIPE_FORMAT_DXT1_RGB:
case PIPE_FORMAT_DXT1_RGBA: case PIPE_FORMAT_DXT1_RGBA:
case PIPE_FORMAT_DXT3_RGBA: case PIPE_FORMAT_DXT3_RGBA:

2
src/gallium/drivers/nvfx/nvfx_state_fb.c
View file

@ -102,7 +102,7 @@ nvfx_state_framebuffer_validate(struct nvfx_context *nvfx)
rt_format |= NV34TCL_RT_FORMAT_ZETA_Z16; rt_format |= NV34TCL_RT_FORMAT_ZETA_Z16;
zeta_bits = 16; zeta_bits = 16;
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
case 0: case 0:
rt_format |= NV34TCL_RT_FORMAT_ZETA_Z24S8; rt_format |= NV34TCL_RT_FORMAT_ZETA_Z24S8;

2
src/gallium/drivers/r300/r300_screen.c
View file

@ -208,7 +208,7 @@ static boolean r300_is_format_supported(struct pipe_screen* screen,
uint32_t retval = 0; uint32_t retval = 0;
boolean is_r500 = r300_screen(screen)->caps->is_r500; boolean is_r500 = r300_screen(screen)->caps->is_r500;
boolean is_z24 = format == PIPE_FORMAT_X8Z24_UNORM || boolean is_z24 = format == PIPE_FORMAT_X8Z24_UNORM ||
format == PIPE_FORMAT_S8Z24_UNORM; format == PIPE_FORMAT_S8_USCALED_Z24_UNORM;
boolean is_color2101010 = format == PIPE_FORMAT_R10G10B10A2_UNORM; boolean is_color2101010 = format == PIPE_FORMAT_R10G10B10A2_UNORM;
if (target >= PIPE_MAX_TEXTURE_TYPES) { if (target >= PIPE_MAX_TEXTURE_TYPES) {

4
src/gallium/drivers/r300/r300_texture.c
View file

@ -104,7 +104,7 @@ static uint32_t r300_translate_texformat(enum pipe_format format)
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
return R300_EASY_TX_FORMAT(X, X, X, X, X16); return R300_EASY_TX_FORMAT(X, X, X, X, X16);
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
return R300_EASY_TX_FORMAT(X, X, X, X, W24_FP); return R300_EASY_TX_FORMAT(X, X, X, X, W24_FP);
default: default:
return ~0; /* Unsupported. */ return ~0; /* Unsupported. */
@ -372,7 +372,7 @@ static uint32_t r300_translate_zsformat(enum pipe_format format)
/* 24-bit depth, ignored stencil */ /* 24-bit depth, ignored stencil */
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
/* 24-bit depth, 8-bit stencil */ /* 24-bit depth, 8-bit stencil */
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL; return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL;
default: default:
return ~0; /* Unsupported. */ return ~0; /* Unsupported. */

12
src/gallium/drivers/softpipe/sp_quad_depth_test.c
View file

@ -75,7 +75,7 @@ get_depth_stencil_values( struct depth_data *data,
} }
break; break;
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
for (j = 0; j < QUAD_SIZE; j++) { for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->input.x0 % TILE_SIZE + (j & 1); int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1); int y = quad->input.y0 % TILE_SIZE + (j >> 1);
@ -84,7 +84,7 @@ get_depth_stencil_values( struct depth_data *data,
} }
break; break;
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
for (j = 0; j < QUAD_SIZE; j++) { for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->input.x0 % TILE_SIZE + (j & 1); int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1); int y = quad->input.y0 % TILE_SIZE + (j >> 1);
@ -153,7 +153,7 @@ convert_quad_depth( struct depth_data *data,
} }
break; break;
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
{ {
float scale = (float) ((1 << 24) - 1); float scale = (float) ((1 << 24) - 1);
@ -163,7 +163,7 @@ convert_quad_depth( struct depth_data *data,
} }
break; break;
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
{ {
float scale = (float) ((1 << 24) - 1); float scale = (float) ((1 << 24) - 1);
@ -206,14 +206,14 @@ write_depth_stencil_values( struct depth_data *data,
tile->data.depth32[y][x] = data->bzzzz[j]; tile->data.depth32[y][x] = data->bzzzz[j];
} }
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
for (j = 0; j < QUAD_SIZE; j++) { for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->input.x0 % TILE_SIZE + (j & 1); int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1); int y = quad->input.y0 % TILE_SIZE + (j >> 1);
tile->data.depth32[y][x] = (data->stencilVals[j] << 24) | data->bzzzz[j]; tile->data.depth32[y][x] = (data->stencilVals[j] << 24) | data->bzzzz[j];
} }
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
for (j = 0; j < QUAD_SIZE; j++) { for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->input.x0 % TILE_SIZE + (j & 1); int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1); int y = quad->input.y0 % TILE_SIZE + (j >> 1);

6
src/gallium/drivers/softpipe/sp_tile_cache.c
View file

@ -158,13 +158,13 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
PIPE_TRANSFER_READ_WRITE, PIPE_TRANSFER_READ_WRITE,
0, 0, ps->width, ps->height); 0, 0, ps->width, ps->height);
tc->depth_stencil = (ps->format == PIPE_FORMAT_Z24S8_UNORM || tc->depth_stencil = (ps->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
ps->format == PIPE_FORMAT_Z24X8_UNORM || ps->format == PIPE_FORMAT_Z24X8_UNORM ||
ps->format == PIPE_FORMAT_S8Z24_UNORM || ps->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
ps->format == PIPE_FORMAT_X8Z24_UNORM || ps->format == PIPE_FORMAT_X8Z24_UNORM ||
ps->format == PIPE_FORMAT_Z16_UNORM || ps->format == PIPE_FORMAT_Z16_UNORM ||
ps->format == PIPE_FORMAT_Z32_UNORM || ps->format == PIPE_FORMAT_Z32_UNORM ||
ps->format == PIPE_FORMAT_S8_UNORM); ps->format == PIPE_FORMAT_S8_USCALED);
} }
} }

2
src/gallium/drivers/svga/svga_pipe_clear.c
View file

@ -63,7 +63,7 @@ try_clear(struct svga_context *svga,
if ((buffers & PIPE_CLEAR_DEPTHSTENCIL) && fb->zsbuf) { if ((buffers & PIPE_CLEAR_DEPTHSTENCIL) && fb->zsbuf) {
flags |= SVGA3D_CLEAR_DEPTH; flags |= SVGA3D_CLEAR_DEPTH;
if (svga->curr.framebuffer.zsbuf->format == PIPE_FORMAT_S8Z24_UNORM) if (svga->curr.framebuffer.zsbuf->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM)
flags |= SVGA3D_CLEAR_STENCIL; flags |= SVGA3D_CLEAR_STENCIL;
rect.w = MAX2(rect.w, fb->zsbuf->width); rect.w = MAX2(rect.w, fb->zsbuf->width);

4
src/gallium/drivers/svga/svga_pipe_misc.c
View file

@ -118,9 +118,9 @@ static void svga_set_framebuffer_state(struct pipe_context *pipe,
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
svga->curr.depthscale = 1.0f / DEPTH_BIAS_SCALE_FACTOR_D16; svga->curr.depthscale = 1.0f / DEPTH_BIAS_SCALE_FACTOR_D16;
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
svga->curr.depthscale = 1.0f / DEPTH_BIAS_SCALE_FACTOR_D24S8; svga->curr.depthscale = 1.0f / DEPTH_BIAS_SCALE_FACTOR_D24S8;
break; break;

2
src/gallium/drivers/svga/svga_screen.c
View file

@ -210,7 +210,7 @@ svga_translate_format_cap(enum pipe_format format)
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
return SVGA3D_DEVCAP_SURFACEFMT_Z_D16; return SVGA3D_DEVCAP_SURFACEFMT_Z_D16;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
return SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8; return SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8;
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
return SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8; return SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8;

4
src/gallium/drivers/svga/svga_screen_texture.c
View file

@ -81,7 +81,7 @@ svga_translate_format(enum pipe_format format)
*/ */
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:
return SVGA3D_Z_D16; return SVGA3D_Z_D16;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
return SVGA3D_Z_D24S8; return SVGA3D_Z_D24S8;
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
return SVGA3D_Z_D24X8; return SVGA3D_Z_D24X8;
@ -114,7 +114,7 @@ svga_translate_format_render(enum pipe_format format)
case PIPE_FORMAT_B5G5R5A1_UNORM: case PIPE_FORMAT_B5G5R5A1_UNORM:
case PIPE_FORMAT_B4G4R4A4_UNORM: case PIPE_FORMAT_B4G4R4A4_UNORM:
case PIPE_FORMAT_B5G6R5_UNORM: case PIPE_FORMAT_B5G6R5_UNORM:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
case PIPE_FORMAT_Z32_UNORM: case PIPE_FORMAT_Z32_UNORM:
case PIPE_FORMAT_Z16_UNORM: case PIPE_FORMAT_Z16_UNORM:

2
src/gallium/drivers/svga/svga_state_framebuffer.c
View file

@ -70,7 +70,7 @@ static int emit_framebuffer( struct svga_context *svga,
return ret; return ret;
if (curr->zsbuf && if (curr->zsbuf &&
curr->zsbuf->format == PIPE_FORMAT_S8Z24_UNORM) { curr->zsbuf->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM) {
ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_STENCIL, curr->zsbuf); ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_STENCIL, curr->zsbuf);
if (ret != PIPE_OK) if (ret != PIPE_OK)
return ret; return ret;

236
src/gallium/include/pipe/p_format.h
View file

@ -44,120 +44,140 @@ extern "C" {
*/ */
enum pipe_format { enum pipe_format {
PIPE_FORMAT_NONE = 0, PIPE_FORMAT_NONE = 0,
PIPE_FORMAT_B8G8R8A8_UNORM = 1, PIPE_FORMAT_B8G8R8A8_UNORM = 1,
PIPE_FORMAT_B8G8R8X8_UNORM = 2, PIPE_FORMAT_B8G8R8X8_UNORM = 2,
PIPE_FORMAT_A8R8G8B8_UNORM = 3, PIPE_FORMAT_A8R8G8B8_UNORM = 3,
PIPE_FORMAT_X8R8G8B8_UNORM = 4, PIPE_FORMAT_X8R8G8B8_UNORM = 4,
PIPE_FORMAT_B5G5R5A1_UNORM = 5, PIPE_FORMAT_B5G5R5A1_UNORM = 5,
PIPE_FORMAT_B4G4R4A4_UNORM = 6, PIPE_FORMAT_B4G4R4A4_UNORM = 6,
PIPE_FORMAT_B5G6R5_UNORM = 7, PIPE_FORMAT_B5G6R5_UNORM = 7,
PIPE_FORMAT_R10G10B10A2_UNORM = 8, PIPE_FORMAT_R10G10B10A2_UNORM = 8,
PIPE_FORMAT_L8_UNORM = 9, /**< ubyte luminance */ PIPE_FORMAT_L8_UNORM = 9, /**< ubyte luminance */
PIPE_FORMAT_A8_UNORM = 10, /**< ubyte alpha */ PIPE_FORMAT_A8_UNORM = 10, /**< ubyte alpha */
PIPE_FORMAT_I8_UNORM = 11, /**< ubyte intensity */ PIPE_FORMAT_I8_UNORM = 11, /**< ubyte intensity */
PIPE_FORMAT_L8A8_UNORM = 12, /**< ubyte alpha, luminance */ PIPE_FORMAT_L8A8_UNORM = 12, /**< ubyte alpha, luminance */
PIPE_FORMAT_L16_UNORM = 13, /**< ushort luminance */ PIPE_FORMAT_L16_UNORM = 13, /**< ushort luminance */
PIPE_FORMAT_UYVY = 14, PIPE_FORMAT_UYVY = 14,
PIPE_FORMAT_YUYV = 15, PIPE_FORMAT_YUYV = 15,
PIPE_FORMAT_Z16_UNORM = 16, PIPE_FORMAT_Z16_UNORM = 16,
PIPE_FORMAT_Z32_UNORM = 17, PIPE_FORMAT_Z32_UNORM = 17,
PIPE_FORMAT_Z32_FLOAT = 18, PIPE_FORMAT_Z32_FLOAT = 18,
PIPE_FORMAT_Z24S8_UNORM = 19, PIPE_FORMAT_Z24_UNORM_S8_USCALED = 19,
PIPE_FORMAT_S8Z24_UNORM = 20, PIPE_FORMAT_S8_USCALED_Z24_UNORM = 20,
PIPE_FORMAT_Z24X8_UNORM = 21, PIPE_FORMAT_Z24X8_UNORM = 21,
PIPE_FORMAT_X8Z24_UNORM = 22, PIPE_FORMAT_X8Z24_UNORM = 22,
PIPE_FORMAT_S8_UNORM = 23, /**< ubyte stencil */ PIPE_FORMAT_S8_USCALED = 23, /**< ubyte stencil */
PIPE_FORMAT_R64_FLOAT = 24, PIPE_FORMAT_R64_FLOAT = 24,
PIPE_FORMAT_R64G64_FLOAT = 25, PIPE_FORMAT_R64G64_FLOAT = 25,
PIPE_FORMAT_R64G64B64_FLOAT = 26, PIPE_FORMAT_R64G64B64_FLOAT = 26,
PIPE_FORMAT_R64G64B64A64_FLOAT = 27, PIPE_FORMAT_R64G64B64A64_FLOAT = 27,
PIPE_FORMAT_R32_FLOAT = 28, PIPE_FORMAT_R32_FLOAT = 28,
PIPE_FORMAT_R32G32_FLOAT = 29, PIPE_FORMAT_R32G32_FLOAT = 29,
PIPE_FORMAT_R32G32B32_FLOAT = 30, PIPE_FORMAT_R32G32B32_FLOAT = 30,
PIPE_FORMAT_R32G32B32A32_FLOAT = 31, PIPE_FORMAT_R32G32B32A32_FLOAT = 31,
PIPE_FORMAT_R32_UNORM = 32, PIPE_FORMAT_R32_UNORM = 32,
PIPE_FORMAT_R32G32_UNORM = 33, PIPE_FORMAT_R32G32_UNORM = 33,
PIPE_FORMAT_R32G32B32_UNORM = 34, PIPE_FORMAT_R32G32B32_UNORM = 34,
PIPE_FORMAT_R32G32B32A32_UNORM = 35, PIPE_FORMAT_R32G32B32A32_UNORM = 35,
PIPE_FORMAT_R32_USCALED = 36, PIPE_FORMAT_R32_USCALED = 36,
PIPE_FORMAT_R32G32_USCALED = 37, PIPE_FORMAT_R32G32_USCALED = 37,
PIPE_FORMAT_R32G32B32_USCALED = 38, PIPE_FORMAT_R32G32B32_USCALED = 38,
PIPE_FORMAT_R32G32B32A32_USCALED = 39, PIPE_FORMAT_R32G32B32A32_USCALED = 39,
PIPE_FORMAT_R32_SNORM = 40, PIPE_FORMAT_R32_SNORM = 40,
PIPE_FORMAT_R32G32_SNORM = 41, PIPE_FORMAT_R32G32_SNORM = 41,
PIPE_FORMAT_R32G32B32_SNORM = 42, PIPE_FORMAT_R32G32B32_SNORM = 42,
PIPE_FORMAT_R32G32B32A32_SNORM = 43, PIPE_FORMAT_R32G32B32A32_SNORM = 43,
PIPE_FORMAT_R32_SSCALED = 44, PIPE_FORMAT_R32_SSCALED = 44,
PIPE_FORMAT_R32G32_SSCALED = 45, PIPE_FORMAT_R32G32_SSCALED = 45,
PIPE_FORMAT_R32G32B32_SSCALED = 46, PIPE_FORMAT_R32G32B32_SSCALED = 46,
PIPE_FORMAT_R32G32B32A32_SSCALED = 47, PIPE_FORMAT_R32G32B32A32_SSCALED = 47,
PIPE_FORMAT_R16_UNORM = 48, PIPE_FORMAT_R16_UNORM = 48,
PIPE_FORMAT_R16G16_UNORM = 49, PIPE_FORMAT_R16G16_UNORM = 49,
PIPE_FORMAT_R16G16B16_UNORM = 50, PIPE_FORMAT_R16G16B16_UNORM = 50,
PIPE_FORMAT_R16G16B16A16_UNORM = 51, PIPE_FORMAT_R16G16B16A16_UNORM = 51,
PIPE_FORMAT_R16_USCALED = 52, PIPE_FORMAT_R16_USCALED = 52,
PIPE_FORMAT_R16G16_USCALED = 53, PIPE_FORMAT_R16G16_USCALED = 53,
PIPE_FORMAT_R16G16B16_USCALED = 54, PIPE_FORMAT_R16G16B16_USCALED = 54,
PIPE_FORMAT_R16G16B16A16_USCALED = 55, PIPE_FORMAT_R16G16B16A16_USCALED = 55,
PIPE_FORMAT_R16_SNORM = 56, PIPE_FORMAT_R16_SNORM = 56,
PIPE_FORMAT_R16G16_SNORM = 57, PIPE_FORMAT_R16G16_SNORM = 57,
PIPE_FORMAT_R16G16B16_SNORM = 58, PIPE_FORMAT_R16G16B16_SNORM = 58,
PIPE_FORMAT_R16G16B16A16_SNORM = 59, PIPE_FORMAT_R16G16B16A16_SNORM = 59,
PIPE_FORMAT_R16_SSCALED = 60, PIPE_FORMAT_R16_SSCALED = 60,
PIPE_FORMAT_R16G16_SSCALED = 61, PIPE_FORMAT_R16G16_SSCALED = 61,
PIPE_FORMAT_R16G16B16_SSCALED = 62, PIPE_FORMAT_R16G16B16_SSCALED = 62,
PIPE_FORMAT_R16G16B16A16_SSCALED = 63, PIPE_FORMAT_R16G16B16A16_SSCALED = 63,
PIPE_FORMAT_R8_UNORM = 64, PIPE_FORMAT_R8_UNORM = 64,
PIPE_FORMAT_R8G8_UNORM = 65, PIPE_FORMAT_R8G8_UNORM = 65,
PIPE_FORMAT_R8G8B8_UNORM = 66, PIPE_FORMAT_R8G8B8_UNORM = 66,
PIPE_FORMAT_R8G8B8A8_UNORM = 67, PIPE_FORMAT_R8G8B8A8_UNORM = 67,
PIPE_FORMAT_X8B8G8R8_UNORM = 68, PIPE_FORMAT_X8B8G8R8_UNORM = 68,
PIPE_FORMAT_R8_USCALED = 69, PIPE_FORMAT_R8_USCALED = 69,
PIPE_FORMAT_R8G8_USCALED = 70, PIPE_FORMAT_R8G8_USCALED = 70,
PIPE_FORMAT_R8G8B8_USCALED = 71, PIPE_FORMAT_R8G8B8_USCALED = 71,
PIPE_FORMAT_R8G8B8A8_USCALED = 72, PIPE_FORMAT_R8G8B8A8_USCALED = 72,
PIPE_FORMAT_R8_SNORM = 74, PIPE_FORMAT_R8_SNORM = 74,
PIPE_FORMAT_R8G8_SNORM = 75, PIPE_FORMAT_R8G8_SNORM = 75,
PIPE_FORMAT_R8G8B8_SNORM = 76, PIPE_FORMAT_R8G8B8_SNORM = 76,
PIPE_FORMAT_R8G8B8A8_SNORM = 77, PIPE_FORMAT_R8G8B8A8_SNORM = 77,
PIPE_FORMAT_R8_SSCALED = 82, PIPE_FORMAT_R8_SSCALED = 82,
PIPE_FORMAT_R8G8_SSCALED = 83, PIPE_FORMAT_R8G8_SSCALED = 83,
PIPE_FORMAT_R8G8B8_SSCALED = 84, PIPE_FORMAT_R8G8B8_SSCALED = 84,
PIPE_FORMAT_R8G8B8A8_SSCALED = 85, PIPE_FORMAT_R8G8B8A8_SSCALED = 85,
PIPE_FORMAT_R32_FIXED = 87, PIPE_FORMAT_R32_FIXED = 87,
PIPE_FORMAT_R32G32_FIXED = 88, PIPE_FORMAT_R32G32_FIXED = 88,
PIPE_FORMAT_R32G32B32_FIXED = 89, PIPE_FORMAT_R32G32B32_FIXED = 89,
PIPE_FORMAT_R32G32B32A32_FIXED = 90, PIPE_FORMAT_R32G32B32A32_FIXED = 90,
/* sRGB formats */ PIPE_FORMAT_R16_FLOAT = 91,
PIPE_FORMAT_L8_SRGB = 91, PIPE_FORMAT_R16G16_FLOAT = 92,
PIPE_FORMAT_L8A8_SRGB = 92, PIPE_FORMAT_R16G16B16_FLOAT = 93,
PIPE_FORMAT_R8G8B8_SRGB = 93, PIPE_FORMAT_R16G16B16A16_FLOAT = 94,
PIPE_FORMAT_A8B8G8R8_SRGB = 94,
PIPE_FORMAT_X8B8G8R8_SRGB = 95,
PIPE_FORMAT_B8G8R8A8_SRGB = 96,
PIPE_FORMAT_B8G8R8X8_SRGB = 97,
PIPE_FORMAT_A8R8G8B8_SRGB = 98,
PIPE_FORMAT_X8R8G8B8_SRGB = 99,
/* mixed formats */ /* sRGB formats */
PIPE_FORMAT_R8SG8SB8UX8U_NORM = 100, PIPE_FORMAT_L8_SRGB = 95,
PIPE_FORMAT_R5SG5SB6U_NORM = 101, PIPE_FORMAT_L8A8_SRGB = 96,
PIPE_FORMAT_R8G8B8_SRGB = 97,
PIPE_FORMAT_A8B8G8R8_SRGB = 98,
PIPE_FORMAT_X8B8G8R8_SRGB = 99,
PIPE_FORMAT_B8G8R8A8_SRGB = 100,
PIPE_FORMAT_B8G8R8X8_SRGB = 101,
PIPE_FORMAT_A8R8G8B8_SRGB = 102,
PIPE_FORMAT_X8R8G8B8_SRGB = 103,
PIPE_FORMAT_R8G8B8A8_SRGB = 104,
/* compressed formats */ /* compressed formats */
PIPE_FORMAT_DXT1_RGB = 102, PIPE_FORMAT_DXT1_RGB = 105,
PIPE_FORMAT_DXT1_RGBA = 103, PIPE_FORMAT_DXT1_RGBA = 106,
PIPE_FORMAT_DXT3_RGBA = 104, PIPE_FORMAT_DXT3_RGBA = 107,
PIPE_FORMAT_DXT5_RGBA = 105, PIPE_FORMAT_DXT5_RGBA = 108,
/* sRGB, compressed */ /* sRGB, compressed */
PIPE_FORMAT_DXT1_SRGB = 106, PIPE_FORMAT_DXT1_SRGB = 109,
PIPE_FORMAT_DXT1_SRGBA = 107, PIPE_FORMAT_DXT1_SRGBA = 110,
PIPE_FORMAT_DXT3_SRGBA = 108, PIPE_FORMAT_DXT3_SRGBA = 111,
PIPE_FORMAT_DXT5_SRGBA = 109, PIPE_FORMAT_DXT5_SRGBA = 112,
PIPE_FORMAT_A8B8G8R8_UNORM = 110, /* rgtc compressed */
PIPE_FORMAT_B5G5R5X1_UNORM = 111, PIPE_FORMAT_RGTC1_UNORM = 113,
PIPE_FORMAT_RGTC1_SNORM = 114,
PIPE_FORMAT_RGTC2_UNORM = 115,
PIPE_FORMAT_RGTC2_SNORM = 116,
PIPE_FORMAT_R8G8_B8G8_UNORM = 117,
PIPE_FORMAT_G8R8_G8B8_UNORM = 118,
/* mixed formats */
PIPE_FORMAT_R8SG8SB8UX8U_NORM = 119,
PIPE_FORMAT_R5SG5SB6U_NORM = 120,
PIPE_FORMAT_A8B8G8R8_UNORM = 121,
PIPE_FORMAT_B5G5R5X1_UNORM = 122,
PIPE_FORMAT_R10G10B10A2_USCALED = 123,
PIPE_FORMAT_R11G11B10_FLOAT = 124,
PIPE_FORMAT_R9G9B9E5_FLOAT = 125,
PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED = 126,
PIPE_FORMAT_R1_UNORM = 127,
PIPE_FORMAT_COUNT PIPE_FORMAT_COUNT
}; };

8
src/gallium/state_trackers/dri/common/dri_screen.c
View file

@ -97,10 +97,10 @@ dri_fill_in_modes(struct dri_screen *screen,
pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM, pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0); PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24S8_UNORM, pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0); PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8Z24_UNORM, pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0); PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
pf_a8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM, pf_a8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM,
@ -241,8 +241,8 @@ dri_fill_st_visual(struct st_visual *stvis, struct dri_screen *screen,
PIPE_FORMAT_X8Z24_UNORM; PIPE_FORMAT_X8Z24_UNORM;
} else { } else {
stvis->depth_stencil_format = (screen->sd_depth_bits_last) ? stvis->depth_stencil_format = (screen->sd_depth_bits_last) ?
PIPE_FORMAT_Z24S8_UNORM: PIPE_FORMAT_Z24_UNORM_S8_USCALED:
PIPE_FORMAT_S8Z24_UNORM; PIPE_FORMAT_S8_USCALED_Z24_UNORM;
} }
break; break;
case 32: case 32:

4
src/gallium/state_trackers/egl/kms/native_kms.c
View file

@ -631,9 +631,9 @@ kms_display_get_configs(struct native_display *ndpy, int *num_configs)
nconf->mode.alphaBits = 8; nconf->mode.alphaBits = 8;
nconf->mode.rgbBits = 32; nconf->mode.rgbBits = 32;
format = PIPE_FORMAT_Z24S8_UNORM; format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
if (!kms_display_is_format_supported(&kdpy->base, format, FALSE)) { if (!kms_display_is_format_supported(&kdpy->base, format, FALSE)) {
format = PIPE_FORMAT_S8Z24_UNORM; format = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
if (!kms_display_is_format_supported(&kdpy->base, format, FALSE)) if (!kms_display_is_format_supported(&kdpy->base, format, FALSE))
format = PIPE_FORMAT_NONE; format = PIPE_FORMAT_NONE;
} }

4
src/gallium/state_trackers/egl/x11/native_dri2.c
View file

@ -558,8 +558,8 @@ choose_depth_stencil_format(const __GLcontextModes *mode,
break; break;
case 24: case 24:
if (mode->stencilBits) { if (mode->stencilBits) {
formats[count++] = PIPE_FORMAT_Z24S8_UNORM; formats[count++] = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
formats[count++] = PIPE_FORMAT_S8Z24_UNORM; formats[count++] = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
} }
else { else {
formats[count++] = PIPE_FORMAT_Z24X8_UNORM; formats[count++] = PIPE_FORMAT_Z24X8_UNORM;

4
src/gallium/state_trackers/egl/x11/native_ximage.c
View file

@ -526,8 +526,8 @@ ximage_display_get_configs(struct native_display *ndpy, int *num_configs)
xconf->base.stencil_format = PIPE_FORMAT_NONE; xconf->base.stencil_format = PIPE_FORMAT_NONE;
/* create the second config with depth/stencil buffer */ /* create the second config with depth/stencil buffer */
if (j == 1) { if (j == 1) {
xconf->base.depth_format = PIPE_FORMAT_Z24S8_UNORM; xconf->base.depth_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
xconf->base.stencil_format = PIPE_FORMAT_Z24S8_UNORM; xconf->base.stencil_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
mode->depthBits = 24; mode->depthBits = 24;
mode->stencilBits = 8; mode->stencilBits = 8;
mode->haveDepthBuffer = TRUE; mode->haveDepthBuffer = TRUE;

4
src/gallium/state_trackers/glx/xlib/xm_api.c
View file

@ -355,8 +355,8 @@ choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil)
formats[count++] = PIPE_FORMAT_Z24X8_UNORM; formats[count++] = PIPE_FORMAT_Z24X8_UNORM;
} }
if (depth <= 24 && stencil <= 8) { if (depth <= 24 && stencil <= 8) {
formats[count++] = PIPE_FORMAT_S8Z24_UNORM; formats[count++] = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
formats[count++] = PIPE_FORMAT_Z24S8_UNORM; formats[count++] = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
} }
if (depth <= 32 && stencil == 0) { if (depth <= 32 && stencil == 0) {
formats[count++] = PIPE_FORMAT_Z32_UNORM; formats[count++] = PIPE_FORMAT_Z32_UNORM;

2
src/gallium/state_trackers/vega/vg_tracker.c
View file

@ -208,7 +208,7 @@ struct st_framebuffer * st_create_framebuffer(const void *visual,
if (stencilFormat == depthFormat) if (stencilFormat == depthFormat)
stfb->dsrb = st_new_renderbuffer_fb(stencilFormat); stfb->dsrb = st_new_renderbuffer_fb(stencilFormat);
else else
stfb->dsrb = st_new_renderbuffer_fb(PIPE_FORMAT_Z24S8_UNORM); stfb->dsrb = st_new_renderbuffer_fb(PIPE_FORMAT_Z24_UNORM_S8_USCALED);
/*### currently we always allocate it but it's possible it's /*### currently we always allocate it but it's possible it's
not necessary if EGL_ALPHA_MASK_SIZE was 0 not necessary if EGL_ALPHA_MASK_SIZE was 0

4
src/gallium/state_trackers/wgl/stw_pixelformat.c
View file

@ -96,8 +96,8 @@ stw_pf_depth_stencil[] = {
{ PIPE_FORMAT_Z24X8_UNORM, {24, 0} }, { PIPE_FORMAT_Z24X8_UNORM, {24, 0} },
{ PIPE_FORMAT_Z16_UNORM, {16, 0} }, { PIPE_FORMAT_Z16_UNORM, {16, 0} },
/* combined depth-stencil */ /* combined depth-stencil */
{ PIPE_FORMAT_Z24S8_UNORM, {24, 8} }, { PIPE_FORMAT_Z24_UNORM_S8_USCALED, {24, 8} },
{ PIPE_FORMAT_S8Z24_UNORM, {24, 8} } { PIPE_FORMAT_S8_USCALED_Z24_UNORM, {24, 8} }
}; };

4
src/gallium/state_trackers/xorg/xorg_dri2.c
View file

@ -122,7 +122,7 @@ dri2_do_create_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int form
} }
} else { } else {
template.format = ms->ds_depth_bits_last ? template.format = ms->ds_depth_bits_last ?
PIPE_FORMAT_Z24S8_UNORM : PIPE_FORMAT_S8Z24_UNORM; PIPE_FORMAT_Z24_UNORM_S8_USCALED : PIPE_FORMAT_S8_USCALED_Z24_UNORM;
} }
template.width0 = pDraw->width; template.width0 = pDraw->width;
template.height0 = pDraw->height; template.height0 = pDraw->height;
@ -439,7 +439,7 @@ xorg_dri2_init(ScreenPtr pScreen)
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0); PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
ms->ds_depth_bits_last = ms->ds_depth_bits_last =
ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24S8_UNORM, ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0); PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);

12
src/mesa/state_tracker/st_cb_drawpixels.c
View file

@ -735,14 +735,14 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
/* now pack the stencil (and Z) values in the dest format */ /* now pack the stencil (and Z) values in the dest format */
switch (pt->texture->format) { switch (pt->texture->format) {
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
{ {
ubyte *dest = stmap + spanY * pt->stride + spanX; ubyte *dest = stmap + spanY * pt->stride + spanX;
assert(usage == PIPE_TRANSFER_WRITE); assert(usage == PIPE_TRANSFER_WRITE);
memcpy(dest, sValues, spanWidth); memcpy(dest, sValues, spanWidth);
} }
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
if (format == GL_DEPTH_STENCIL) { if (format == GL_DEPTH_STENCIL) {
uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4); uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
GLint k; GLint k;
@ -760,7 +760,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
} }
} }
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
if (format == GL_DEPTH_STENCIL) { if (format == GL_DEPTH_STENCIL) {
uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4); uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
GLint k; GLint k;
@ -913,7 +913,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
src = buffer + i * width; src = buffer + i * width;
switch (ptDraw->texture->format) { switch (ptDraw->texture->format) {
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
{ {
uint *dst4 = (uint *) dst; uint *dst4 = (uint *) dst;
int j; int j;
@ -924,7 +924,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
} }
} }
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
{ {
uint *dst4 = (uint *) dst; uint *dst4 = (uint *) dst;
int j; int j;
@ -935,7 +935,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
} }
} }
break; break;
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
assert(usage == PIPE_TRANSFER_WRITE); assert(usage == PIPE_TRANSFER_WRITE);
memcpy(dst, src, width); memcpy(dst, src, width);
break; break;

6
src/mesa/state_tracker/st_cb_fbo.c
View file

@ -255,13 +255,13 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
case PIPE_FORMAT_Z32_UNORM: case PIPE_FORMAT_Z32_UNORM:
strb->Base.InternalFormat = GL_DEPTH_COMPONENT32; strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT; strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
break; break;
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT; strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
break; break;
case PIPE_FORMAT_R16G16B16A16_SNORM: case PIPE_FORMAT_R16G16B16A16_SNORM:

10
src/mesa/state_tracker/st_cb_readpixels.c
View file

@ -103,13 +103,13 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
/* get stencil (and Z) values */ /* get stencil (and Z) values */
switch (pt->texture->format) { switch (pt->texture->format) {
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
{ {
const ubyte *src = stmap + srcY * pt->stride; const ubyte *src = stmap + srcY * pt->stride;
memcpy(sValues, src, width); memcpy(sValues, src, width);
} }
break; break;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
if (format == GL_DEPTH_STENCIL) { if (format == GL_DEPTH_STENCIL) {
const uint *src = (uint *) (stmap + srcY * pt->stride); const uint *src = (uint *) (stmap + srcY * pt->stride);
const GLfloat scale = 1.0f / (0xffffff); const GLfloat scale = 1.0f / (0xffffff);
@ -127,7 +127,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
} }
} }
break; break;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
if (format == GL_DEPTH_STENCIL) { if (format == GL_DEPTH_STENCIL) {
const uint *src = (uint *) (stmap + srcY * pt->stride); const uint *src = (uint *) (stmap + srcY * pt->stride);
const GLfloat scale = 1.0f / (0xffffff); const GLfloat scale = 1.0f / (0xffffff);
@ -437,7 +437,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width, const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width,
format, type); format, type);
if (trans->texture->format == PIPE_FORMAT_Z24S8_UNORM || if (trans->texture->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
trans->texture->format == PIPE_FORMAT_Z24X8_UNORM) { trans->texture->format == PIPE_FORMAT_Z24X8_UNORM) {
if (format == GL_DEPTH_COMPONENT) { if (format == GL_DEPTH_COMPONENT) {
for (i = 0; i < height; i++) { for (i = 0; i < height; i++) {
@ -469,7 +469,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
} }
} }
} }
else if (trans->texture->format == PIPE_FORMAT_S8Z24_UNORM || else if (trans->texture->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
trans->texture->format == PIPE_FORMAT_X8Z24_UNORM) { trans->texture->format == PIPE_FORMAT_X8Z24_UNORM) {
if (format == GL_DEPTH_COMPONENT) { if (format == GL_DEPTH_COMPONENT) {
for (i = 0; i < height; i++) { for (i = 0; i < height; i++) {

8
src/mesa/state_tracker/st_extensions.c
View file

@ -281,18 +281,18 @@ void st_init_extensions(struct st_context *st)
/* GL_EXT_packed_depth_stencil requires both the ability to render to /* GL_EXT_packed_depth_stencil requires both the ability to render to
* a depth/stencil buffer and texture from depth/stencil source. * a depth/stencil buffer and texture from depth/stencil source.
*/ */
if (screen->is_format_supported(screen, PIPE_FORMAT_S8Z24_UNORM, if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0) && PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0) &&
screen->is_format_supported(screen, PIPE_FORMAT_S8Z24_UNORM, screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_SAMPLER, 0)) { PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE; ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
} }
else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24S8_UNORM, else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0) && PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0) &&
screen->is_format_supported(screen, PIPE_FORMAT_Z24S8_UNORM, screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, PIPE_TEXTURE_2D,
PIPE_TEXTURE_USAGE_SAMPLER, 0)) { PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE; ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;

46
src/mesa/state_tracker/st_format.c
View file

@ -76,8 +76,8 @@ st_format_datatype(enum pipe_format format)
format == PIPE_FORMAT_B5G6R5_UNORM) { format == PIPE_FORMAT_B5G6R5_UNORM) {
return GL_UNSIGNED_SHORT; return GL_UNSIGNED_SHORT;
} }
else if (format == PIPE_FORMAT_Z24S8_UNORM || else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
format == PIPE_FORMAT_S8Z24_UNORM) { format == PIPE_FORMAT_S8_USCALED_Z24_UNORM) {
return GL_UNSIGNED_INT_24_8; return GL_UNSIGNED_INT_24_8;
} }
else { else {
@ -151,9 +151,9 @@ st_mesa_format_to_pipe_format(gl_format mesaFormat)
case MESA_FORMAT_Z32: case MESA_FORMAT_Z32:
return PIPE_FORMAT_Z32_UNORM; return PIPE_FORMAT_Z32_UNORM;
case MESA_FORMAT_Z24_S8: case MESA_FORMAT_Z24_S8:
return PIPE_FORMAT_S8Z24_UNORM; return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
case MESA_FORMAT_S8_Z24: case MESA_FORMAT_S8_Z24:
return PIPE_FORMAT_Z24S8_UNORM; return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
case MESA_FORMAT_YCBCR: case MESA_FORMAT_YCBCR:
return PIPE_FORMAT_UYVY; return PIPE_FORMAT_UYVY;
#if FEATURE_texture_s3tc #if FEATURE_texture_s3tc
@ -224,7 +224,7 @@ st_pipe_format_to_mesa_format(enum pipe_format format)
return MESA_FORMAT_L8; return MESA_FORMAT_L8;
case PIPE_FORMAT_I8_UNORM: case PIPE_FORMAT_I8_UNORM:
return MESA_FORMAT_I8; return MESA_FORMAT_I8;
case PIPE_FORMAT_S8_UNORM: case PIPE_FORMAT_S8_USCALED:
return MESA_FORMAT_S8; return MESA_FORMAT_S8;
case PIPE_FORMAT_R16G16B16A16_SNORM: case PIPE_FORMAT_R16G16B16A16_SNORM:
@ -234,13 +234,13 @@ st_pipe_format_to_mesa_format(enum pipe_format format)
return MESA_FORMAT_Z16; return MESA_FORMAT_Z16;
case PIPE_FORMAT_Z32_UNORM: case PIPE_FORMAT_Z32_UNORM:
return MESA_FORMAT_Z32; return MESA_FORMAT_Z32;
case PIPE_FORMAT_S8Z24_UNORM: case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
return MESA_FORMAT_Z24_S8; return MESA_FORMAT_Z24_S8;
case PIPE_FORMAT_X8Z24_UNORM: case PIPE_FORMAT_X8Z24_UNORM:
return MESA_FORMAT_Z24_X8; return MESA_FORMAT_Z24_X8;
case PIPE_FORMAT_Z24X8_UNORM: case PIPE_FORMAT_Z24X8_UNORM:
return MESA_FORMAT_X8_Z24; return MESA_FORMAT_X8_Z24;
case PIPE_FORMAT_Z24S8_UNORM: case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
return MESA_FORMAT_S8_Z24; return MESA_FORMAT_S8_Z24;
case PIPE_FORMAT_UYVY: case PIPE_FORMAT_UYVY:
@ -393,8 +393,8 @@ default_depth_format(struct pipe_screen *screen,
static const enum pipe_format zFormats[] = { static const enum pipe_format zFormats[] = {
PIPE_FORMAT_Z16_UNORM, PIPE_FORMAT_Z16_UNORM,
PIPE_FORMAT_Z32_UNORM, PIPE_FORMAT_Z32_UNORM,
PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_FORMAT_S8Z24_UNORM PIPE_FORMAT_S8_USCALED_Z24_UNORM
}; };
uint i; uint i;
for (i = 0; i < Elements(zFormats); i++) { for (i = 0; i < Elements(zFormats); i++) {
@ -546,10 +546,10 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
return PIPE_FORMAT_Z16_UNORM; return PIPE_FORMAT_Z16_UNORM;
/* fall-through */ /* fall-through */
case GL_DEPTH_COMPONENT24: case GL_DEPTH_COMPONENT24:
if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED, target, tex_usage, geom_flags ))
return PIPE_FORMAT_Z24S8_UNORM; return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM, target, tex_usage, geom_flags ))
return PIPE_FORMAT_S8Z24_UNORM; return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
/* fall-through */ /* fall-through */
case GL_DEPTH_COMPONENT32: case GL_DEPTH_COMPONENT32:
if (screen->is_format_supported( screen, PIPE_FORMAT_Z32_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_Z32_UNORM, target, tex_usage, geom_flags ))
@ -563,20 +563,20 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_STENCIL_INDEX4_EXT: case GL_STENCIL_INDEX4_EXT:
case GL_STENCIL_INDEX8_EXT: case GL_STENCIL_INDEX8_EXT:
case GL_STENCIL_INDEX16_EXT: case GL_STENCIL_INDEX16_EXT:
if (screen->is_format_supported( screen, PIPE_FORMAT_S8_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_S8_USCALED, target, tex_usage, geom_flags ))
return PIPE_FORMAT_S8_UNORM; return PIPE_FORMAT_S8_USCALED;
if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED, target, tex_usage, geom_flags ))
return PIPE_FORMAT_Z24S8_UNORM; return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM, target, tex_usage, geom_flags ))
return PIPE_FORMAT_S8Z24_UNORM; return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
return PIPE_FORMAT_NONE; return PIPE_FORMAT_NONE;
case GL_DEPTH_STENCIL_EXT: case GL_DEPTH_STENCIL_EXT:
case GL_DEPTH24_STENCIL8_EXT: case GL_DEPTH24_STENCIL8_EXT:
if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED, target, tex_usage, geom_flags ))
return PIPE_FORMAT_Z24S8_UNORM; return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags )) if (screen->is_format_supported( screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM, target, tex_usage, geom_flags ))
return PIPE_FORMAT_S8Z24_UNORM; return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
return PIPE_FORMAT_NONE; return PIPE_FORMAT_NONE;
case GL_SRGB_EXT: case GL_SRGB_EXT: