static void GLAPIENTRY
_mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
/* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
return;
}
if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
/* test that mapsize is a power of two */
if (!_mesa_is_pow_two(mapsize)) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
return;
}
}
FLUSH_VERTICES(ctx, _NEW_PIXEL);
if (!values) {
return;
}
store_pixelmap(ctx, map, mapsize, values);
}
void GLAPIENTRY
_mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
/* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
return;
}
if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
/* test that mapsize is a power of two */
if (!_mesa_is_pow_two(mapsize)) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
return;
}
}
FLUSH_VERTICES(ctx, _NEW_PIXEL);
if (ctx->Unpack.BufferObj->Name) {
/* unpack pixelmap from PBO */
GLubyte *buf;
/* Note, need to use DefaultPacking and Unpack's buffer object */
ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
GL_INTENSITY, GL_FLOAT, values)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glPixelMapfv(invalid PBO access)");
return;
}
/* restore */
ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
GL_READ_ONLY_ARB,
ctx->Unpack.BufferObj);
if (!buf) {
/* buffer is already mapped - that's an error */
_mesa_error(ctx, GL_INVALID_OPERATION,
"glPixelMapfv(PBO is mapped)");
return;
}
values = (const GLfloat *) ADD_POINTERS(buf, values);
}
else if (!values) {
return;
}
store_pixelmap(ctx, map, mapsize, values);
if (ctx->Unpack.BufferObj->Name) {
ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
ctx->Unpack.BufferObj);
}
}
/**
* Code that overrides ctx->Driver.AllocTextureImageBuffer may use this to
* initialize the fields of swrast_texture_image without allocating the image
* buffer or initializing ImageOffsets or RowStride.
*
* Returns GL_TRUE on success, GL_FALSE on memory allocation failure.
*/
void
_swrast_init_texture_image(struct gl_texture_image *texImage, GLsizei width,
GLsizei height, GLsizei depth)
{
struct swrast_texture_image *swImg = swrast_texture_image(texImage);
if ((width == 1 || _mesa_is_pow_two(texImage->Width2)) &&
(height == 1 || _mesa_is_pow_two(texImage->Height2)) &&
(depth == 1 || _mesa_is_pow_two(texImage->Depth2)))
swImg->_IsPowerOfTwo = GL_TRUE;
else
swImg->_IsPowerOfTwo = GL_FALSE;
/* Compute Width/Height/DepthScale for mipmap lod computation */
swImg->WidthScale = (GLfloat) texImage->Width;
swImg->HeightScale = (GLfloat) texImage->Height;
swImg->DepthScale = (GLfloat) texImage->Depth;
}
static void GLAPIENTRY
_mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
{
GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );
return;
}
if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
/* test that mapsize is a power of two */
if (!_mesa_is_pow_two(mapsize)) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
return;
}
}
FLUSH_VERTICES(ctx, _NEW_PIXEL);
if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, GL_INTENSITY,
GL_UNSIGNED_SHORT, INT_MAX, values)) {
return;
}
values = (const GLushort *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
if (!values) {
if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glPixelMapusv(PBO is mapped)");
}
return;
}
/* convert to floats */
if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
GLint i;
for (i = 0; i < mapsize; i++) {
fvalues[i] = (GLfloat) values[i];
}
}
else {
GLint i;
for (i = 0; i < mapsize; i++) {
fvalues[i] = USHORT_TO_FLOAT( values[i] );
}
}
_mesa_unmap_pbo_source(ctx, &ctx->Unpack);
store_pixelmap(ctx, map, mapsize, fvalues);
}
static void GLAPIENTRY
_mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
{
GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );
return;
}
if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
/* test that mapsize is a power of two */
if (!_mesa_is_pow_two(mapsize)) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
return;
}
}
FLUSH_VERTICES(ctx, _NEW_PIXEL);
if (!values) {
return;
}
/* convert to floats */
if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
GLint i;
for (i = 0; i < mapsize; i++) {
fvalues[i] = (GLfloat) values[i];
}
}
else {
GLint i;
for (i = 0; i < mapsize; i++) {
fvalues[i] = USHORT_TO_FLOAT( values[i] );
}
}
store_pixelmap(ctx, map, mapsize, fvalues);
}
unsigned get_texture_image_row_stride(radeonContextPtr rmesa, mesa_format format, unsigned width, unsigned tiling, GLuint target)
{
if (_mesa_is_format_compressed(format)) {
return get_aligned_compressed_row_stride(format, width, rmesa->texture_compressed_row_align);
} else {
unsigned row_align;
if (!_mesa_is_pow_two(width) || target == GL_TEXTURE_RECTANGLE) {
row_align = rmesa->texture_rect_row_align - 1;
} else if (tiling) {
unsigned tileWidth, tileHeight;
get_tile_size(format, &tileWidth, &tileHeight);
row_align = tileWidth * _mesa_get_format_bytes(format) - 1;
} else {
row_align = rmesa->texture_row_align - 1;
}
return (_mesa_format_row_stride(format, width) + row_align) & ~row_align;
}
}
static void GLAPIENTRY
_mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
/* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
return;
}
if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
/* test that mapsize is a power of two */
if (!_mesa_is_pow_two(mapsize)) {
_mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
return;
}
}
FLUSH_VERTICES(ctx, _NEW_PIXEL);
if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, GL_INTENSITY,
GL_FLOAT, INT_MAX, values)) {
return;
}
values = (const GLfloat *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
if (!values) {
if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glPixelMapfv(PBO is mapped)");
}
return;
}
store_pixelmap(ctx, map, mapsize, values);
_mesa_unmap_pbo_source(ctx, &ctx->Unpack);
}
void GLAPIENTRY
_mesa_ColorTable( GLenum target, GLenum internalFormat,
GLsizei width, GLenum format, GLenum type,
const GLvoid *data )
{
static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };
static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };
GET_CURRENT_CONTEXT(ctx);
struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
struct gl_texture_object *texObj = NULL;
struct gl_color_table *table = NULL;
GLboolean proxy = GL_FALSE;
GLint baseFormat;
const GLfloat *scale = one, *bias = zero;
GLint comps;
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
switch (target) {
case GL_SHARED_TEXTURE_PALETTE_EXT:
table = &ctx->Texture.Palette;
break;
case GL_COLOR_TABLE:
table = &ctx->ColorTable[COLORTABLE_PRECONVOLUTION];
scale = ctx->Pixel.ColorTableScale[COLORTABLE_PRECONVOLUTION];
bias = ctx->Pixel.ColorTableBias[COLORTABLE_PRECONVOLUTION];
break;
case GL_PROXY_COLOR_TABLE:
table = &ctx->ProxyColorTable[COLORTABLE_PRECONVOLUTION];
proxy = GL_TRUE;
break;
case GL_TEXTURE_COLOR_TABLE_SGI:
if (!ctx->Extensions.SGI_texture_color_table) {
_mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
return;
}
table = &(texUnit->ColorTable);
scale = ctx->Pixel.TextureColorTableScale;
bias = ctx->Pixel.TextureColorTableBias;
break;
case GL_PROXY_TEXTURE_COLOR_TABLE_SGI:
if (!ctx->Extensions.SGI_texture_color_table) {
_mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
return;
}
table = &(texUnit->ProxyColorTable);
proxy = GL_TRUE;
break;
case GL_POST_CONVOLUTION_COLOR_TABLE:
table = &ctx->ColorTable[COLORTABLE_POSTCONVOLUTION];
scale = ctx->Pixel.ColorTableScale[COLORTABLE_POSTCONVOLUTION];
bias = ctx->Pixel.ColorTableBias[COLORTABLE_POSTCONVOLUTION];
break;
case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
table = &ctx->ProxyColorTable[COLORTABLE_POSTCONVOLUTION];
proxy = GL_TRUE;
break;
case GL_POST_COLOR_MATRIX_COLOR_TABLE:
table = &ctx->ColorTable[COLORTABLE_POSTCOLORMATRIX];
scale = ctx->Pixel.ColorTableScale[COLORTABLE_POSTCOLORMATRIX];
bias = ctx->Pixel.ColorTableBias[COLORTABLE_POSTCOLORMATRIX];
break;
case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
table = &ctx->ProxyColorTable[COLORTABLE_POSTCOLORMATRIX];
proxy = GL_TRUE;
break;
default:
/* try texture targets */
{
struct gl_texture_object *texobj
= _mesa_select_tex_object(ctx, texUnit, target);
if (texobj) {
table = &texobj->Palette;
proxy = _mesa_is_proxy_texture(target);
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
return;
}
}
}
assert(table);
if (!_mesa_is_legal_format_and_type(ctx, format, type) ||
format == GL_INTENSITY) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)");
return;
}
baseFormat = base_colortab_format(internalFormat);
if (baseFormat < 0) {
_mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
return;
}
if (width < 0 || (width != 0 && !_mesa_is_pow_two(width))) {
/* error */
if (proxy) {
table->Size = 0;
table->InternalFormat = (GLenum) 0;
table->_BaseFormat = (GLenum) 0;
}
else {
_mesa_error(ctx, GL_INVALID_VALUE, "glColorTable(width=%d)", width);
}
return;
}
if (width > (GLsizei) ctx->Const.MaxColorTableSize) {
if (proxy) {
table->Size = 0;
table->InternalFormat = (GLenum) 0;
table->_BaseFormat = (GLenum) 0;
}
else {
_mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
}
return;
}
table->Size = width;
table->InternalFormat = internalFormat;
table->_BaseFormat = (GLenum) baseFormat;
comps = _mesa_components_in_format(table->_BaseFormat);
assert(comps > 0); /* error should have been caught sooner */
if (!proxy) {
_mesa_free_colortable_data(table);
if (width > 0) {
table->TableF = (GLfloat *) _mesa_malloc(comps * width * sizeof(GLfloat));
table->TableUB = (GLubyte *) _mesa_malloc(comps * width * sizeof(GLubyte));
if (!table->TableF || !table->TableUB) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
return;
}
store_colortable_entries(ctx, table,
0, width, /* start, count */
format, type, data,
scale[0], bias[0],
scale[1], bias[1],
scale[2], bias[2],
scale[3], bias[3]);
}
} /* proxy */
/* do this after the table's Type and Format are set */
set_component_sizes(table);
if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
/* texture object palette, texObj==NULL means the shared palette */
if (ctx->Driver.UpdateTexturePalette) {
(*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
}
}
ctx->NewState |= _NEW_PIXEL;
}
static void
setup_glsl_msaa_blit_scaled_shader(struct gl_context *ctx,
struct blit_state *blit,
struct gl_renderbuffer *src_rb,
GLenum target, GLenum filter)
{
GLint loc_src_width, loc_src_height;
int i, samples;
int shader_offset = 0;
void *mem_ctx = ralloc_context(NULL);
char *fs_source;
char *name, *sample_number;
const uint8_t *sample_map;
char *sample_map_str = rzalloc_size(mem_ctx, 1);
char *sample_map_expr = rzalloc_size(mem_ctx, 1);
char *texel_fetch_macro = rzalloc_size(mem_ctx, 1);
const char *sampler_array_suffix = "";
float y_scale;
enum blit_msaa_shader shader_index;
assert(src_rb);
samples = MAX2(src_rb->NumSamples, 1);
y_scale = samples * 0.5;
/* We expect only power of 2 samples in source multisample buffer. */
assert(samples > 0 && _mesa_is_pow_two(samples));
while (samples >> (shader_offset + 1)) {
shader_offset++;
}
/* Update the assert if we plan to support more than 8X MSAA. */
assert(shader_offset > 0 && shader_offset < 4);
assert(target == GL_TEXTURE_2D_MULTISAMPLE ||
target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
shader_index = BLIT_2X_MSAA_SHADER_2D_MULTISAMPLE_SCALED_RESOLVE +
shader_offset - 1;
if (target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY) {
shader_index += BLIT_2X_MSAA_SHADER_2D_MULTISAMPLE_ARRAY_SCALED_RESOLVE -
BLIT_2X_MSAA_SHADER_2D_MULTISAMPLE_SCALED_RESOLVE;
sampler_array_suffix = "Array";
}
if (blit->msaa_shaders[shader_index]) {
_mesa_UseProgram(blit->msaa_shaders[shader_index]);
/* Update the uniform values. */
loc_src_width =
_mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
loc_src_height =
_mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
_mesa_Uniform1f(loc_src_width, src_rb->Width);
_mesa_Uniform1f(loc_src_height, src_rb->Height);
return;
}
name = ralloc_asprintf(mem_ctx, "vec4 MSAA scaled resolve");
/* Below switch is used to setup the shader expression, which computes
* sample index and map it to to a sample number on hardware.
*/
switch(samples) {
case 2:
sample_number = "sample_map[int(2 * fract(coord.x))]";
sample_map = ctx->Const.SampleMap2x;
break;
case 4:
sample_number = "sample_map[int(2 * fract(coord.x) + 4 * fract(coord.y))]";
sample_map = ctx->Const.SampleMap4x;
break;
case 8:
sample_number = "sample_map[int(2 * fract(coord.x) + 8 * fract(coord.y))]";
sample_map = ctx->Const.SampleMap8x;
break;
default:
sample_number = NULL;
sample_map = NULL;
_mesa_problem(ctx, "Unsupported sample count %d\n", samples);
unreachable("Unsupported sample count");
}
/* Create sample map string. */
for (i = 0 ; i < samples - 1; i++) {
ralloc_asprintf_append(&sample_map_str, "%d, ", sample_map[i]);
}
ralloc_asprintf_append(&sample_map_str, "%d", sample_map[samples - 1]);
/* Create sample map expression using above string. */
ralloc_asprintf_append(&sample_map_expr,
" const int sample_map[%d] = int[%d](%s);\n",
samples, samples, sample_map_str);
if (target == GL_TEXTURE_2D_MULTISAMPLE) {
ralloc_asprintf_append(&texel_fetch_macro,
"#define TEXEL_FETCH(coord) texelFetch(texSampler, ivec2(coord), %s);\n",
sample_number);
} else {
ralloc_asprintf_append(&texel_fetch_macro,
"#define TEXEL_FETCH(coord) texelFetch(texSampler, ivec3(coord, layer), %s);\n",
sample_number);
}
static const char vs_source[] =
"#version 130\n"
"in vec2 position;\n"
"in vec3 textureCoords;\n"
"out vec2 texCoords;\n"
"flat out int layer;\n"
"void main()\n"
"{\n"
" texCoords = textureCoords.xy;\n"
" layer = int(textureCoords.z);\n"
" gl_Position = vec4(position, 0.0, 1.0);\n"
"}\n"
;
fs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
"#extension GL_ARB_texture_multisample : enable\n"
"uniform sampler2DMS%s texSampler;\n"
"uniform float src_width, src_height;\n"
"in vec2 texCoords;\n"
"flat in int layer;\n"
"out vec4 out_color;\n"
"\n"
"void main()\n"
"{\n"
"%s"
" vec2 interp;\n"
" const vec2 scale = vec2(2.0f, %ff);\n"
" const vec2 scale_inv = vec2(0.5f, %ff);\n"
" const vec2 s_0_offset = vec2(0.25f, %ff);\n"
" vec2 s_0_coord, s_1_coord, s_2_coord, s_3_coord;\n"
" vec4 s_0_color, s_1_color, s_2_color, s_3_color;\n"
" vec4 x_0_color, x_1_color;\n"
" vec2 tex_coord = texCoords - s_0_offset;\n"
"\n"
" tex_coord *= scale;\n"
" clamp(tex_coord.x, 0.0f, scale.x * src_width - 1.0f);\n"
" clamp(tex_coord.y, 0.0f, scale.y * src_height - 1.0f);\n"
" interp = fract(tex_coord);\n"
" tex_coord = ivec2(tex_coord) * scale_inv;\n"
"\n"
" /* Compute the sample coordinates used for filtering. */\n"
" s_0_coord = tex_coord;\n"
" s_1_coord = tex_coord + vec2(scale_inv.x, 0.0f);\n"
" s_2_coord = tex_coord + vec2(0.0f, scale_inv.y);\n"
" s_3_coord = tex_coord + vec2(scale_inv.x, scale_inv.y);\n"
"\n"
" /* Fetch sample color values. */\n"
"%s"
" s_0_color = TEXEL_FETCH(s_0_coord)\n"
" s_1_color = TEXEL_FETCH(s_1_coord)\n"
" s_2_color = TEXEL_FETCH(s_2_coord)\n"
" s_3_color = TEXEL_FETCH(s_3_coord)\n"
"#undef TEXEL_FETCH\n"
"\n"
" /* Do bilinear filtering on sample colors. */\n"
" x_0_color = mix(s_0_color, s_1_color, interp.x);\n"
" x_1_color = mix(s_2_color, s_3_color, interp.x);\n"
" out_color = mix(x_0_color, x_1_color, interp.y);\n"
"}\n",
sampler_array_suffix,
sample_map_expr,
y_scale,
1.0f / y_scale,
1.0f / samples,
texel_fetch_macro);
_mesa_meta_compile_and_link_program(ctx, vs_source, fs_source, name,
&blit->msaa_shaders[shader_index]);
loc_src_width =
_mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_width");
loc_src_height =
_mesa_GetUniformLocation(blit->msaa_shaders[shader_index], "src_height");
_mesa_Uniform1f(loc_src_width, src_rb->Width);
_mesa_Uniform1f(loc_src_height, src_rb->Height);
ralloc_free(mem_ctx);
}
static void
setup_glsl_msaa_blit_shader(struct gl_context *ctx,
struct blit_state *blit,
const struct gl_framebuffer *drawFb,
struct gl_renderbuffer *src_rb,
GLenum target)
{
const char *vs_source;
char *fs_source;
void *mem_ctx;
enum blit_msaa_shader shader_index;
bool dst_is_msaa = false;
GLenum src_datatype;
const char *vec4_prefix;
const char *sampler_array_suffix = "";
char *name;
const char *texcoord_type = "vec2";
int samples;
int shader_offset = 0;
if (src_rb) {
samples = MAX2(src_rb->NumSamples, 1);
src_datatype = _mesa_get_format_datatype(src_rb->Format);
} else {
/* depth-or-color glCopyTexImage fallback path that passes a NULL rb and
* doesn't handle integer.
*/
samples = 1;
src_datatype = GL_UNSIGNED_NORMALIZED;
}
/* We expect only power of 2 samples in source multisample buffer. */
assert(samples > 0 && _mesa_is_pow_two(samples));
while (samples >> (shader_offset + 1)) {
shader_offset++;
}
/* Update the assert if we plan to support more than 16X MSAA. */
assert(shader_offset >= 0 && shader_offset <= 4);
if (drawFb->Visual.samples > 1) {
/* If you're calling meta_BlitFramebuffer with the destination
* multisampled, this is the only path that will work -- swrast and
* CopyTexImage won't work on it either.
*/
assert(ctx->Extensions.ARB_sample_shading);
dst_is_msaa = true;
/* We need shader invocation per sample, not per pixel */
_mesa_set_enable(ctx, GL_MULTISAMPLE, GL_TRUE);
_mesa_set_enable(ctx, GL_SAMPLE_SHADING, GL_TRUE);
_mesa_MinSampleShading(1.0);
}
switch (target) {
case GL_TEXTURE_2D_MULTISAMPLE:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
if (src_rb && (src_rb->_BaseFormat == GL_DEPTH_COMPONENT ||
src_rb->_BaseFormat == GL_DEPTH_STENCIL)) {
if (dst_is_msaa)
shader_index = BLIT_MSAA_SHADER_2D_MULTISAMPLE_DEPTH_COPY;
else
shader_index = BLIT_MSAA_SHADER_2D_MULTISAMPLE_DEPTH_RESOLVE;
} else {
if (dst_is_msaa)
shader_index = BLIT_MSAA_SHADER_2D_MULTISAMPLE_COPY;
else {
shader_index = BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE +
shader_offset;
}
}
if (target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY) {
shader_index += (BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_ARRAY_RESOLVE -
BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE);
sampler_array_suffix = "Array";
texcoord_type = "vec3";
}
break;
default:
_mesa_problem(ctx, "Unkown texture target %s\n",
_mesa_enum_to_string(target));
shader_index = BLIT_2X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE;
}
/* We rely on the enum being sorted this way. */
STATIC_ASSERT(BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE_INT ==
BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE + 5);
STATIC_ASSERT(BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE_UINT ==
BLIT_1X_MSAA_SHADER_2D_MULTISAMPLE_RESOLVE + 10);
if (src_datatype == GL_INT) {
shader_index += 5;
vec4_prefix = "i";
} else if (src_datatype == GL_UNSIGNED_INT) {
shader_index += 10;
vec4_prefix = "u";
} else {
vec4_prefix = "";
}
if (blit->msaa_shaders[shader_index]) {
_mesa_UseProgram(blit->msaa_shaders[shader_index]);
return;
}
mem_ctx = ralloc_context(NULL);
if (shader_index == BLIT_MSAA_SHADER_2D_MULTISAMPLE_DEPTH_RESOLVE ||
shader_index == BLIT_MSAA_SHADER_2D_MULTISAMPLE_ARRAY_DEPTH_RESOLVE ||
shader_index == BLIT_MSAA_SHADER_2D_MULTISAMPLE_ARRAY_DEPTH_COPY ||
shader_index == BLIT_MSAA_SHADER_2D_MULTISAMPLE_DEPTH_COPY) {
char *sample_index;
const char *arb_sample_shading_extension_string;
if (dst_is_msaa) {
arb_sample_shading_extension_string = "#extension GL_ARB_sample_shading : enable";
sample_index = "gl_SampleID";
name = "depth MSAA copy";
} else {
/* Don't need that extension, since we're drawing to a single-sampled
* destination.
*/
arb_sample_shading_extension_string = "";
/* From the GL 4.3 spec:
*
* "If there is a multisample buffer (the value of SAMPLE_BUFFERS
* is one), then values are obtained from the depth samples in
* this buffer. It is recommended that the depth value of the
* centermost sample be used, though implementations may choose
* any function of the depth sample values at each pixel.
*
* We're slacking and instead of choosing centermost, we've got 0.
*/
sample_index = "0";
name = "depth MSAA resolve";
}
vs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
"in vec2 position;\n"
"in %s textureCoords;\n"
"out %s texCoords;\n"
"void main()\n"
"{\n"
" texCoords = textureCoords;\n"
" gl_Position = vec4(position, 0.0, 1.0);\n"
"}\n",
texcoord_type,
texcoord_type);
fs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
"#extension GL_ARB_texture_multisample : enable\n"
"%s\n"
"uniform sampler2DMS%s texSampler;\n"
"in %s texCoords;\n"
"out vec4 out_color;\n"
"\n"
"void main()\n"
"{\n"
" gl_FragDepth = texelFetch(texSampler, i%s(texCoords), %s).r;\n"
"}\n",
arb_sample_shading_extension_string,
sampler_array_suffix,
texcoord_type,
texcoord_type,
sample_index);
} else {
/* You can create 2D_MULTISAMPLE textures with 0 sample count (meaning 1
* sample). Yes, this is ridiculous.
*/
char *sample_resolve;
const char *arb_sample_shading_extension_string;
const char *merge_function;
name = ralloc_asprintf(mem_ctx, "%svec4 MSAA %s",
vec4_prefix,
dst_is_msaa ? "copy" : "resolve");
if (dst_is_msaa) {
arb_sample_shading_extension_string = "#extension GL_ARB_sample_shading : enable";
sample_resolve = ralloc_asprintf(mem_ctx, " out_color = texelFetch(texSampler, i%s(texCoords), gl_SampleID);", texcoord_type);
merge_function = "";
} else {
int i;
int step;
if (src_datatype == GL_INT || src_datatype == GL_UNSIGNED_INT) {
merge_function =
"gvec4 merge(gvec4 a, gvec4 b) { return (a >> gvec4(1)) + (b >> gvec4(1)) + (a & b & gvec4(1)); }\n";
} else {
/* The divide will happen at the end for floats. */
merge_function =
"vec4 merge(vec4 a, vec4 b) { return (a + b); }\n";
}
arb_sample_shading_extension_string = "";
/* We're assuming power of two samples for this resolution procedure.
*
* To avoid losing any floating point precision if the samples all
* happen to have the same value, we merge pairs of values at a time
* (so the floating point exponent just gets increased), rather than
* doing a naive sum and dividing.
*/
assert(_mesa_is_pow_two(samples));
/* Fetch each individual sample. */
sample_resolve = rzalloc_size(mem_ctx, 1);
for (i = 0; i < samples; i++) {
ralloc_asprintf_append(&sample_resolve,
" gvec4 sample_1_%d = texelFetch(texSampler, i%s(texCoords), %d);\n",
i, texcoord_type, i);
}
/* Now, merge each pair of samples, then merge each pair of those,
* etc.
*/
for (step = 2; step <= samples; step *= 2) {
for (i = 0; i < samples; i += step) {
ralloc_asprintf_append(&sample_resolve,
" gvec4 sample_%d_%d = merge(sample_%d_%d, sample_%d_%d);\n",
step, i,
step / 2, i,
step / 2, i + step / 2);
}
}
/* Scale the final result. */
if (src_datatype == GL_UNSIGNED_INT || src_datatype == GL_INT) {
ralloc_asprintf_append(&sample_resolve,
" out_color = sample_%d_0;\n",
samples);
} else {
ralloc_asprintf_append(&sample_resolve,
" gl_FragColor = sample_%d_0 / %f;\n",
samples, (float)samples);
}
}
vs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
"in vec2 position;\n"
"in %s textureCoords;\n"
"out %s texCoords;\n"
"void main()\n"
"{\n"
" texCoords = textureCoords;\n"
" gl_Position = vec4(position, 0.0, 1.0);\n"
"}\n",
texcoord_type,
texcoord_type);
fs_source = ralloc_asprintf(mem_ctx,
"#version 130\n"
"#extension GL_ARB_texture_multisample : enable\n"
"%s\n"
"#define gvec4 %svec4\n"
"uniform %ssampler2DMS%s texSampler;\n"
"in %s texCoords;\n"
"out gvec4 out_color;\n"
"\n"
"%s" /* merge_function */
"void main()\n"
"{\n"
"%s\n" /* sample_resolve */
"}\n",
arb_sample_shading_extension_string,
vec4_prefix,
vec4_prefix,
sampler_array_suffix,
texcoord_type,
merge_function,
sample_resolve);
}
_mesa_meta_compile_and_link_program(ctx, vs_source, fs_source, name,
&blit->msaa_shaders[shader_index]);
ralloc_free(mem_ctx);
}
static unsigned int
tr_mode_horizontal_texture_alignment(const struct brw_context *brw,
const struct intel_mipmap_tree *mt)
{
const unsigned *align_yf, *align_ys;
const unsigned bpp = _mesa_get_format_bytes(mt->format) * 8;
unsigned ret_align, divisor;
/* Horizontal alignment tables for TRMODE_{YF,YS}. Value in below
* tables specifies the horizontal alignment requirement in elements
* for the surface. An element is defined as a pixel in uncompressed
* surface formats, and as a compression block in compressed surface
* formats. For MSFMT_DEPTH_STENCIL type multisampled surfaces, an
* element is a sample.
*/
const unsigned align_1d_yf[] = {4096, 2048, 1024, 512, 256};
const unsigned align_1d_ys[] = {65536, 32768, 16384, 8192, 4096};
const unsigned align_2d_yf[] = {64, 64, 32, 32, 16};
const unsigned align_2d_ys[] = {256, 256, 128, 128, 64};
const unsigned align_3d_yf[] = {16, 8, 8, 8, 4};
const unsigned align_3d_ys[] = {64, 32, 32, 32, 16};
int i = 0;
/* Alignment computations below assume bpp >= 8 and a power of 2. */
assert (bpp >= 8 && bpp <= 128 && _mesa_is_pow_two(bpp));
switch(mt->target) {
case GL_TEXTURE_1D:
case GL_TEXTURE_1D_ARRAY:
align_yf = align_1d_yf;
align_ys = align_1d_ys;
break;
case GL_TEXTURE_2D:
case GL_TEXTURE_RECTANGLE:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_ARRAY:
case GL_TEXTURE_2D_MULTISAMPLE:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
align_yf = align_2d_yf;
align_ys = align_2d_ys;
break;
case GL_TEXTURE_3D:
align_yf = align_3d_yf;
align_ys = align_3d_ys;
break;
default:
unreachable("not reached");
}
/* Compute array index. */
i = ffs(bpp/8) - 1;
ret_align = mt->tr_mode == INTEL_MIPTREE_TRMODE_YF ?
align_yf[i] : align_ys[i];
assert(_mesa_is_pow_two(mt->num_samples));
switch (mt->num_samples) {
case 2:
case 4:
divisor = 2;
break;
case 8:
case 16:
divisor = 4;
break;
default:
divisor = 1;
break;
}
return ret_align / divisor;
}
static unsigned int
tr_mode_vertical_texture_alignment(const struct brw_context *brw,
const struct intel_mipmap_tree *mt)
{
const unsigned *align_yf, *align_ys;
const unsigned bpp = _mesa_get_format_bytes(mt->format) * 8;
unsigned ret_align, divisor;
/* Vertical alignment tables for TRMODE_YF and TRMODE_YS. */
const unsigned align_2d_yf[] = {64, 32, 32, 16, 16};
const unsigned align_2d_ys[] = {256, 128, 128, 64, 64};
const unsigned align_3d_yf[] = {16, 16, 16, 8, 8};
const unsigned align_3d_ys[] = {32, 32, 32, 16, 16};
int i = 0;
assert(brw->gen >= 9 &&
mt->target != GL_TEXTURE_1D &&
mt->target != GL_TEXTURE_1D_ARRAY);
/* Alignment computations below assume bpp >= 8 and a power of 2. */
assert (bpp >= 8 && bpp <= 128 && _mesa_is_pow_two(bpp)) ;
switch(mt->target) {
case GL_TEXTURE_2D:
case GL_TEXTURE_RECTANGLE:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_ARRAY:
case GL_TEXTURE_2D_MULTISAMPLE:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
align_yf = align_2d_yf;
align_ys = align_2d_ys;
break;
case GL_TEXTURE_3D:
align_yf = align_3d_yf;
align_ys = align_3d_ys;
break;
default:
unreachable("not reached");
}
/* Compute array index. */
i = ffs(bpp / 8) - 1;
ret_align = mt->tr_mode == INTEL_MIPTREE_TRMODE_YF ?
align_yf[i] : align_ys[i];
assert(_mesa_is_pow_two(mt->num_samples));
switch (mt->num_samples) {
case 4:
case 8:
divisor = 2;
break;
case 16:
divisor = 4;
break;
default:
divisor = 1;
break;
}
return ret_align / divisor;
}
static void GLAPIENTRY
_mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
{
GLuint i;
GLboolean error = GL_FALSE;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */
if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glHistogram");
return;
}
if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
_mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(target)");
return;
}
if (width < 0 || width > HISTOGRAM_TABLE_SIZE) {
if (target == GL_PROXY_HISTOGRAM) {
error = GL_TRUE;
}
else {
if (width < 0)
_mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
else
_mesa_error(ctx, GL_TABLE_TOO_LARGE, "glHistogram(width)");
return;
}
}
if (width != 0 && !_mesa_is_pow_two(width)) {
if (target == GL_PROXY_HISTOGRAM) {
error = GL_TRUE;
}
else {
_mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
return;
}
}
if (base_histogram_format(internalFormat) < 0) {
if (target == GL_PROXY_HISTOGRAM) {
error = GL_TRUE;
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(internalFormat)");
return;
}
}
FLUSH_VERTICES(ctx, _NEW_PIXEL);
/* reset histograms */
for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
ctx->Histogram.Count[i][0] = 0;
ctx->Histogram.Count[i][1] = 0;
ctx->Histogram.Count[i][2] = 0;
ctx->Histogram.Count[i][3] = 0;
}
if (error) {
ctx->Histogram.Width = 0;
ctx->Histogram.Format = 0;
ctx->Histogram.RedSize = 0;
ctx->Histogram.GreenSize = 0;
ctx->Histogram.BlueSize = 0;
ctx->Histogram.AlphaSize = 0;
ctx->Histogram.LuminanceSize = 0;
}
else {
ctx->Histogram.Width = width;
ctx->Histogram.Format = internalFormat;
ctx->Histogram.Sink = sink;
ctx->Histogram.RedSize = 8 * sizeof(GLuint);
ctx->Histogram.GreenSize = 8 * sizeof(GLuint);
ctx->Histogram.BlueSize = 8 * sizeof(GLuint);
ctx->Histogram.AlphaSize = 8 * sizeof(GLuint);
ctx->Histogram.LuminanceSize = 8 * sizeof(GLuint);
}
}
static void
nv04_surface_copy_swizzle(struct gl_context *ctx,
struct nouveau_surface *dst,
struct nouveau_surface *src,
int dx, int dy, int sx, int sy,
int w, int h)
{
struct nouveau_pushbuf_refn refs[] = {
{ src->bo, NOUVEAU_BO_RD | NOUVEAU_BO_VRAM | NOUVEAU_BO_GART },
{ dst->bo, NOUVEAU_BO_WR | NOUVEAU_BO_VRAM },
};
struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
struct nouveau_object *swzsurf = hw->swzsurf;
struct nv04_fifo *fifo = hw->chan->data;
/* Max width & height may not be the same on all HW, but must be POT */
const unsigned max_w = 1024;
const unsigned max_h = 1024;
unsigned sub_w = w > max_w ? max_w : w;
unsigned sub_h = h > max_h ? max_h : h;
unsigned x, y;
/* Swizzled surfaces must be POT */
assert(_mesa_is_pow_two(dst->width) &&
_mesa_is_pow_two(dst->height));
if (context_chipset(ctx) < 0x10) {
BEGIN_NV04(push, NV01_SUBC(SURF, OBJECT), 1);
PUSH_DATA (push, swzsurf->handle);
}
for (y = 0; y < h; y += sub_h) {
sub_h = MIN2(sub_h, h - y);
for (x = 0; x < w; x += sub_w) {
sub_w = MIN2(sub_w, w - x);
if (nouveau_pushbuf_space(push, 64, 4, 0) ||
nouveau_pushbuf_refn (push, refs, 2))
return;
BEGIN_NV04(push, NV04_SSWZ(DMA_IMAGE), 1);
PUSH_DATA (push, fifo->vram);
BEGIN_NV04(push, NV04_SSWZ(FORMAT), 2);
PUSH_DATA (push, swzsurf_format(dst->format) |
log2i(dst->width) << 16 |
log2i(dst->height) << 24);
PUSH_RELOC(push, dst->bo, dst->offset, NOUVEAU_BO_LOW, 0, 0);
BEGIN_NV04(push, NV03_SIFM(DMA_IMAGE), 1);
PUSH_RELOC(push, src->bo, 0, NOUVEAU_BO_OR, fifo->vram, fifo->gart);
BEGIN_NV04(push, NV05_SIFM(SURFACE), 1);
PUSH_DATA (push, swzsurf->handle);
BEGIN_NV04(push, NV03_SIFM(COLOR_FORMAT), 8);
PUSH_DATA (push, sifm_format(src->format));
PUSH_DATA (push, NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY);
PUSH_DATA (push, (y + dy) << 16 | (x + dx));
PUSH_DATA (push, sub_h << 16 | sub_w);
PUSH_DATA (push, (y + dy) << 16 | (x + dx));
PUSH_DATA (push, sub_h << 16 | sub_w);
PUSH_DATA (push, 1 << 20);
PUSH_DATA (push, 1 << 20);
BEGIN_NV04(push, NV03_SIFM(SIZE), 4);
PUSH_DATA (push, align(sub_h, 2) << 16 | align(sub_w, 2));
PUSH_DATA (push, src->pitch |
NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER |
NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE);
PUSH_RELOC(push, src->bo, src->offset + (y + sy) * src->pitch +
(x + sx) * src->cpp, NOUVEAU_BO_LOW, 0, 0);
PUSH_DATA (push, 0);
}
}
if (context_chipset(ctx) < 0x10) {
BEGIN_NV04(push, NV01_SUBC(SURF, OBJECT), 1);
PUSH_DATA (push, hw->surf3d->handle);
}
}
