From a0c4815433ccd57322f4f7703ca35e9ccfa59250 Mon Sep 17 00:00:00 2001 From: marha Date: Thu, 8 Oct 2009 13:15:52 +0000 Subject: Added MesaLib-7.6 --- mesalib/src/mesa/main/convolve.c | 1427 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 1427 insertions(+) create mode 100644 mesalib/src/mesa/main/convolve.c (limited to 'mesalib/src/mesa/main/convolve.c') diff --git a/mesalib/src/mesa/main/convolve.c b/mesalib/src/mesa/main/convolve.c new file mode 100644 index 000000000..70951112a --- /dev/null +++ b/mesalib/src/mesa/main/convolve.c @@ -0,0 +1,1427 @@ +/* + * Mesa 3-D graphics library + * Version: 6.5.2 + * + * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +/* + * Image convolution functions. + * + * Notes: filter kernel elements are indexed by and as in + * the GL spec. + */ + + +#include "glheader.h" +#include "bufferobj.h" +#include "colormac.h" +#include "convolve.h" +#include "context.h" +#include "image.h" +#include "mtypes.h" +#include "pixel.h" +#include "state.h" + + +/* + * Given an internalFormat token passed to glConvolutionFilter + * or glSeparableFilter, return the corresponding base format. + * Return -1 if invalid token. + */ +static GLint +base_filter_format( GLenum format ) +{ + switch (format) { + case GL_ALPHA: + case GL_ALPHA4: + case GL_ALPHA8: + case GL_ALPHA12: + case GL_ALPHA16: + return GL_ALPHA; + case GL_LUMINANCE: + case GL_LUMINANCE4: + case GL_LUMINANCE8: + case GL_LUMINANCE12: + case GL_LUMINANCE16: + return GL_LUMINANCE; + case GL_LUMINANCE_ALPHA: + case GL_LUMINANCE4_ALPHA4: + case GL_LUMINANCE6_ALPHA2: + case GL_LUMINANCE8_ALPHA8: + case GL_LUMINANCE12_ALPHA4: + case GL_LUMINANCE12_ALPHA12: + case GL_LUMINANCE16_ALPHA16: + return GL_LUMINANCE_ALPHA; + case GL_INTENSITY: + case GL_INTENSITY4: + case GL_INTENSITY8: + case GL_INTENSITY12: + case GL_INTENSITY16: + return GL_INTENSITY; + case GL_RGB: + case GL_R3_G3_B2: + case GL_RGB4: + case GL_RGB5: + case GL_RGB8: + case GL_RGB10: + case GL_RGB12: + case GL_RGB16: + return GL_RGB; + case 4: + case GL_RGBA: + case GL_RGBA2: + case GL_RGBA4: + case GL_RGB5_A1: + case GL_RGBA8: + case GL_RGB10_A2: + case GL_RGBA12: + case GL_RGBA16: + return GL_RGBA; + default: + return -1; /* error */ + } +} + + +void GLAPIENTRY +_mesa_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) +{ + GLint baseFormat; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (target != GL_CONVOLUTION_1D) { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(target)"); + return; + } + + baseFormat = base_filter_format(internalFormat); + if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(internalFormat)"); + return; + } + + if (width < 0 || width > MAX_CONVOLUTION_WIDTH) { + _mesa_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter1D(width)"); + return; + } + + if (!_mesa_is_legal_format_and_type(ctx, format, type)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glConvolutionFilter1D(format or type)"); + return; + } + + if (format == GL_COLOR_INDEX || + format == GL_STENCIL_INDEX || + format == GL_DEPTH_COMPONENT || + format == GL_INTENSITY || + type == GL_BITMAP) { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(format or type)"); + return; + } + + ctx->Convolution1D.Format = format; + ctx->Convolution1D.InternalFormat = internalFormat; + ctx->Convolution1D.Width = width; + ctx->Convolution1D.Height = 1; + + image = _mesa_map_validate_pbo_source(ctx, + 1, &ctx->Unpack, width, 1, 1, + format, type, image, + "glConvolutionFilter1D"); + if (!image) + return; + + _mesa_unpack_color_span_float(ctx, width, GL_RGBA, + ctx->Convolution1D.Filter, + format, type, image, &ctx->Unpack, + 0); /* transferOps */ + + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); + + _mesa_scale_and_bias_rgba(width, + (GLfloat (*)[4]) ctx->Convolution1D.Filter, + ctx->Pixel.ConvolutionFilterScale[0][0], + ctx->Pixel.ConvolutionFilterScale[0][1], + ctx->Pixel.ConvolutionFilterScale[0][2], + ctx->Pixel.ConvolutionFilterScale[0][3], + ctx->Pixel.ConvolutionFilterBias[0][0], + ctx->Pixel.ConvolutionFilterBias[0][1], + ctx->Pixel.ConvolutionFilterBias[0][2], + ctx->Pixel.ConvolutionFilterBias[0][3]); + + ctx->NewState |= _NEW_PIXEL; +} + + +void GLAPIENTRY +_mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) +{ + GLint baseFormat; + GLint i; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (target != GL_CONVOLUTION_2D) { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(target)"); + return; + } + + baseFormat = base_filter_format(internalFormat); + if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(internalFormat)"); + return; + } + + if (width < 0 || width > MAX_CONVOLUTION_WIDTH) { + _mesa_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter2D(width)"); + return; + } + if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) { + _mesa_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter2D(height)"); + return; + } + + if (!_mesa_is_legal_format_and_type(ctx, format, type)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glConvolutionFilter2D(format or type)"); + return; + } + if (format == GL_COLOR_INDEX || + format == GL_STENCIL_INDEX || + format == GL_DEPTH_COMPONENT || + format == GL_INTENSITY || + type == GL_BITMAP) { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(format or type)"); + return; + } + + /* this should have been caught earlier */ + assert(_mesa_components_in_format(format)); + + ctx->Convolution2D.Format = format; + ctx->Convolution2D.InternalFormat = internalFormat; + ctx->Convolution2D.Width = width; + ctx->Convolution2D.Height = height; + + image = _mesa_map_validate_pbo_source(ctx, + 2, &ctx->Unpack, width, height, 1, + format, type, image, + "glConvolutionFilter2D"); + if (!image) + return; + + /* Unpack filter image. We always store filters in RGBA format. */ + for (i = 0; i < height; i++) { + const GLvoid *src = _mesa_image_address2d(&ctx->Unpack, image, width, + height, format, type, i, 0); + GLfloat *dst = ctx->Convolution2D.Filter + i * width * 4; + _mesa_unpack_color_span_float(ctx, width, GL_RGBA, dst, + format, type, src, &ctx->Unpack, + 0); /* transferOps */ + } + + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); + + _mesa_scale_and_bias_rgba(width * height, + (GLfloat (*)[4]) ctx->Convolution2D.Filter, + ctx->Pixel.ConvolutionFilterScale[1][0], + ctx->Pixel.ConvolutionFilterScale[1][1], + ctx->Pixel.ConvolutionFilterScale[1][2], + ctx->Pixel.ConvolutionFilterScale[1][3], + ctx->Pixel.ConvolutionFilterBias[1][0], + ctx->Pixel.ConvolutionFilterBias[1][1], + ctx->Pixel.ConvolutionFilterBias[1][2], + ctx->Pixel.ConvolutionFilterBias[1][3]); + + ctx->NewState |= _NEW_PIXEL; +} + + +void GLAPIENTRY +_mesa_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint c; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + switch (target) { + case GL_CONVOLUTION_1D: + c = 0; + break; + case GL_CONVOLUTION_2D: + c = 1; + break; + case GL_SEPARABLE_2D: + c = 2; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(target)"); + return; + } + + switch (pname) { + case GL_CONVOLUTION_BORDER_MODE: + if (param == (GLfloat) GL_REDUCE || + param == (GLfloat) GL_CONSTANT_BORDER || + param == (GLfloat) GL_REPLICATE_BORDER) { + ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) param; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(params)"); + return; + } + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(pname)"); + return; + } + + ctx->NewState |= _NEW_PIXEL; +} + + +void GLAPIENTRY +_mesa_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint c; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + switch (target) { + case GL_CONVOLUTION_1D: + c = 0; + break; + case GL_CONVOLUTION_2D: + c = 1; + break; + case GL_SEPARABLE_2D: + c = 2; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(target)"); + return; + } + + switch (pname) { + case GL_CONVOLUTION_BORDER_COLOR: + COPY_4V(ctx->Pixel.ConvolutionBorderColor[c], params); + break; + case GL_CONVOLUTION_BORDER_MODE: + if (params[0] == (GLfloat) GL_REDUCE || + params[0] == (GLfloat) GL_CONSTANT_BORDER || + params[0] == (GLfloat) GL_REPLICATE_BORDER) { + ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) params[0]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(params)"); + return; + } + break; + case GL_CONVOLUTION_FILTER_SCALE: + COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params); + break; + case GL_CONVOLUTION_FILTER_BIAS: + COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params); + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(pname)"); + return; + } + + ctx->NewState |= _NEW_PIXEL; +} + + +void GLAPIENTRY +_mesa_ConvolutionParameteri(GLenum target, GLenum pname, GLint param) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint c; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + switch (target) { + case GL_CONVOLUTION_1D: + c = 0; + break; + case GL_CONVOLUTION_2D: + c = 1; + break; + case GL_SEPARABLE_2D: + c = 2; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(target)"); + return; + } + + switch (pname) { + case GL_CONVOLUTION_BORDER_MODE: + if (param == (GLint) GL_REDUCE || + param == (GLint) GL_CONSTANT_BORDER || + param == (GLint) GL_REPLICATE_BORDER) { + ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) param; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(params)"); + return; + } + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(pname)"); + return; + } + + ctx->NewState |= _NEW_PIXEL; +} + + +void GLAPIENTRY +_mesa_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint c; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + switch (target) { + case GL_CONVOLUTION_1D: + c = 0; + break; + case GL_CONVOLUTION_2D: + c = 1; + break; + case GL_SEPARABLE_2D: + c = 2; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(target)"); + return; + } + + switch (pname) { + case GL_CONVOLUTION_BORDER_COLOR: + ctx->Pixel.ConvolutionBorderColor[c][0] = INT_TO_FLOAT(params[0]); + ctx->Pixel.ConvolutionBorderColor[c][1] = INT_TO_FLOAT(params[1]); + ctx->Pixel.ConvolutionBorderColor[c][2] = INT_TO_FLOAT(params[2]); + ctx->Pixel.ConvolutionBorderColor[c][3] = INT_TO_FLOAT(params[3]); + break; + case GL_CONVOLUTION_BORDER_MODE: + if (params[0] == (GLint) GL_REDUCE || + params[0] == (GLint) GL_CONSTANT_BORDER || + params[0] == (GLint) GL_REPLICATE_BORDER) { + ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) params[0]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(params)"); + return; + } + break; + case GL_CONVOLUTION_FILTER_SCALE: + /* COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params); */ + /* need cast to prevent compiler warnings */ + ctx->Pixel.ConvolutionFilterScale[c][0] = (GLfloat) params[0]; + ctx->Pixel.ConvolutionFilterScale[c][1] = (GLfloat) params[1]; + ctx->Pixel.ConvolutionFilterScale[c][2] = (GLfloat) params[2]; + ctx->Pixel.ConvolutionFilterScale[c][3] = (GLfloat) params[3]; + break; + case GL_CONVOLUTION_FILTER_BIAS: + /* COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params); */ + /* need cast to prevent compiler warnings */ + ctx->Pixel.ConvolutionFilterBias[c][0] = (GLfloat) params[0]; + ctx->Pixel.ConvolutionFilterBias[c][1] = (GLfloat) params[1]; + ctx->Pixel.ConvolutionFilterBias[c][2] = (GLfloat) params[2]; + ctx->Pixel.ConvolutionFilterBias[c][3] = (GLfloat) params[3]; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(pname)"); + return; + } + + ctx->NewState |= _NEW_PIXEL; +} + + +void GLAPIENTRY +_mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + GLint baseFormat; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (target != GL_CONVOLUTION_1D) { + _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter1D(target)"); + return; + } + + baseFormat = base_filter_format(internalFormat); + if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { + _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter1D(internalFormat)"); + return; + } + + if (width < 0 || width > MAX_CONVOLUTION_WIDTH) { + _mesa_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter1D(width)"); + return; + } + + ctx->Driver.CopyConvolutionFilter1D( ctx, target, + internalFormat, x, y, width); +} + + +void GLAPIENTRY +_mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + GLint baseFormat; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (target != GL_CONVOLUTION_2D) { + _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter2D(target)"); + return; + } + + baseFormat = base_filter_format(internalFormat); + if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { + _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter2D(internalFormat)"); + return; + } + + if (width < 0 || width > MAX_CONVOLUTION_WIDTH) { + _mesa_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter2D(width)"); + return; + } + if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) { + _mesa_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter2D(height)"); + return; + } + + ctx->Driver.CopyConvolutionFilter2D( ctx, target, internalFormat, x, y, + width, height ); +} + + +void GLAPIENTRY +_mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, + GLvoid *image) +{ + struct gl_convolution_attrib *filter; + GLuint row; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (ctx->NewState) { + _mesa_update_state(ctx); + } + + if (!_mesa_is_legal_format_and_type(ctx, format, type)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetConvolutionFilter(format or type)"); + return; + } + + if (format == GL_COLOR_INDEX || + format == GL_STENCIL_INDEX || + format == GL_DEPTH_COMPONENT || + format == GL_INTENSITY || + type == GL_BITMAP) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(format or type)"); + return; + } + + switch (target) { + case GL_CONVOLUTION_1D: + filter = &(ctx->Convolution1D); + break; + case GL_CONVOLUTION_2D: + filter = &(ctx->Convolution2D); + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(target)"); + return; + } + + image = _mesa_map_validate_pbo_dest(ctx, 2, &ctx->Pack, + filter->Width, filter->Height, 1, + format, type, image, + "glGetConvolutionFilter"); + if (!image) + return; + + for (row = 0; row < filter->Height; row++) { + GLvoid *dst = _mesa_image_address2d(&ctx->Pack, image, filter->Width, + filter->Height, format, type, + row, 0); + GLfloat (*src)[4] = (GLfloat (*)[4]) (filter->Filter + row * filter->Width * 4); + _mesa_pack_rgba_span_float(ctx, filter->Width, src, + format, type, dst, &ctx->Pack, 0x0); + } + + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); +} + + +void GLAPIENTRY +_mesa_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params) +{ + GET_CURRENT_CONTEXT(ctx); + const struct gl_convolution_attrib *conv; + GLuint c; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + switch (target) { + case GL_CONVOLUTION_1D: + c = 0; + conv = &ctx->Convolution1D; + break; + case GL_CONVOLUTION_2D: + c = 1; + conv = &ctx->Convolution2D; + break; + case GL_SEPARABLE_2D: + c = 2; + conv = &ctx->Separable2D; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameterfv(target)"); + return; + } + + switch (pname) { + case GL_CONVOLUTION_BORDER_COLOR: + COPY_4V(params, ctx->Pixel.ConvolutionBorderColor[c]); + break; + case GL_CONVOLUTION_BORDER_MODE: + *params = (GLfloat) ctx->Pixel.ConvolutionBorderMode[c]; + break; + case GL_CONVOLUTION_FILTER_SCALE: + COPY_4V(params, ctx->Pixel.ConvolutionFilterScale[c]); + break; + case GL_CONVOLUTION_FILTER_BIAS: + COPY_4V(params, ctx->Pixel.ConvolutionFilterBias[c]); + break; + case GL_CONVOLUTION_FORMAT: + *params = (GLfloat) conv->Format; + break; + case GL_CONVOLUTION_WIDTH: + *params = (GLfloat) conv->Width; + break; + case GL_CONVOLUTION_HEIGHT: + *params = (GLfloat) conv->Height; + break; + case GL_MAX_CONVOLUTION_WIDTH: + *params = (GLfloat) ctx->Const.MaxConvolutionWidth; + break; + case GL_MAX_CONVOLUTION_HEIGHT: + *params = (GLfloat) ctx->Const.MaxConvolutionHeight; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameterfv(pname)"); + return; + } +} + + +void GLAPIENTRY +_mesa_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params) +{ + GET_CURRENT_CONTEXT(ctx); + const struct gl_convolution_attrib *conv; + GLuint c; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + switch (target) { + case GL_CONVOLUTION_1D: + c = 0; + conv = &ctx->Convolution1D; + break; + case GL_CONVOLUTION_2D: + c = 1; + conv = &ctx->Convolution2D; + break; + case GL_SEPARABLE_2D: + c = 2; + conv = &ctx->Separable2D; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(target)"); + return; + } + + switch (pname) { + case GL_CONVOLUTION_BORDER_COLOR: + params[0] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][0]); + params[1] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][1]); + params[2] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][2]); + params[3] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][3]); + break; + case GL_CONVOLUTION_BORDER_MODE: + *params = (GLint) ctx->Pixel.ConvolutionBorderMode[c]; + break; + case GL_CONVOLUTION_FILTER_SCALE: + params[0] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][0]; + params[1] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][1]; + params[2] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][2]; + params[3] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][3]; + break; + case GL_CONVOLUTION_FILTER_BIAS: + params[0] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][0]; + params[1] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][1]; + params[2] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][2]; + params[3] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][3]; + break; + case GL_CONVOLUTION_FORMAT: + *params = (GLint) conv->Format; + break; + case GL_CONVOLUTION_WIDTH: + *params = (GLint) conv->Width; + break; + case GL_CONVOLUTION_HEIGHT: + *params = (GLint) conv->Height; + break; + case GL_MAX_CONVOLUTION_WIDTH: + *params = (GLint) ctx->Const.MaxConvolutionWidth; + break; + case GL_MAX_CONVOLUTION_HEIGHT: + *params = (GLint) ctx->Const.MaxConvolutionHeight; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(pname)"); + return; + } +} + + +void GLAPIENTRY +_mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type, + GLvoid *row, GLvoid *column, GLvoid *span) +{ + const GLint colStart = MAX_CONVOLUTION_WIDTH * 4; + struct gl_convolution_attrib *filter; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (ctx->NewState) { + _mesa_update_state(ctx); + } + + if (target != GL_SEPARABLE_2D) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetSeparableFilter(target)"); + return; + } + + if (!_mesa_is_legal_format_and_type(ctx, format, type)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetConvolutionFilter(format or type)"); + return; + } + + if (format == GL_COLOR_INDEX || + format == GL_STENCIL_INDEX || + format == GL_DEPTH_COMPONENT || + format == GL_INTENSITY || + type == GL_BITMAP) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(format or type)"); + return; + } + + filter = &ctx->Separable2D; + + /* Get row filter */ + row = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, + filter->Width, 1, 1, + format, type, row, + "glGetConvolutionFilter"); + if (row) { + GLvoid *dst = _mesa_image_address1d(&ctx->Pack, row, filter->Width, + format, type, 0); + _mesa_pack_rgba_span_float(ctx, filter->Width, + (GLfloat (*)[4]) filter->Filter, + format, type, dst, &ctx->Pack, 0x0); + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); + } + + /* get column filter */ + column = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, + filter->Height, 1, 1, + format, type, column, + "glGetConvolutionFilter"); + if (column) { + GLvoid *dst = _mesa_image_address1d(&ctx->Pack, column, filter->Height, + format, type, 0); + GLfloat (*src)[4] = (GLfloat (*)[4]) (filter->Filter + colStart); + _mesa_pack_rgba_span_float(ctx, filter->Height, src, + format, type, dst, &ctx->Pack, 0x0); + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); + } + + (void) span; /* unused at this time */ +} + + +void GLAPIENTRY +_mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) +{ + const GLint colStart = MAX_CONVOLUTION_WIDTH * 4; + GLint baseFormat; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (target != GL_SEPARABLE_2D) { + _mesa_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(target)"); + return; + } + + baseFormat = base_filter_format(internalFormat); + if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { + _mesa_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(internalFormat)"); + return; + } + + if (width < 0 || width > MAX_CONVOLUTION_WIDTH) { + _mesa_error(ctx, GL_INVALID_VALUE, "glSeparableFilter2D(width)"); + return; + } + if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) { + _mesa_error(ctx, GL_INVALID_VALUE, "glSeparableFilter2D(height)"); + return; + } + + if (!_mesa_is_legal_format_and_type(ctx, format, type)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glSeparableFilter2D(format or type)"); + return; + } + + if (format == GL_COLOR_INDEX || + format == GL_STENCIL_INDEX || + format == GL_DEPTH_COMPONENT || + format == GL_INTENSITY || + type == GL_BITMAP) { + _mesa_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(format or type)"); + return; + } + + ctx->Separable2D.Format = format; + ctx->Separable2D.InternalFormat = internalFormat; + ctx->Separable2D.Width = width; + ctx->Separable2D.Height = height; + + /* unpack row filter */ + row = _mesa_map_validate_pbo_source(ctx, 1, &ctx->Unpack, + width, 1, 1, + format, type, row, + "glSeparableFilter2D"); + if (row) { + _mesa_unpack_color_span_float(ctx, width, GL_RGBA, + ctx->Separable2D.Filter, + format, type, row, &ctx->Unpack, + 0x0); /* transferOps */ + _mesa_scale_and_bias_rgba(width, + (GLfloat (*)[4]) ctx->Separable2D.Filter, + ctx->Pixel.ConvolutionFilterScale[2][0], + ctx->Pixel.ConvolutionFilterScale[2][1], + ctx->Pixel.ConvolutionFilterScale[2][2], + ctx->Pixel.ConvolutionFilterScale[2][3], + ctx->Pixel.ConvolutionFilterBias[2][0], + ctx->Pixel.ConvolutionFilterBias[2][1], + ctx->Pixel.ConvolutionFilterBias[2][2], + ctx->Pixel.ConvolutionFilterBias[2][3]); + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); + } + + /* unpack column filter */ + column = _mesa_map_validate_pbo_source(ctx, 1, &ctx->Unpack, + height, 1, 1, + format, type, column, + "glSeparableFilter2D"); + if (column) { + _mesa_unpack_color_span_float(ctx, height, GL_RGBA, + &ctx->Separable2D.Filter[colStart], + format, type, column, &ctx->Unpack, + 0); /* transferOps */ + + _mesa_scale_and_bias_rgba(height, + (GLfloat (*)[4]) (ctx->Separable2D.Filter + colStart), + ctx->Pixel.ConvolutionFilterScale[2][0], + ctx->Pixel.ConvolutionFilterScale[2][1], + ctx->Pixel.ConvolutionFilterScale[2][2], + ctx->Pixel.ConvolutionFilterScale[2][3], + ctx->Pixel.ConvolutionFilterBias[2][0], + ctx->Pixel.ConvolutionFilterBias[2][1], + ctx->Pixel.ConvolutionFilterBias[2][2], + ctx->Pixel.ConvolutionFilterBias[2][3]); + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); + } + + if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) { + ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, + ctx->Unpack.BufferObj); + } + + ctx->NewState |= _NEW_PIXEL; +} + + +/**********************************************************************/ +/*** image convolution functions ***/ +/**********************************************************************/ + +static void +convolve_1d_reduce(GLint srcWidth, const GLfloat src[][4], + GLint filterWidth, const GLfloat filter[][4], + GLfloat dest[][4]) +{ + GLint dstWidth; + GLint i, n; + + if (filterWidth >= 1) + dstWidth = srcWidth - (filterWidth - 1); + else + dstWidth = srcWidth; + + if (dstWidth <= 0) + return; /* null result */ + + for (i = 0; i < dstWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (n = 0; n < filterWidth; n++) { + sumR += src[i + n][RCOMP] * filter[n][RCOMP]; + sumG += src[i + n][GCOMP] * filter[n][GCOMP]; + sumB += src[i + n][BCOMP] * filter[n][BCOMP]; + sumA += src[i + n][ACOMP] * filter[n][ACOMP]; + } + dest[i][RCOMP] = sumR; + dest[i][GCOMP] = sumG; + dest[i][BCOMP] = sumB; + dest[i][ACOMP] = sumA; + } +} + + +static void +convolve_1d_constant(GLint srcWidth, const GLfloat src[][4], + GLint filterWidth, const GLfloat filter[][4], + GLfloat dest[][4], + const GLfloat borderColor[4]) +{ + const GLint halfFilterWidth = filterWidth / 2; + GLint i, n; + + for (i = 0; i < srcWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (n = 0; n < filterWidth; n++) { + if (i + n < halfFilterWidth || i + n - halfFilterWidth >= srcWidth) { + sumR += borderColor[RCOMP] * filter[n][RCOMP]; + sumG += borderColor[GCOMP] * filter[n][GCOMP]; + sumB += borderColor[BCOMP] * filter[n][BCOMP]; + sumA += borderColor[ACOMP] * filter[n][ACOMP]; + } + else { + sumR += src[i + n - halfFilterWidth][RCOMP] * filter[n][RCOMP]; + sumG += src[i + n - halfFilterWidth][GCOMP] * filter[n][GCOMP]; + sumB += src[i + n - halfFilterWidth][BCOMP] * filter[n][BCOMP]; + sumA += src[i + n - halfFilterWidth][ACOMP] * filter[n][ACOMP]; + } + } + dest[i][RCOMP] = sumR; + dest[i][GCOMP] = sumG; + dest[i][BCOMP] = sumB; + dest[i][ACOMP] = sumA; + } +} + + +static void +convolve_1d_replicate(GLint srcWidth, const GLfloat src[][4], + GLint filterWidth, const GLfloat filter[][4], + GLfloat dest[][4]) +{ + const GLint halfFilterWidth = filterWidth / 2; + GLint i, n; + + for (i = 0; i < srcWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (n = 0; n < filterWidth; n++) { + if (i + n < halfFilterWidth) { + sumR += src[0][RCOMP] * filter[n][RCOMP]; + sumG += src[0][GCOMP] * filter[n][GCOMP]; + sumB += src[0][BCOMP] * filter[n][BCOMP]; + sumA += src[0][ACOMP] * filter[n][ACOMP]; + } + else if (i + n - halfFilterWidth >= srcWidth) { + sumR += src[srcWidth - 1][RCOMP] * filter[n][RCOMP]; + sumG += src[srcWidth - 1][GCOMP] * filter[n][GCOMP]; + sumB += src[srcWidth - 1][BCOMP] * filter[n][BCOMP]; + sumA += src[srcWidth - 1][ACOMP] * filter[n][ACOMP]; + } + else { + sumR += src[i + n - halfFilterWidth][RCOMP] * filter[n][RCOMP]; + sumG += src[i + n - halfFilterWidth][GCOMP] * filter[n][GCOMP]; + sumB += src[i + n - halfFilterWidth][BCOMP] * filter[n][BCOMP]; + sumA += src[i + n - halfFilterWidth][ACOMP] * filter[n][ACOMP]; + } + } + dest[i][RCOMP] = sumR; + dest[i][GCOMP] = sumG; + dest[i][BCOMP] = sumB; + dest[i][ACOMP] = sumA; + } +} + + +static void +convolve_2d_reduce(GLint srcWidth, GLint srcHeight, + const GLfloat src[][4], + GLint filterWidth, GLint filterHeight, + const GLfloat filter[][4], + GLfloat dest[][4]) +{ + GLint dstWidth, dstHeight; + GLint i, j, n, m; + + if (filterWidth >= 1) + dstWidth = srcWidth - (filterWidth - 1); + else + dstWidth = srcWidth; + + if (filterHeight >= 1) + dstHeight = srcHeight - (filterHeight - 1); + else + dstHeight = srcHeight; + + if (dstWidth <= 0 || dstHeight <= 0) + return; + + for (j = 0; j < dstHeight; j++) { + for (i = 0; i < dstWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (m = 0; m < filterHeight; m++) { + for (n = 0; n < filterWidth; n++) { + const GLint k = (j + m) * srcWidth + i + n; + const GLint f = m * filterWidth + n; + sumR += src[k][RCOMP] * filter[f][RCOMP]; + sumG += src[k][GCOMP] * filter[f][GCOMP]; + sumB += src[k][BCOMP] * filter[f][BCOMP]; + sumA += src[k][ACOMP] * filter[f][ACOMP]; + } + } + dest[j * dstWidth + i][RCOMP] = sumR; + dest[j * dstWidth + i][GCOMP] = sumG; + dest[j * dstWidth + i][BCOMP] = sumB; + dest[j * dstWidth + i][ACOMP] = sumA; + } + } +} + + +static void +convolve_2d_constant(GLint srcWidth, GLint srcHeight, + const GLfloat src[][4], + GLint filterWidth, GLint filterHeight, + const GLfloat filter[][4], + GLfloat dest[][4], + const GLfloat borderColor[4]) +{ + const GLint halfFilterWidth = filterWidth / 2; + const GLint halfFilterHeight = filterHeight / 2; + GLint i, j, n, m; + + for (j = 0; j < srcHeight; j++) { + for (i = 0; i < srcWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (m = 0; m < filterHeight; m++) { + for (n = 0; n < filterWidth; n++) { + const GLint f = m * filterWidth + n; + const GLint is = i + n - halfFilterWidth; + const GLint js = j + m - halfFilterHeight; + if (is < 0 || is >= srcWidth || + js < 0 || js >= srcHeight) { + sumR += borderColor[RCOMP] * filter[f][RCOMP]; + sumG += borderColor[GCOMP] * filter[f][GCOMP]; + sumB += borderColor[BCOMP] * filter[f][BCOMP]; + sumA += borderColor[ACOMP] * filter[f][ACOMP]; + } + else { + const GLint k = js * srcWidth + is; + sumR += src[k][RCOMP] * filter[f][RCOMP]; + sumG += src[k][GCOMP] * filter[f][GCOMP]; + sumB += src[k][BCOMP] * filter[f][BCOMP]; + sumA += src[k][ACOMP] * filter[f][ACOMP]; + } + } + } + dest[j * srcWidth + i][RCOMP] = sumR; + dest[j * srcWidth + i][GCOMP] = sumG; + dest[j * srcWidth + i][BCOMP] = sumB; + dest[j * srcWidth + i][ACOMP] = sumA; + } + } +} + + +static void +convolve_2d_replicate(GLint srcWidth, GLint srcHeight, + const GLfloat src[][4], + GLint filterWidth, GLint filterHeight, + const GLfloat filter[][4], + GLfloat dest[][4]) +{ + const GLint halfFilterWidth = filterWidth / 2; + const GLint halfFilterHeight = filterHeight / 2; + GLint i, j, n, m; + + for (j = 0; j < srcHeight; j++) { + for (i = 0; i < srcWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (m = 0; m < filterHeight; m++) { + for (n = 0; n < filterWidth; n++) { + const GLint f = m * filterWidth + n; + GLint is = i + n - halfFilterWidth; + GLint js = j + m - halfFilterHeight; + GLint k; + if (is < 0) + is = 0; + else if (is >= srcWidth) + is = srcWidth - 1; + if (js < 0) + js = 0; + else if (js >= srcHeight) + js = srcHeight - 1; + k = js * srcWidth + is; + sumR += src[k][RCOMP] * filter[f][RCOMP]; + sumG += src[k][GCOMP] * filter[f][GCOMP]; + sumB += src[k][BCOMP] * filter[f][BCOMP]; + sumA += src[k][ACOMP] * filter[f][ACOMP]; + } + } + dest[j * srcWidth + i][RCOMP] = sumR; + dest[j * srcWidth + i][GCOMP] = sumG; + dest[j * srcWidth + i][BCOMP] = sumB; + dest[j * srcWidth + i][ACOMP] = sumA; + } + } +} + + +static void +convolve_sep_reduce(GLint srcWidth, GLint srcHeight, + const GLfloat src[][4], + GLint filterWidth, GLint filterHeight, + const GLfloat rowFilt[][4], + const GLfloat colFilt[][4], + GLfloat dest[][4]) +{ + GLint dstWidth, dstHeight; + GLint i, j, n, m; + + if (filterWidth >= 1) + dstWidth = srcWidth - (filterWidth - 1); + else + dstWidth = srcWidth; + + if (filterHeight >= 1) + dstHeight = srcHeight - (filterHeight - 1); + else + dstHeight = srcHeight; + + if (dstWidth <= 0 || dstHeight <= 0) + return; + + for (j = 0; j < dstHeight; j++) { + for (i = 0; i < dstWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (m = 0; m < filterHeight; m++) { + for (n = 0; n < filterWidth; n++) { + GLint k = (j + m) * srcWidth + i + n; + sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP]; + sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP]; + sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP]; + sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP]; + } + } + dest[j * dstWidth + i][RCOMP] = sumR; + dest[j * dstWidth + i][GCOMP] = sumG; + dest[j * dstWidth + i][BCOMP] = sumB; + dest[j * dstWidth + i][ACOMP] = sumA; + } + } +} + + +static void +convolve_sep_constant(GLint srcWidth, GLint srcHeight, + const GLfloat src[][4], + GLint filterWidth, GLint filterHeight, + const GLfloat rowFilt[][4], + const GLfloat colFilt[][4], + GLfloat dest[][4], + const GLfloat borderColor[4]) +{ + const GLint halfFilterWidth = filterWidth / 2; + const GLint halfFilterHeight = filterHeight / 2; + GLint i, j, n, m; + + for (j = 0; j < srcHeight; j++) { + for (i = 0; i < srcWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (m = 0; m < filterHeight; m++) { + for (n = 0; n < filterWidth; n++) { + const GLint is = i + n - halfFilterWidth; + const GLint js = j + m - halfFilterHeight; + if (is < 0 || is >= srcWidth || + js < 0 || js >= srcHeight) { + sumR += borderColor[RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP]; + sumG += borderColor[GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP]; + sumB += borderColor[BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP]; + sumA += borderColor[ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP]; + } + else { + GLint k = js * srcWidth + is; + sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP]; + sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP]; + sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP]; + sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP]; + } + + } + } + dest[j * srcWidth + i][RCOMP] = sumR; + dest[j * srcWidth + i][GCOMP] = sumG; + dest[j * srcWidth + i][BCOMP] = sumB; + dest[j * srcWidth + i][ACOMP] = sumA; + } + } +} + + +static void +convolve_sep_replicate(GLint srcWidth, GLint srcHeight, + const GLfloat src[][4], + GLint filterWidth, GLint filterHeight, + const GLfloat rowFilt[][4], + const GLfloat colFilt[][4], + GLfloat dest[][4]) +{ + const GLint halfFilterWidth = filterWidth / 2; + const GLint halfFilterHeight = filterHeight / 2; + GLint i, j, n, m; + + for (j = 0; j < srcHeight; j++) { + for (i = 0; i < srcWidth; i++) { + GLfloat sumR = 0.0; + GLfloat sumG = 0.0; + GLfloat sumB = 0.0; + GLfloat sumA = 0.0; + for (m = 0; m < filterHeight; m++) { + for (n = 0; n < filterWidth; n++) { + GLint is = i + n - halfFilterWidth; + GLint js = j + m - halfFilterHeight; + GLint k; + if (is < 0) + is = 0; + else if (is >= srcWidth) + is = srcWidth - 1; + if (js < 0) + js = 0; + else if (js >= srcHeight) + js = srcHeight - 1; + k = js * srcWidth + is; + sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP]; + sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP]; + sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP]; + sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP]; + } + } + dest[j * srcWidth + i][RCOMP] = sumR; + dest[j * srcWidth + i][GCOMP] = sumG; + dest[j * srcWidth + i][BCOMP] = sumB; + dest[j * srcWidth + i][ACOMP] = sumA; + } + } +} + + + +void +_mesa_convolve_1d_image(const GLcontext *ctx, GLsizei *width, + const GLfloat *srcImage, GLfloat *dstImage) +{ + switch (ctx->Pixel.ConvolutionBorderMode[0]) { + case GL_REDUCE: + convolve_1d_reduce(*width, (const GLfloat (*)[4]) srcImage, + ctx->Convolution1D.Width, + (const GLfloat (*)[4]) ctx->Convolution1D.Filter, + (GLfloat (*)[4]) dstImage); + *width = *width - (MAX2(ctx->Convolution1D.Width, 1) - 1); + break; + case GL_CONSTANT_BORDER: + convolve_1d_constant(*width, (const GLfloat (*)[4]) srcImage, + ctx->Convolution1D.Width, + (const GLfloat (*)[4]) ctx->Convolution1D.Filter, + (GLfloat (*)[4]) dstImage, + ctx->Pixel.ConvolutionBorderColor[0]); + break; + case GL_REPLICATE_BORDER: + convolve_1d_replicate(*width, (const GLfloat (*)[4]) srcImage, + ctx->Convolution1D.Width, + (const GLfloat (*)[4]) ctx->Convolution1D.Filter, + (GLfloat (*)[4]) dstImage); + break; + default: + ; + } +} + + +void +_mesa_convolve_2d_image(const GLcontext *ctx, GLsizei *width, GLsizei *height, + const GLfloat *srcImage, GLfloat *dstImage) +{ + switch (ctx->Pixel.ConvolutionBorderMode[1]) { + case GL_REDUCE: + convolve_2d_reduce(*width, *height, + (const GLfloat (*)[4]) srcImage, + ctx->Convolution2D.Width, + ctx->Convolution2D.Height, + (const GLfloat (*)[4]) ctx->Convolution2D.Filter, + (GLfloat (*)[4]) dstImage); + *width = *width - (MAX2(ctx->Convolution2D.Width, 1) - 1); + *height = *height - (MAX2(ctx->Convolution2D.Height, 1) - 1); + break; + case GL_CONSTANT_BORDER: + convolve_2d_constant(*width, *height, + (const GLfloat (*)[4]) srcImage, + ctx->Convolution2D.Width, + ctx->Convolution2D.Height, + (const GLfloat (*)[4]) ctx->Convolution2D.Filter, + (GLfloat (*)[4]) dstImage, + ctx->Pixel.ConvolutionBorderColor[1]); + break; + case GL_REPLICATE_BORDER: + convolve_2d_replicate(*width, *height, + (const GLfloat (*)[4]) srcImage, + ctx->Convolution2D.Width, + ctx->Convolution2D.Height, + (const GLfloat (*)[4])ctx->Convolution2D.Filter, + (GLfloat (*)[4]) dstImage); + break; + default: + ; + } +} + + +void +_mesa_convolve_sep_image(const GLcontext *ctx, + GLsizei *width, GLsizei *height, + const GLfloat *srcImage, GLfloat *dstImage) +{ + const GLfloat *rowFilter = ctx->Separable2D.Filter; + const GLfloat *colFilter = rowFilter + 4 * MAX_CONVOLUTION_WIDTH; + + switch (ctx->Pixel.ConvolutionBorderMode[2]) { + case GL_REDUCE: + convolve_sep_reduce(*width, *height, + (const GLfloat (*)[4]) srcImage, + ctx->Separable2D.Width, + ctx->Separable2D.Height, + (const GLfloat (*)[4]) rowFilter, + (const GLfloat (*)[4]) colFilter, + (GLfloat (*)[4]) dstImage); + *width = *width - (MAX2(ctx->Separable2D.Width, 1) - 1); + *height = *height - (MAX2(ctx->Separable2D.Height, 1) - 1); + break; + case GL_CONSTANT_BORDER: + convolve_sep_constant(*width, *height, + (const GLfloat (*)[4]) srcImage, + ctx->Separable2D.Width, + ctx->Separable2D.Height, + (const GLfloat (*)[4]) rowFilter, + (const GLfloat (*)[4]) colFilter, + (GLfloat (*)[4]) dstImage, + ctx->Pixel.ConvolutionBorderColor[2]); + break; + case GL_REPLICATE_BORDER: + convolve_sep_replicate(*width, *height, + (const GLfloat (*)[4]) srcImage, + ctx->Separable2D.Width, + ctx->Separable2D.Height, + (const GLfloat (*)[4]) rowFilter, + (const GLfloat (*)[4]) colFilter, + (GLfloat (*)[4]) dstImage); + break; + default: + ; + } +} + + + +/* + * This function computes an image's size after convolution. + * If the convolution border mode is GL_REDUCE, the post-convolution + * image will be smaller than the original. + */ +void +_mesa_adjust_image_for_convolution(const GLcontext *ctx, GLuint dimensions, + GLsizei *width, GLsizei *height) +{ + if (ctx->Pixel.Convolution1DEnabled + && dimensions == 1 + && ctx->Pixel.ConvolutionBorderMode[0] == GL_REDUCE) { + *width = *width - (MAX2(ctx->Convolution1D.Width, 1) - 1); + } + else if (ctx->Pixel.Convolution2DEnabled + && dimensions > 1 + && ctx->Pixel.ConvolutionBorderMode[1] == GL_REDUCE) { + *width = *width - (MAX2(ctx->Convolution2D.Width, 1) - 1); + *height = *height - (MAX2(ctx->Convolution2D.Height, 1) - 1); + } + else if (ctx->Pixel.Separable2DEnabled + && dimensions > 1 + && ctx->Pixel.ConvolutionBorderMode[2] == GL_REDUCE) { + *width = *width - (MAX2(ctx->Separable2D.Width, 1) - 1); + *height = *height - (MAX2(ctx->Separable2D.Height, 1) - 1); + } +} -- cgit v1.2.3