2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Image convolution functions.
29 * Notes: filter kernel elements are indexed by <n> and <m> as in
35 #include "bufferobj.h"
46 * Given an internalFormat token passed to glConvolutionFilter
47 * or glSeparableFilter, return the corresponding base format.
48 * Return -1 if invalid token.
51 base_filter_format( GLenum format
)
66 case GL_LUMINANCE_ALPHA
:
67 case GL_LUMINANCE4_ALPHA4
:
68 case GL_LUMINANCE6_ALPHA2
:
69 case GL_LUMINANCE8_ALPHA8
:
70 case GL_LUMINANCE12_ALPHA4
:
71 case GL_LUMINANCE12_ALPHA12
:
72 case GL_LUMINANCE16_ALPHA16
:
73 return GL_LUMINANCE_ALPHA
;
100 return -1; /* error */
106 _mesa_ConvolutionFilter1D(GLenum target
, GLenum internalFormat
, GLsizei width
, GLenum format
, GLenum type
, const GLvoid
*image
)
109 GET_CURRENT_CONTEXT(ctx
);
110 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
112 if (target
!= GL_CONVOLUTION_1D
) {
113 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionFilter1D(target)");
117 baseFormat
= base_filter_format(internalFormat
);
118 if (baseFormat
< 0 || baseFormat
== GL_COLOR_INDEX
) {
119 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionFilter1D(internalFormat)");
123 if (width
< 0 || width
> MAX_CONVOLUTION_WIDTH
) {
124 _mesa_error(ctx
, GL_INVALID_VALUE
, "glConvolutionFilter1D(width)");
128 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
)) {
129 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glConvolutionFilter1D(format or type)");
133 if (format
== GL_COLOR_INDEX
||
134 format
== GL_STENCIL_INDEX
||
135 format
== GL_DEPTH_COMPONENT
||
136 format
== GL_INTENSITY
||
138 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionFilter1D(format or type)");
142 ctx
->Convolution1D
.Format
= format
;
143 ctx
->Convolution1D
.InternalFormat
= internalFormat
;
144 ctx
->Convolution1D
.Width
= width
;
145 ctx
->Convolution1D
.Height
= 1;
147 if (ctx
->Unpack
.BufferObj
->Name
) {
148 /* unpack filter from PBO */
150 if (!_mesa_validate_pbo_access(1, &ctx
->Unpack
, width
, 1, 1,
151 format
, type
, image
)) {
152 _mesa_error(ctx
, GL_INVALID_OPERATION
,
153 "glConvolutionFilter1D(invalid PBO access)");
156 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
158 ctx
->Unpack
.BufferObj
);
160 /* buffer is already mapped - that's an error */
161 _mesa_error(ctx
, GL_INVALID_OPERATION
,
162 "glConvolutionFilter1D(PBO is mapped)");
165 image
= ADD_POINTERS(buf
, image
);
171 _mesa_unpack_color_span_float(ctx
, width
, GL_RGBA
,
172 ctx
->Convolution1D
.Filter
,
173 format
, type
, image
, &ctx
->Unpack
,
174 0); /* transferOps */
176 if (ctx
->Unpack
.BufferObj
->Name
) {
177 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
178 ctx
->Unpack
.BufferObj
);
181 _mesa_scale_and_bias_rgba(width
,
182 (GLfloat (*)[4]) ctx
->Convolution1D
.Filter
,
183 ctx
->Pixel
.ConvolutionFilterScale
[0][0],
184 ctx
->Pixel
.ConvolutionFilterScale
[0][1],
185 ctx
->Pixel
.ConvolutionFilterScale
[0][2],
186 ctx
->Pixel
.ConvolutionFilterScale
[0][3],
187 ctx
->Pixel
.ConvolutionFilterBias
[0][0],
188 ctx
->Pixel
.ConvolutionFilterBias
[0][1],
189 ctx
->Pixel
.ConvolutionFilterBias
[0][2],
190 ctx
->Pixel
.ConvolutionFilterBias
[0][3]);
192 ctx
->NewState
|= _NEW_PIXEL
;
197 _mesa_ConvolutionFilter2D(GLenum target
, GLenum internalFormat
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*image
)
201 GET_CURRENT_CONTEXT(ctx
);
202 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
204 if (target
!= GL_CONVOLUTION_2D
) {
205 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionFilter2D(target)");
209 baseFormat
= base_filter_format(internalFormat
);
210 if (baseFormat
< 0 || baseFormat
== GL_COLOR_INDEX
) {
211 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionFilter2D(internalFormat)");
215 if (width
< 0 || width
> MAX_CONVOLUTION_WIDTH
) {
216 _mesa_error(ctx
, GL_INVALID_VALUE
, "glConvolutionFilter2D(width)");
219 if (height
< 0 || height
> MAX_CONVOLUTION_HEIGHT
) {
220 _mesa_error(ctx
, GL_INVALID_VALUE
, "glConvolutionFilter2D(height)");
224 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
)) {
225 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glConvolutionFilter2D(format or type)");
228 if (format
== GL_COLOR_INDEX
||
229 format
== GL_STENCIL_INDEX
||
230 format
== GL_DEPTH_COMPONENT
||
231 format
== GL_INTENSITY
||
233 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionFilter2D(format or type)");
237 /* this should have been caught earlier */
238 assert(_mesa_components_in_format(format
));
240 ctx
->Convolution2D
.Format
= format
;
241 ctx
->Convolution2D
.InternalFormat
= internalFormat
;
242 ctx
->Convolution2D
.Width
= width
;
243 ctx
->Convolution2D
.Height
= height
;
245 if (ctx
->Unpack
.BufferObj
->Name
) {
246 /* unpack filter from PBO */
248 if (!_mesa_validate_pbo_access(2, &ctx
->Unpack
, width
, height
, 1,
249 format
, type
, image
)) {
250 _mesa_error(ctx
, GL_INVALID_OPERATION
,
251 "glConvolutionFilter2D(invalid PBO access)");
254 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
256 ctx
->Unpack
.BufferObj
);
258 /* buffer is already mapped - that's an error */
259 _mesa_error(ctx
, GL_INVALID_OPERATION
,
260 "glConvolutionFilter2D(PBO is mapped)");
263 image
= ADD_POINTERS(buf
, image
);
269 /* Unpack filter image. We always store filters in RGBA format. */
270 for (i
= 0; i
< height
; i
++) {
271 const GLvoid
*src
= _mesa_image_address2d(&ctx
->Unpack
, image
, width
,
272 height
, format
, type
, i
, 0);
273 GLfloat
*dst
= ctx
->Convolution2D
.Filter
+ i
* width
* 4;
274 _mesa_unpack_color_span_float(ctx
, width
, GL_RGBA
, dst
,
275 format
, type
, src
, &ctx
->Unpack
,
276 0); /* transferOps */
279 if (ctx
->Unpack
.BufferObj
->Name
) {
280 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
281 ctx
->Unpack
.BufferObj
);
284 _mesa_scale_and_bias_rgba(width
* height
,
285 (GLfloat (*)[4]) ctx
->Convolution2D
.Filter
,
286 ctx
->Pixel
.ConvolutionFilterScale
[1][0],
287 ctx
->Pixel
.ConvolutionFilterScale
[1][1],
288 ctx
->Pixel
.ConvolutionFilterScale
[1][2],
289 ctx
->Pixel
.ConvolutionFilterScale
[1][3],
290 ctx
->Pixel
.ConvolutionFilterBias
[1][0],
291 ctx
->Pixel
.ConvolutionFilterBias
[1][1],
292 ctx
->Pixel
.ConvolutionFilterBias
[1][2],
293 ctx
->Pixel
.ConvolutionFilterBias
[1][3]);
295 ctx
->NewState
|= _NEW_PIXEL
;
300 _mesa_ConvolutionParameterf(GLenum target
, GLenum pname
, GLfloat param
)
302 GET_CURRENT_CONTEXT(ctx
);
304 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
307 case GL_CONVOLUTION_1D
:
310 case GL_CONVOLUTION_2D
:
313 case GL_SEPARABLE_2D
:
317 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameterf(target)");
322 case GL_CONVOLUTION_BORDER_MODE
:
323 if (param
== (GLfloat
) GL_REDUCE
||
324 param
== (GLfloat
) GL_CONSTANT_BORDER
||
325 param
== (GLfloat
) GL_REPLICATE_BORDER
) {
326 ctx
->Pixel
.ConvolutionBorderMode
[c
] = (GLenum
) param
;
329 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameterf(params)");
334 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameterf(pname)");
338 ctx
->NewState
|= _NEW_PIXEL
;
343 _mesa_ConvolutionParameterfv(GLenum target
, GLenum pname
, const GLfloat
*params
)
345 GET_CURRENT_CONTEXT(ctx
);
347 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
350 case GL_CONVOLUTION_1D
:
353 case GL_CONVOLUTION_2D
:
356 case GL_SEPARABLE_2D
:
360 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameterfv(target)");
365 case GL_CONVOLUTION_BORDER_COLOR
:
366 COPY_4V(ctx
->Pixel
.ConvolutionBorderColor
[c
], params
);
368 case GL_CONVOLUTION_BORDER_MODE
:
369 if (params
[0] == (GLfloat
) GL_REDUCE
||
370 params
[0] == (GLfloat
) GL_CONSTANT_BORDER
||
371 params
[0] == (GLfloat
) GL_REPLICATE_BORDER
) {
372 ctx
->Pixel
.ConvolutionBorderMode
[c
] = (GLenum
) params
[0];
375 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameterfv(params)");
379 case GL_CONVOLUTION_FILTER_SCALE
:
380 COPY_4V(ctx
->Pixel
.ConvolutionFilterScale
[c
], params
);
382 case GL_CONVOLUTION_FILTER_BIAS
:
383 COPY_4V(ctx
->Pixel
.ConvolutionFilterBias
[c
], params
);
386 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameterfv(pname)");
390 ctx
->NewState
|= _NEW_PIXEL
;
395 _mesa_ConvolutionParameteri(GLenum target
, GLenum pname
, GLint param
)
397 GET_CURRENT_CONTEXT(ctx
);
399 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
402 case GL_CONVOLUTION_1D
:
405 case GL_CONVOLUTION_2D
:
408 case GL_SEPARABLE_2D
:
412 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameteri(target)");
417 case GL_CONVOLUTION_BORDER_MODE
:
418 if (param
== (GLint
) GL_REDUCE
||
419 param
== (GLint
) GL_CONSTANT_BORDER
||
420 param
== (GLint
) GL_REPLICATE_BORDER
) {
421 ctx
->Pixel
.ConvolutionBorderMode
[c
] = (GLenum
) param
;
424 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameteri(params)");
429 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameteri(pname)");
433 ctx
->NewState
|= _NEW_PIXEL
;
438 _mesa_ConvolutionParameteriv(GLenum target
, GLenum pname
, const GLint
*params
)
440 GET_CURRENT_CONTEXT(ctx
);
442 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
445 case GL_CONVOLUTION_1D
:
448 case GL_CONVOLUTION_2D
:
451 case GL_SEPARABLE_2D
:
455 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameteriv(target)");
460 case GL_CONVOLUTION_BORDER_COLOR
:
461 ctx
->Pixel
.ConvolutionBorderColor
[c
][0] = INT_TO_FLOAT(params
[0]);
462 ctx
->Pixel
.ConvolutionBorderColor
[c
][1] = INT_TO_FLOAT(params
[1]);
463 ctx
->Pixel
.ConvolutionBorderColor
[c
][2] = INT_TO_FLOAT(params
[2]);
464 ctx
->Pixel
.ConvolutionBorderColor
[c
][3] = INT_TO_FLOAT(params
[3]);
466 case GL_CONVOLUTION_BORDER_MODE
:
467 if (params
[0] == (GLint
) GL_REDUCE
||
468 params
[0] == (GLint
) GL_CONSTANT_BORDER
||
469 params
[0] == (GLint
) GL_REPLICATE_BORDER
) {
470 ctx
->Pixel
.ConvolutionBorderMode
[c
] = (GLenum
) params
[0];
473 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameteriv(params)");
477 case GL_CONVOLUTION_FILTER_SCALE
:
478 /* COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params); */
479 /* need cast to prevent compiler warnings */
480 ctx
->Pixel
.ConvolutionFilterScale
[c
][0] = (GLfloat
) params
[0];
481 ctx
->Pixel
.ConvolutionFilterScale
[c
][1] = (GLfloat
) params
[1];
482 ctx
->Pixel
.ConvolutionFilterScale
[c
][2] = (GLfloat
) params
[2];
483 ctx
->Pixel
.ConvolutionFilterScale
[c
][3] = (GLfloat
) params
[3];
485 case GL_CONVOLUTION_FILTER_BIAS
:
486 /* COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params); */
487 /* need cast to prevent compiler warnings */
488 ctx
->Pixel
.ConvolutionFilterBias
[c
][0] = (GLfloat
) params
[0];
489 ctx
->Pixel
.ConvolutionFilterBias
[c
][1] = (GLfloat
) params
[1];
490 ctx
->Pixel
.ConvolutionFilterBias
[c
][2] = (GLfloat
) params
[2];
491 ctx
->Pixel
.ConvolutionFilterBias
[c
][3] = (GLfloat
) params
[3];
494 _mesa_error(ctx
, GL_INVALID_ENUM
, "glConvolutionParameteriv(pname)");
498 ctx
->NewState
|= _NEW_PIXEL
;
503 _mesa_CopyConvolutionFilter1D(GLenum target
, GLenum internalFormat
, GLint x
, GLint y
, GLsizei width
)
506 GET_CURRENT_CONTEXT(ctx
);
507 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
509 if (target
!= GL_CONVOLUTION_1D
) {
510 _mesa_error(ctx
, GL_INVALID_ENUM
, "glCopyConvolutionFilter1D(target)");
514 baseFormat
= base_filter_format(internalFormat
);
515 if (baseFormat
< 0 || baseFormat
== GL_COLOR_INDEX
) {
516 _mesa_error(ctx
, GL_INVALID_ENUM
, "glCopyConvolutionFilter1D(internalFormat)");
520 if (width
< 0 || width
> MAX_CONVOLUTION_WIDTH
) {
521 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCopyConvolutionFilter1D(width)");
525 ctx
->Driver
.CopyConvolutionFilter1D( ctx
, target
,
526 internalFormat
, x
, y
, width
);
531 _mesa_CopyConvolutionFilter2D(GLenum target
, GLenum internalFormat
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
534 GET_CURRENT_CONTEXT(ctx
);
535 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
537 if (target
!= GL_CONVOLUTION_2D
) {
538 _mesa_error(ctx
, GL_INVALID_ENUM
, "glCopyConvolutionFilter2D(target)");
542 baseFormat
= base_filter_format(internalFormat
);
543 if (baseFormat
< 0 || baseFormat
== GL_COLOR_INDEX
) {
544 _mesa_error(ctx
, GL_INVALID_ENUM
, "glCopyConvolutionFilter2D(internalFormat)");
548 if (width
< 0 || width
> MAX_CONVOLUTION_WIDTH
) {
549 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCopyConvolutionFilter2D(width)");
552 if (height
< 0 || height
> MAX_CONVOLUTION_HEIGHT
) {
553 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCopyConvolutionFilter2D(height)");
557 ctx
->Driver
.CopyConvolutionFilter2D( ctx
, target
, internalFormat
, x
, y
,
563 _mesa_GetConvolutionFilter(GLenum target
, GLenum format
, GLenum type
,
566 struct gl_convolution_attrib
*filter
;
568 GET_CURRENT_CONTEXT(ctx
);
569 ASSERT_OUTSIDE_BEGIN_END(ctx
);
572 _mesa_update_state(ctx
);
575 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
)) {
576 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetConvolutionFilter(format or type)");
580 if (format
== GL_COLOR_INDEX
||
581 format
== GL_STENCIL_INDEX
||
582 format
== GL_DEPTH_COMPONENT
||
583 format
== GL_INTENSITY
||
585 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionFilter(format or type)");
590 case GL_CONVOLUTION_1D
:
591 filter
= &(ctx
->Convolution1D
);
593 case GL_CONVOLUTION_2D
:
594 filter
= &(ctx
->Convolution2D
);
597 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionFilter(target)");
601 if (ctx
->Pack
.BufferObj
->Name
) {
602 /* Pack the filter into a PBO */
604 if (!_mesa_validate_pbo_access(2, &ctx
->Pack
,
605 filter
->Width
, filter
->Height
,
606 1, format
, type
, image
)) {
607 _mesa_error(ctx
, GL_INVALID_OPERATION
,
608 "glGetConvolutionFilter(invalid PBO access)");
611 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
613 ctx
->Pack
.BufferObj
);
615 /* buffer is already mapped - that's an error */
616 _mesa_error(ctx
, GL_INVALID_OPERATION
,
617 "glGetConvolutionFilter(PBO is mapped)");
620 image
= ADD_POINTERS(image
, buf
);
623 for (row
= 0; row
< filter
->Height
; row
++) {
624 GLvoid
*dst
= _mesa_image_address2d(&ctx
->Pack
, image
, filter
->Width
,
625 filter
->Height
, format
, type
,
627 GLfloat (*src
)[4] = (GLfloat (*)[4]) (filter
->Filter
+ row
* filter
->Width
* 4);
628 _mesa_pack_rgba_span_float(ctx
, filter
->Width
, src
,
629 format
, type
, dst
, &ctx
->Pack
, 0x0);
632 if (ctx
->Pack
.BufferObj
->Name
) {
633 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
634 ctx
->Pack
.BufferObj
);
640 _mesa_GetConvolutionParameterfv(GLenum target
, GLenum pname
, GLfloat
*params
)
642 GET_CURRENT_CONTEXT(ctx
);
643 const struct gl_convolution_attrib
*conv
;
645 ASSERT_OUTSIDE_BEGIN_END(ctx
);
648 case GL_CONVOLUTION_1D
:
650 conv
= &ctx
->Convolution1D
;
652 case GL_CONVOLUTION_2D
:
654 conv
= &ctx
->Convolution2D
;
656 case GL_SEPARABLE_2D
:
658 conv
= &ctx
->Separable2D
;
661 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionParameterfv(target)");
666 case GL_CONVOLUTION_BORDER_COLOR
:
667 COPY_4V(params
, ctx
->Pixel
.ConvolutionBorderColor
[c
]);
669 case GL_CONVOLUTION_BORDER_MODE
:
670 *params
= (GLfloat
) ctx
->Pixel
.ConvolutionBorderMode
[c
];
672 case GL_CONVOLUTION_FILTER_SCALE
:
673 COPY_4V(params
, ctx
->Pixel
.ConvolutionFilterScale
[c
]);
675 case GL_CONVOLUTION_FILTER_BIAS
:
676 COPY_4V(params
, ctx
->Pixel
.ConvolutionFilterBias
[c
]);
678 case GL_CONVOLUTION_FORMAT
:
679 *params
= (GLfloat
) conv
->Format
;
681 case GL_CONVOLUTION_WIDTH
:
682 *params
= (GLfloat
) conv
->Width
;
684 case GL_CONVOLUTION_HEIGHT
:
685 *params
= (GLfloat
) conv
->Height
;
687 case GL_MAX_CONVOLUTION_WIDTH
:
688 *params
= (GLfloat
) ctx
->Const
.MaxConvolutionWidth
;
690 case GL_MAX_CONVOLUTION_HEIGHT
:
691 *params
= (GLfloat
) ctx
->Const
.MaxConvolutionHeight
;
694 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionParameterfv(pname)");
701 _mesa_GetConvolutionParameteriv(GLenum target
, GLenum pname
, GLint
*params
)
703 GET_CURRENT_CONTEXT(ctx
);
704 const struct gl_convolution_attrib
*conv
;
706 ASSERT_OUTSIDE_BEGIN_END(ctx
);
709 case GL_CONVOLUTION_1D
:
711 conv
= &ctx
->Convolution1D
;
713 case GL_CONVOLUTION_2D
:
715 conv
= &ctx
->Convolution2D
;
717 case GL_SEPARABLE_2D
:
719 conv
= &ctx
->Separable2D
;
722 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionParameteriv(target)");
727 case GL_CONVOLUTION_BORDER_COLOR
:
728 params
[0] = FLOAT_TO_INT(ctx
->Pixel
.ConvolutionBorderColor
[c
][0]);
729 params
[1] = FLOAT_TO_INT(ctx
->Pixel
.ConvolutionBorderColor
[c
][1]);
730 params
[2] = FLOAT_TO_INT(ctx
->Pixel
.ConvolutionBorderColor
[c
][2]);
731 params
[3] = FLOAT_TO_INT(ctx
->Pixel
.ConvolutionBorderColor
[c
][3]);
733 case GL_CONVOLUTION_BORDER_MODE
:
734 *params
= (GLint
) ctx
->Pixel
.ConvolutionBorderMode
[c
];
736 case GL_CONVOLUTION_FILTER_SCALE
:
737 params
[0] = (GLint
) ctx
->Pixel
.ConvolutionFilterScale
[c
][0];
738 params
[1] = (GLint
) ctx
->Pixel
.ConvolutionFilterScale
[c
][1];
739 params
[2] = (GLint
) ctx
->Pixel
.ConvolutionFilterScale
[c
][2];
740 params
[3] = (GLint
) ctx
->Pixel
.ConvolutionFilterScale
[c
][3];
742 case GL_CONVOLUTION_FILTER_BIAS
:
743 params
[0] = (GLint
) ctx
->Pixel
.ConvolutionFilterBias
[c
][0];
744 params
[1] = (GLint
) ctx
->Pixel
.ConvolutionFilterBias
[c
][1];
745 params
[2] = (GLint
) ctx
->Pixel
.ConvolutionFilterBias
[c
][2];
746 params
[3] = (GLint
) ctx
->Pixel
.ConvolutionFilterBias
[c
][3];
748 case GL_CONVOLUTION_FORMAT
:
749 *params
= (GLint
) conv
->Format
;
751 case GL_CONVOLUTION_WIDTH
:
752 *params
= (GLint
) conv
->Width
;
754 case GL_CONVOLUTION_HEIGHT
:
755 *params
= (GLint
) conv
->Height
;
757 case GL_MAX_CONVOLUTION_WIDTH
:
758 *params
= (GLint
) ctx
->Const
.MaxConvolutionWidth
;
760 case GL_MAX_CONVOLUTION_HEIGHT
:
761 *params
= (GLint
) ctx
->Const
.MaxConvolutionHeight
;
764 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionParameteriv(pname)");
771 _mesa_GetSeparableFilter(GLenum target
, GLenum format
, GLenum type
,
772 GLvoid
*row
, GLvoid
*column
, GLvoid
*span
)
774 const GLint colStart
= MAX_CONVOLUTION_WIDTH
* 4;
775 struct gl_convolution_attrib
*filter
;
776 GET_CURRENT_CONTEXT(ctx
);
777 ASSERT_OUTSIDE_BEGIN_END(ctx
);
780 _mesa_update_state(ctx
);
783 if (target
!= GL_SEPARABLE_2D
) {
784 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetSeparableFilter(target)");
788 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
)) {
789 _mesa_error(ctx
, GL_INVALID_OPERATION
,
790 "glGetConvolutionFilter(format or type)");
794 if (format
== GL_COLOR_INDEX
||
795 format
== GL_STENCIL_INDEX
||
796 format
== GL_DEPTH_COMPONENT
||
797 format
== GL_INTENSITY
||
799 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetConvolutionFilter(format or type)");
803 filter
= &ctx
->Separable2D
;
805 if (ctx
->Pack
.BufferObj
->Name
) {
806 /* Pack filter into PBO */
808 if (!_mesa_validate_pbo_access(1, &ctx
->Pack
, filter
->Width
, 1, 1,
809 format
, type
, row
)) {
810 _mesa_error(ctx
, GL_INVALID_OPERATION
,
811 "glGetSeparableFilter(invalid PBO access, width)");
814 if (!_mesa_validate_pbo_access(1, &ctx
->Pack
, filter
->Height
, 1, 1,
815 format
, type
, column
)) {
816 _mesa_error(ctx
, GL_INVALID_OPERATION
,
817 "glGetSeparableFilter(invalid PBO access, height)");
820 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
822 ctx
->Pack
.BufferObj
);
824 /* buffer is already mapped - that's an error */
825 _mesa_error(ctx
, GL_INVALID_OPERATION
,
826 "glGetSeparableFilter(PBO is mapped)");
829 row
= ADD_POINTERS(buf
, row
);
830 column
= ADD_POINTERS(buf
, column
);
835 GLvoid
*dst
= _mesa_image_address1d(&ctx
->Pack
, row
, filter
->Width
,
837 _mesa_pack_rgba_span_float(ctx
, filter
->Width
,
838 (GLfloat (*)[4]) filter
->Filter
,
839 format
, type
, dst
, &ctx
->Pack
, 0x0);
844 GLvoid
*dst
= _mesa_image_address1d(&ctx
->Pack
, column
, filter
->Height
,
846 GLfloat (*src
)[4] = (GLfloat (*)[4]) (filter
->Filter
+ colStart
);
847 _mesa_pack_rgba_span_float(ctx
, filter
->Height
, src
,
848 format
, type
, dst
, &ctx
->Pack
, 0x0);
851 (void) span
; /* unused at this time */
853 if (ctx
->Pack
.BufferObj
->Name
) {
854 /* Pack filter into PBO */
855 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
856 ctx
->Unpack
.BufferObj
);
862 _mesa_SeparableFilter2D(GLenum target
, GLenum internalFormat
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*row
, const GLvoid
*column
)
864 const GLint colStart
= MAX_CONVOLUTION_WIDTH
* 4;
866 GET_CURRENT_CONTEXT(ctx
);
867 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
869 if (target
!= GL_SEPARABLE_2D
) {
870 _mesa_error(ctx
, GL_INVALID_ENUM
, "glSeparableFilter2D(target)");
874 baseFormat
= base_filter_format(internalFormat
);
875 if (baseFormat
< 0 || baseFormat
== GL_COLOR_INDEX
) {
876 _mesa_error(ctx
, GL_INVALID_ENUM
, "glSeparableFilter2D(internalFormat)");
880 if (width
< 0 || width
> MAX_CONVOLUTION_WIDTH
) {
881 _mesa_error(ctx
, GL_INVALID_VALUE
, "glSeparableFilter2D(width)");
884 if (height
< 0 || height
> MAX_CONVOLUTION_HEIGHT
) {
885 _mesa_error(ctx
, GL_INVALID_VALUE
, "glSeparableFilter2D(height)");
889 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
)) {
890 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glSeparableFilter2D(format or type)");
894 if (format
== GL_COLOR_INDEX
||
895 format
== GL_STENCIL_INDEX
||
896 format
== GL_DEPTH_COMPONENT
||
897 format
== GL_INTENSITY
||
899 _mesa_error(ctx
, GL_INVALID_ENUM
, "glSeparableFilter2D(format or type)");
903 ctx
->Separable2D
.Format
= format
;
904 ctx
->Separable2D
.InternalFormat
= internalFormat
;
905 ctx
->Separable2D
.Width
= width
;
906 ctx
->Separable2D
.Height
= height
;
908 if (ctx
->Unpack
.BufferObj
->Name
) {
909 /* unpack filter from PBO */
911 if (!_mesa_validate_pbo_access(1, &ctx
->Unpack
, width
, 1, 1,
912 format
, type
, row
)) {
913 _mesa_error(ctx
, GL_INVALID_OPERATION
,
914 "glSeparableFilter2D(invalid PBO access, width)");
917 if (!_mesa_validate_pbo_access(1, &ctx
->Unpack
, height
, 1, 1,
918 format
, type
, column
)) {
919 _mesa_error(ctx
, GL_INVALID_OPERATION
,
920 "glSeparableFilter2D(invalid PBO access, height)");
923 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
925 ctx
->Unpack
.BufferObj
);
927 /* buffer is already mapped - that's an error */
928 _mesa_error(ctx
, GL_INVALID_OPERATION
,
929 "glSeparableFilter2D(PBO is mapped)");
932 row
= ADD_POINTERS(buf
, row
);
933 column
= ADD_POINTERS(buf
, column
);
936 /* unpack row filter */
938 _mesa_unpack_color_span_float(ctx
, width
, GL_RGBA
,
939 ctx
->Separable2D
.Filter
,
940 format
, type
, row
, &ctx
->Unpack
,
941 0); /* transferOps */
943 _mesa_scale_and_bias_rgba(width
,
944 (GLfloat (*)[4]) ctx
->Separable2D
.Filter
,
945 ctx
->Pixel
.ConvolutionFilterScale
[2][0],
946 ctx
->Pixel
.ConvolutionFilterScale
[2][1],
947 ctx
->Pixel
.ConvolutionFilterScale
[2][2],
948 ctx
->Pixel
.ConvolutionFilterScale
[2][3],
949 ctx
->Pixel
.ConvolutionFilterBias
[2][0],
950 ctx
->Pixel
.ConvolutionFilterBias
[2][1],
951 ctx
->Pixel
.ConvolutionFilterBias
[2][2],
952 ctx
->Pixel
.ConvolutionFilterBias
[2][3]);
955 /* unpack column filter */
957 _mesa_unpack_color_span_float(ctx
, height
, GL_RGBA
,
958 &ctx
->Separable2D
.Filter
[colStart
],
959 format
, type
, column
, &ctx
->Unpack
,
960 0); /* transferOps */
962 _mesa_scale_and_bias_rgba(height
,
963 (GLfloat (*)[4]) (ctx
->Separable2D
.Filter
+ colStart
),
964 ctx
->Pixel
.ConvolutionFilterScale
[2][0],
965 ctx
->Pixel
.ConvolutionFilterScale
[2][1],
966 ctx
->Pixel
.ConvolutionFilterScale
[2][2],
967 ctx
->Pixel
.ConvolutionFilterScale
[2][3],
968 ctx
->Pixel
.ConvolutionFilterBias
[2][0],
969 ctx
->Pixel
.ConvolutionFilterBias
[2][1],
970 ctx
->Pixel
.ConvolutionFilterBias
[2][2],
971 ctx
->Pixel
.ConvolutionFilterBias
[2][3]);
974 if (ctx
->Unpack
.BufferObj
->Name
) {
975 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
976 ctx
->Unpack
.BufferObj
);
979 ctx
->NewState
|= _NEW_PIXEL
;
983 /**********************************************************************/
984 /*** image convolution functions ***/
985 /**********************************************************************/
988 convolve_1d_reduce(GLint srcWidth
, const GLfloat src
[][4],
989 GLint filterWidth
, const GLfloat filter
[][4],
995 if (filterWidth
>= 1)
996 dstWidth
= srcWidth
- (filterWidth
- 1);
1001 return; /* null result */
1003 for (i
= 0; i
< dstWidth
; i
++) {
1008 for (n
= 0; n
< filterWidth
; n
++) {
1009 sumR
+= src
[i
+ n
][RCOMP
] * filter
[n
][RCOMP
];
1010 sumG
+= src
[i
+ n
][GCOMP
] * filter
[n
][GCOMP
];
1011 sumB
+= src
[i
+ n
][BCOMP
] * filter
[n
][BCOMP
];
1012 sumA
+= src
[i
+ n
][ACOMP
] * filter
[n
][ACOMP
];
1014 dest
[i
][RCOMP
] = sumR
;
1015 dest
[i
][GCOMP
] = sumG
;
1016 dest
[i
][BCOMP
] = sumB
;
1017 dest
[i
][ACOMP
] = sumA
;
1023 convolve_1d_constant(GLint srcWidth
, const GLfloat src
[][4],
1024 GLint filterWidth
, const GLfloat filter
[][4],
1026 const GLfloat borderColor
[4])
1028 const GLint halfFilterWidth
= filterWidth
/ 2;
1031 for (i
= 0; i
< srcWidth
; i
++) {
1036 for (n
= 0; n
< filterWidth
; n
++) {
1037 if (i
+ n
< halfFilterWidth
|| i
+ n
- halfFilterWidth
>= srcWidth
) {
1038 sumR
+= borderColor
[RCOMP
] * filter
[n
][RCOMP
];
1039 sumG
+= borderColor
[GCOMP
] * filter
[n
][GCOMP
];
1040 sumB
+= borderColor
[BCOMP
] * filter
[n
][BCOMP
];
1041 sumA
+= borderColor
[ACOMP
] * filter
[n
][ACOMP
];
1044 sumR
+= src
[i
+ n
- halfFilterWidth
][RCOMP
] * filter
[n
][RCOMP
];
1045 sumG
+= src
[i
+ n
- halfFilterWidth
][GCOMP
] * filter
[n
][GCOMP
];
1046 sumB
+= src
[i
+ n
- halfFilterWidth
][BCOMP
] * filter
[n
][BCOMP
];
1047 sumA
+= src
[i
+ n
- halfFilterWidth
][ACOMP
] * filter
[n
][ACOMP
];
1050 dest
[i
][RCOMP
] = sumR
;
1051 dest
[i
][GCOMP
] = sumG
;
1052 dest
[i
][BCOMP
] = sumB
;
1053 dest
[i
][ACOMP
] = sumA
;
1059 convolve_1d_replicate(GLint srcWidth
, const GLfloat src
[][4],
1060 GLint filterWidth
, const GLfloat filter
[][4],
1063 const GLint halfFilterWidth
= filterWidth
/ 2;
1066 for (i
= 0; i
< srcWidth
; i
++) {
1071 for (n
= 0; n
< filterWidth
; n
++) {
1072 if (i
+ n
< halfFilterWidth
) {
1073 sumR
+= src
[0][RCOMP
] * filter
[n
][RCOMP
];
1074 sumG
+= src
[0][GCOMP
] * filter
[n
][GCOMP
];
1075 sumB
+= src
[0][BCOMP
] * filter
[n
][BCOMP
];
1076 sumA
+= src
[0][ACOMP
] * filter
[n
][ACOMP
];
1078 else if (i
+ n
- halfFilterWidth
>= srcWidth
) {
1079 sumR
+= src
[srcWidth
- 1][RCOMP
] * filter
[n
][RCOMP
];
1080 sumG
+= src
[srcWidth
- 1][GCOMP
] * filter
[n
][GCOMP
];
1081 sumB
+= src
[srcWidth
- 1][BCOMP
] * filter
[n
][BCOMP
];
1082 sumA
+= src
[srcWidth
- 1][ACOMP
] * filter
[n
][ACOMP
];
1085 sumR
+= src
[i
+ n
- halfFilterWidth
][RCOMP
] * filter
[n
][RCOMP
];
1086 sumG
+= src
[i
+ n
- halfFilterWidth
][GCOMP
] * filter
[n
][GCOMP
];
1087 sumB
+= src
[i
+ n
- halfFilterWidth
][BCOMP
] * filter
[n
][BCOMP
];
1088 sumA
+= src
[i
+ n
- halfFilterWidth
][ACOMP
] * filter
[n
][ACOMP
];
1091 dest
[i
][RCOMP
] = sumR
;
1092 dest
[i
][GCOMP
] = sumG
;
1093 dest
[i
][BCOMP
] = sumB
;
1094 dest
[i
][ACOMP
] = sumA
;
1100 convolve_2d_reduce(GLint srcWidth
, GLint srcHeight
,
1101 const GLfloat src
[][4],
1102 GLint filterWidth
, GLint filterHeight
,
1103 const GLfloat filter
[][4],
1106 GLint dstWidth
, dstHeight
;
1109 if (filterWidth
>= 1)
1110 dstWidth
= srcWidth
- (filterWidth
- 1);
1112 dstWidth
= srcWidth
;
1114 if (filterHeight
>= 1)
1115 dstHeight
= srcHeight
- (filterHeight
- 1);
1117 dstHeight
= srcHeight
;
1119 if (dstWidth
<= 0 || dstHeight
<= 0)
1122 for (j
= 0; j
< dstHeight
; j
++) {
1123 for (i
= 0; i
< dstWidth
; i
++) {
1128 for (m
= 0; m
< filterHeight
; m
++) {
1129 for (n
= 0; n
< filterWidth
; n
++) {
1130 const GLint k
= (j
+ m
) * srcWidth
+ i
+ n
;
1131 const GLint f
= m
* filterWidth
+ n
;
1132 sumR
+= src
[k
][RCOMP
] * filter
[f
][RCOMP
];
1133 sumG
+= src
[k
][GCOMP
] * filter
[f
][GCOMP
];
1134 sumB
+= src
[k
][BCOMP
] * filter
[f
][BCOMP
];
1135 sumA
+= src
[k
][ACOMP
] * filter
[f
][ACOMP
];
1138 dest
[j
* dstWidth
+ i
][RCOMP
] = sumR
;
1139 dest
[j
* dstWidth
+ i
][GCOMP
] = sumG
;
1140 dest
[j
* dstWidth
+ i
][BCOMP
] = sumB
;
1141 dest
[j
* dstWidth
+ i
][ACOMP
] = sumA
;
1148 convolve_2d_constant(GLint srcWidth
, GLint srcHeight
,
1149 const GLfloat src
[][4],
1150 GLint filterWidth
, GLint filterHeight
,
1151 const GLfloat filter
[][4],
1153 const GLfloat borderColor
[4])
1155 const GLint halfFilterWidth
= filterWidth
/ 2;
1156 const GLint halfFilterHeight
= filterHeight
/ 2;
1159 for (j
= 0; j
< srcHeight
; j
++) {
1160 for (i
= 0; i
< srcWidth
; i
++) {
1165 for (m
= 0; m
< filterHeight
; m
++) {
1166 for (n
= 0; n
< filterWidth
; n
++) {
1167 const GLint f
= m
* filterWidth
+ n
;
1168 const GLint is
= i
+ n
- halfFilterWidth
;
1169 const GLint js
= j
+ m
- halfFilterHeight
;
1170 if (is
< 0 || is
>= srcWidth
||
1171 js
< 0 || js
>= srcHeight
) {
1172 sumR
+= borderColor
[RCOMP
] * filter
[f
][RCOMP
];
1173 sumG
+= borderColor
[GCOMP
] * filter
[f
][GCOMP
];
1174 sumB
+= borderColor
[BCOMP
] * filter
[f
][BCOMP
];
1175 sumA
+= borderColor
[ACOMP
] * filter
[f
][ACOMP
];
1178 const GLint k
= js
* srcWidth
+ is
;
1179 sumR
+= src
[k
][RCOMP
] * filter
[f
][RCOMP
];
1180 sumG
+= src
[k
][GCOMP
] * filter
[f
][GCOMP
];
1181 sumB
+= src
[k
][BCOMP
] * filter
[f
][BCOMP
];
1182 sumA
+= src
[k
][ACOMP
] * filter
[f
][ACOMP
];
1186 dest
[j
* srcWidth
+ i
][RCOMP
] = sumR
;
1187 dest
[j
* srcWidth
+ i
][GCOMP
] = sumG
;
1188 dest
[j
* srcWidth
+ i
][BCOMP
] = sumB
;
1189 dest
[j
* srcWidth
+ i
][ACOMP
] = sumA
;
1196 convolve_2d_replicate(GLint srcWidth
, GLint srcHeight
,
1197 const GLfloat src
[][4],
1198 GLint filterWidth
, GLint filterHeight
,
1199 const GLfloat filter
[][4],
1202 const GLint halfFilterWidth
= filterWidth
/ 2;
1203 const GLint halfFilterHeight
= filterHeight
/ 2;
1206 for (j
= 0; j
< srcHeight
; j
++) {
1207 for (i
= 0; i
< srcWidth
; i
++) {
1212 for (m
= 0; m
< filterHeight
; m
++) {
1213 for (n
= 0; n
< filterWidth
; n
++) {
1214 const GLint f
= m
* filterWidth
+ n
;
1215 GLint is
= i
+ n
- halfFilterWidth
;
1216 GLint js
= j
+ m
- halfFilterHeight
;
1220 else if (is
>= srcWidth
)
1224 else if (js
>= srcHeight
)
1226 k
= js
* srcWidth
+ is
;
1227 sumR
+= src
[k
][RCOMP
] * filter
[f
][RCOMP
];
1228 sumG
+= src
[k
][GCOMP
] * filter
[f
][GCOMP
];
1229 sumB
+= src
[k
][BCOMP
] * filter
[f
][BCOMP
];
1230 sumA
+= src
[k
][ACOMP
] * filter
[f
][ACOMP
];
1233 dest
[j
* srcWidth
+ i
][RCOMP
] = sumR
;
1234 dest
[j
* srcWidth
+ i
][GCOMP
] = sumG
;
1235 dest
[j
* srcWidth
+ i
][BCOMP
] = sumB
;
1236 dest
[j
* srcWidth
+ i
][ACOMP
] = sumA
;
1243 convolve_sep_reduce(GLint srcWidth
, GLint srcHeight
,
1244 const GLfloat src
[][4],
1245 GLint filterWidth
, GLint filterHeight
,
1246 const GLfloat rowFilt
[][4],
1247 const GLfloat colFilt
[][4],
1250 GLint dstWidth
, dstHeight
;
1253 if (filterWidth
>= 1)
1254 dstWidth
= srcWidth
- (filterWidth
- 1);
1256 dstWidth
= srcWidth
;
1258 if (filterHeight
>= 1)
1259 dstHeight
= srcHeight
- (filterHeight
- 1);
1261 dstHeight
= srcHeight
;
1263 if (dstWidth
<= 0 || dstHeight
<= 0)
1266 for (j
= 0; j
< dstHeight
; j
++) {
1267 for (i
= 0; i
< dstWidth
; i
++) {
1272 for (m
= 0; m
< filterHeight
; m
++) {
1273 for (n
= 0; n
< filterWidth
; n
++) {
1274 GLint k
= (j
+ m
) * srcWidth
+ i
+ n
;
1275 sumR
+= src
[k
][RCOMP
] * rowFilt
[n
][RCOMP
] * colFilt
[m
][RCOMP
];
1276 sumG
+= src
[k
][GCOMP
] * rowFilt
[n
][GCOMP
] * colFilt
[m
][GCOMP
];
1277 sumB
+= src
[k
][BCOMP
] * rowFilt
[n
][BCOMP
] * colFilt
[m
][BCOMP
];
1278 sumA
+= src
[k
][ACOMP
] * rowFilt
[n
][ACOMP
] * colFilt
[m
][ACOMP
];
1281 dest
[j
* dstWidth
+ i
][RCOMP
] = sumR
;
1282 dest
[j
* dstWidth
+ i
][GCOMP
] = sumG
;
1283 dest
[j
* dstWidth
+ i
][BCOMP
] = sumB
;
1284 dest
[j
* dstWidth
+ i
][ACOMP
] = sumA
;
1291 convolve_sep_constant(GLint srcWidth
, GLint srcHeight
,
1292 const GLfloat src
[][4],
1293 GLint filterWidth
, GLint filterHeight
,
1294 const GLfloat rowFilt
[][4],
1295 const GLfloat colFilt
[][4],
1297 const GLfloat borderColor
[4])
1299 const GLint halfFilterWidth
= filterWidth
/ 2;
1300 const GLint halfFilterHeight
= filterHeight
/ 2;
1303 for (j
= 0; j
< srcHeight
; j
++) {
1304 for (i
= 0; i
< srcWidth
; i
++) {
1309 for (m
= 0; m
< filterHeight
; m
++) {
1310 for (n
= 0; n
< filterWidth
; n
++) {
1311 const GLint is
= i
+ n
- halfFilterWidth
;
1312 const GLint js
= j
+ m
- halfFilterHeight
;
1313 if (is
< 0 || is
>= srcWidth
||
1314 js
< 0 || js
>= srcHeight
) {
1315 sumR
+= borderColor
[RCOMP
] * rowFilt
[n
][RCOMP
] * colFilt
[m
][RCOMP
];
1316 sumG
+= borderColor
[GCOMP
] * rowFilt
[n
][GCOMP
] * colFilt
[m
][GCOMP
];
1317 sumB
+= borderColor
[BCOMP
] * rowFilt
[n
][BCOMP
] * colFilt
[m
][BCOMP
];
1318 sumA
+= borderColor
[ACOMP
] * rowFilt
[n
][ACOMP
] * colFilt
[m
][ACOMP
];
1321 GLint k
= js
* srcWidth
+ is
;
1322 sumR
+= src
[k
][RCOMP
] * rowFilt
[n
][RCOMP
] * colFilt
[m
][RCOMP
];
1323 sumG
+= src
[k
][GCOMP
] * rowFilt
[n
][GCOMP
] * colFilt
[m
][GCOMP
];
1324 sumB
+= src
[k
][BCOMP
] * rowFilt
[n
][BCOMP
] * colFilt
[m
][BCOMP
];
1325 sumA
+= src
[k
][ACOMP
] * rowFilt
[n
][ACOMP
] * colFilt
[m
][ACOMP
];
1330 dest
[j
* srcWidth
+ i
][RCOMP
] = sumR
;
1331 dest
[j
* srcWidth
+ i
][GCOMP
] = sumG
;
1332 dest
[j
* srcWidth
+ i
][BCOMP
] = sumB
;
1333 dest
[j
* srcWidth
+ i
][ACOMP
] = sumA
;
1340 convolve_sep_replicate(GLint srcWidth
, GLint srcHeight
,
1341 const GLfloat src
[][4],
1342 GLint filterWidth
, GLint filterHeight
,
1343 const GLfloat rowFilt
[][4],
1344 const GLfloat colFilt
[][4],
1347 const GLint halfFilterWidth
= filterWidth
/ 2;
1348 const GLint halfFilterHeight
= filterHeight
/ 2;
1351 for (j
= 0; j
< srcHeight
; j
++) {
1352 for (i
= 0; i
< srcWidth
; i
++) {
1357 for (m
= 0; m
< filterHeight
; m
++) {
1358 for (n
= 0; n
< filterWidth
; n
++) {
1359 GLint is
= i
+ n
- halfFilterWidth
;
1360 GLint js
= j
+ m
- halfFilterHeight
;
1364 else if (is
>= srcWidth
)
1368 else if (js
>= srcHeight
)
1370 k
= js
* srcWidth
+ is
;
1371 sumR
+= src
[k
][RCOMP
] * rowFilt
[n
][RCOMP
] * colFilt
[m
][RCOMP
];
1372 sumG
+= src
[k
][GCOMP
] * rowFilt
[n
][GCOMP
] * colFilt
[m
][GCOMP
];
1373 sumB
+= src
[k
][BCOMP
] * rowFilt
[n
][BCOMP
] * colFilt
[m
][BCOMP
];
1374 sumA
+= src
[k
][ACOMP
] * rowFilt
[n
][ACOMP
] * colFilt
[m
][ACOMP
];
1377 dest
[j
* srcWidth
+ i
][RCOMP
] = sumR
;
1378 dest
[j
* srcWidth
+ i
][GCOMP
] = sumG
;
1379 dest
[j
* srcWidth
+ i
][BCOMP
] = sumB
;
1380 dest
[j
* srcWidth
+ i
][ACOMP
] = sumA
;
1388 _mesa_convolve_1d_image(const GLcontext
*ctx
, GLsizei
*width
,
1389 const GLfloat
*srcImage
, GLfloat
*dstImage
)
1391 switch (ctx
->Pixel
.ConvolutionBorderMode
[0]) {
1393 convolve_1d_reduce(*width
, (const GLfloat (*)[4]) srcImage
,
1394 ctx
->Convolution1D
.Width
,
1395 (const GLfloat (*)[4]) ctx
->Convolution1D
.Filter
,
1396 (GLfloat (*)[4]) dstImage
);
1397 *width
= *width
- (MAX2(ctx
->Convolution1D
.Width
, 1) - 1);
1399 case GL_CONSTANT_BORDER
:
1400 convolve_1d_constant(*width
, (const GLfloat (*)[4]) srcImage
,
1401 ctx
->Convolution1D
.Width
,
1402 (const GLfloat (*)[4]) ctx
->Convolution1D
.Filter
,
1403 (GLfloat (*)[4]) dstImage
,
1404 ctx
->Pixel
.ConvolutionBorderColor
[0]);
1406 case GL_REPLICATE_BORDER
:
1407 convolve_1d_replicate(*width
, (const GLfloat (*)[4]) srcImage
,
1408 ctx
->Convolution1D
.Width
,
1409 (const GLfloat (*)[4]) ctx
->Convolution1D
.Filter
,
1410 (GLfloat (*)[4]) dstImage
);
1419 _mesa_convolve_2d_image(const GLcontext
*ctx
, GLsizei
*width
, GLsizei
*height
,
1420 const GLfloat
*srcImage
, GLfloat
*dstImage
)
1422 switch (ctx
->Pixel
.ConvolutionBorderMode
[1]) {
1424 convolve_2d_reduce(*width
, *height
,
1425 (const GLfloat (*)[4]) srcImage
,
1426 ctx
->Convolution2D
.Width
,
1427 ctx
->Convolution2D
.Height
,
1428 (const GLfloat (*)[4]) ctx
->Convolution2D
.Filter
,
1429 (GLfloat (*)[4]) dstImage
);
1430 *width
= *width
- (MAX2(ctx
->Convolution2D
.Width
, 1) - 1);
1431 *height
= *height
- (MAX2(ctx
->Convolution2D
.Height
, 1) - 1);
1433 case GL_CONSTANT_BORDER
:
1434 convolve_2d_constant(*width
, *height
,
1435 (const GLfloat (*)[4]) srcImage
,
1436 ctx
->Convolution2D
.Width
,
1437 ctx
->Convolution2D
.Height
,
1438 (const GLfloat (*)[4]) ctx
->Convolution2D
.Filter
,
1439 (GLfloat (*)[4]) dstImage
,
1440 ctx
->Pixel
.ConvolutionBorderColor
[1]);
1442 case GL_REPLICATE_BORDER
:
1443 convolve_2d_replicate(*width
, *height
,
1444 (const GLfloat (*)[4]) srcImage
,
1445 ctx
->Convolution2D
.Width
,
1446 ctx
->Convolution2D
.Height
,
1447 (const GLfloat (*)[4])ctx
->Convolution2D
.Filter
,
1448 (GLfloat (*)[4]) dstImage
);
1457 _mesa_convolve_sep_image(const GLcontext
*ctx
,
1458 GLsizei
*width
, GLsizei
*height
,
1459 const GLfloat
*srcImage
, GLfloat
*dstImage
)
1461 const GLfloat
*rowFilter
= ctx
->Separable2D
.Filter
;
1462 const GLfloat
*colFilter
= rowFilter
+ 4 * MAX_CONVOLUTION_WIDTH
;
1464 switch (ctx
->Pixel
.ConvolutionBorderMode
[2]) {
1466 convolve_sep_reduce(*width
, *height
,
1467 (const GLfloat (*)[4]) srcImage
,
1468 ctx
->Separable2D
.Width
,
1469 ctx
->Separable2D
.Height
,
1470 (const GLfloat (*)[4]) rowFilter
,
1471 (const GLfloat (*)[4]) colFilter
,
1472 (GLfloat (*)[4]) dstImage
);
1473 *width
= *width
- (MAX2(ctx
->Separable2D
.Width
, 1) - 1);
1474 *height
= *height
- (MAX2(ctx
->Separable2D
.Height
, 1) - 1);
1476 case GL_CONSTANT_BORDER
:
1477 convolve_sep_constant(*width
, *height
,
1478 (const GLfloat (*)[4]) srcImage
,
1479 ctx
->Separable2D
.Width
,
1480 ctx
->Separable2D
.Height
,
1481 (const GLfloat (*)[4]) rowFilter
,
1482 (const GLfloat (*)[4]) colFilter
,
1483 (GLfloat (*)[4]) dstImage
,
1484 ctx
->Pixel
.ConvolutionBorderColor
[2]);
1486 case GL_REPLICATE_BORDER
:
1487 convolve_sep_replicate(*width
, *height
,
1488 (const GLfloat (*)[4]) srcImage
,
1489 ctx
->Separable2D
.Width
,
1490 ctx
->Separable2D
.Height
,
1491 (const GLfloat (*)[4]) rowFilter
,
1492 (const GLfloat (*)[4]) colFilter
,
1493 (GLfloat (*)[4]) dstImage
);
1503 * This function computes an image's size after convolution.
1504 * If the convolution border mode is GL_REDUCE, the post-convolution
1505 * image will be smaller than the original.
1508 _mesa_adjust_image_for_convolution(const GLcontext
*ctx
, GLuint dimensions
,
1509 GLsizei
*width
, GLsizei
*height
)
1511 if (ctx
->Pixel
.Convolution1DEnabled
1513 && ctx
->Pixel
.ConvolutionBorderMode
[0] == GL_REDUCE
) {
1514 *width
= *width
- (MAX2(ctx
->Convolution1D
.Width
, 1) - 1);
1516 else if (ctx
->Pixel
.Convolution2DEnabled
1518 && ctx
->Pixel
.ConvolutionBorderMode
[1] == GL_REDUCE
) {
1519 *width
= *width
- (MAX2(ctx
->Convolution2D
.Width
, 1) - 1);
1520 *height
= *height
- (MAX2(ctx
->Convolution2D
.Height
, 1) - 1);
1522 else if (ctx
->Pixel
.Separable2DEnabled
1524 && ctx
->Pixel
.ConvolutionBorderMode
[2] == GL_REDUCE
) {
1525 *width
= *width
- (MAX2(ctx
->Separable2D
.Width
, 1) - 1);
1526 *height
= *height
- (MAX2(ctx
->Separable2D
.Height
, 1) - 1);