Back to the OpenGL extension cross reference
GL_EXT_convolution
EXT_convolution
Name Strings
GL_EXT_convolution
Version
Date: June 27, 2002 Version: 1.32
Number
12
Dependencies
EXT_abgr affects the definition of this extension
EXT_texture is required
EXT_copy_texture affects the definition of this extension
Overview
This extension defines 1 and 2 dimensional convolution operations
at a fixed location in the pixel transfer process. Thus pixel drawing,
reading, and copying, as well as texture image definition, are all
candidates for convolution. The convolution kernels are themselves
treated as 1 and 2 dimensional images, which can be loaded from
application memory or from the framebuffer.
This extension is designed to accommodate 3D convolution, but the
API is left for a future extension.
void ConvolutionFilter1DEXT(enum target,
enum internalformat,
sizei width,
enum format,
enum type,
const void* image);
void ConvolutionFilter2DEXT(enum target,
enum internalformat,
sizei width,
sizei height,
enum format,
enum type,
const void* image);
void CopyConvolutionFilter1DEXT(enum target,
enum internalformat,
int x,
int y,
sizei width);
void CopyConvolutionFilter2DEXT(enum target,
enum internalformat,
int x,
int y,
sizei width,
sizei height);
void GetConvolutionFilterEXT(enum target,
enum format,
enum type,
void* image);
void SeparableFilter2DEXT(enum target,
enum internalformat,
sizei width,
sizei height,
enum format,
enum type,
const void* row,
const void* column);
void GetSeparableFilterEXT(enum target,
enum format,
enum type,
void* row,
void* column,
void* span);
void ConvolutionParameteriEXT(enum target,
enum pname,
int param);
void ConvolutionParameterivEXT(enum target,
enum pname,
const int* params);
void ConvolutionParameterfEXT(enum target,
enum pname,
float param);
void ConvolutionParameterfvEXT(enum target,
enum pname,
const float* params);
void GetConvolutionParameterivEXT(enum target,
enum pname,
int* params);
void GetConvolutionParameterfvEXT(enum target,
enum pname,
float* params);
Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, by
the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and
GetDoublev, and by the <target> parameter of ConvolutionFilter1DEXT,
CopyConvolutionFilter1DEXT, GetConvolutionFilterEXT,
ConvolutionParameteriEXT, ConvolutionParameterfEXT,
ConvolutionParameterivEXT, ConvolutionParameterfvEXT,
GetConvolutionParameterivEXT, and GetConvolutionParameterfvEXT:
CONVOLUTION_1D_EXT 0x8010
Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, by
the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and
GetDoublev, and by the <target> parameter of ConvolutionFilter2DEXT,
CopyConvolutionFilter2DEXT, GetConvolutionFilterEXT,
ConvolutionParameteriEXT, ConvolutionParameterfEXT,
ConvolutionParameterivEXT, ConvolutionParameterfvEXT,
GetConvolutionParameterivEXT, and GetConvolutionParameterfvEXT:
CONVOLUTION_2D_EXT 0x8011
Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, by
the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and
GetDoublev, and by the <target> parameter of SeparableFilter2DEXT,
SeparableFilter2DEXT, GetSeparableFilterEXT,
ConvolutionParameteriEXT, ConvolutionParameterfEXT,
ConvolutionParameterivEXT, ConvolutionParameterfvEXT,
GetConvolutionParameterivEXT, and GetConvolutionParameterfvEXT:
SEPARABLE_2D_EXT 0x8012
Accepted by the <pname> parameter of ConvolutionParameteriEXT,
ConvolutionParameterfEXT, ConvolutionParameterivEXT,
ConvolutionParameterfvEXT, GetConvolutionParameterivEXT, and
GetConvolutionParameterfvEXT:
CONVOLUTION_BORDER_MODE_EXT 0x8013
Accepted by the <pname> parameter of ConvolutionParameterivEXT,
ConvolutionParameterfvEXT, GetConvolutionParameterivEXT, and
GetConvolutionParameterfvEXT:
CONVOLUTION_FILTER_SCALE_EXT 0x8014
CONVOLUTION_FILTER_BIAS_EXT 0x8015
Accepted by the <param> parameter of ConvolutionParameteriEXT,
and ConvolutionParameterfEXT, and by the <params> parameter of
ConvolutionParameterivEXT and ConvolutionParameterfvEXT, when the
<pname> parameter is CONVOLUTION_BORDER_MODE_EXT:
REDUCE_EXT 0x8016
Accepted by the <pname> parameter of GetConvolutionParameterivEXT and
GetConvolutionParameterfvEXT:
CONVOLUTION_FORMAT_EXT 0x8017
CONVOLUTION_WIDTH_EXT 0x8018
CONVOLUTION_HEIGHT_EXT 0x8019
MAX_CONVOLUTION_WIDTH_EXT 0x801A
MAX_CONVOLUTION_HEIGHT_EXT 0x801B
Accepted by the <pname> parameter of PixelTransferi, PixelTransferf,
and by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv,
and GetDoublev:
POST_CONVOLUTION_RED_SCALE_EXT 0x801C
POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D
POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E
POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F
POST_CONVOLUTION_RED_BIAS_EXT 0x8020
POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021
POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022
POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023
Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
None
Additions to Chapter 3 of the 1.0 Specification (Rasterization)
The specification of convolution operators is added to the GL
Specification in section 3.6.2, "Pixel Transfer Modes." A 2-dimensional
convolution filter image is specified using the ConvolutionFilter2DEXT
command. Its <target> parameter must be CONVOLUTION_2D_EXT. Its
<internalformat> parameter specifies the format of image that will be
retained; it must be one of ALPHA, LUMINANCE, LUMINANCE_ALPHA,
INTENSITY_EXT, RGB, or RGBA. Its <width>, <height>, <format>, <type>,
and <image> parameters specify an image in memory with exactly the same
semantics of the corresponding parameters to DrawPixels.
The specified image is extracted from memory and processed just as if
DrawPixels were called, stopping after the Final Expansion to RGBA step
is completed. The R, G, B, and A components of each pixel are then scaled
by the four 2D CONVOLUTION_FILTER_SCALE_EXT parameters, then biased by the
four 2D CONVOLUTION_FILTER_BIAS_EXT parameters. These parameters are
themselves specified by calling ConvolutionParameterivEXT or
ConvolutionParameterfvEXT with <target> CONVOLUTION_2D_EXT, <pname>
CONVOLUTION_FILTER_SCALE_EXT or CONVOLUTION_FILTER_BIAS_EXT, and <params>
pointing to a vector of four values: red, green, blue, and alpha, in that
order. The R, G, B, and A values are not clamped to [0,1] at any time
during this process.
Each pixel is then converted to have the specified internal format.
This conversion simply maps the component values of the pixel (R, G, B,
and A) to the values included in the internal format (red, green, blue,
alpha, luminance, and intensity). The mapping is as follows:
Internal Format red green blue alpha luminance intensity
--------------- --- ----- ---- ----- --------- ---------
ALPHA A
LUMINANCE R
LUMINANCE_ALPHA A R
INTENSITY_EXT R
RGB R G B
RGBA R G B A
Pixel Organization
The red, green, blue, alpha, luminance, and/or intensity components of
the pixels are stored in floating point, rather than integer format.
They form a 2-dimensional image indexed with coordinates i,j such that i
increases from left to right, starting at zero, and j increases from
bottom to top, also starting at zero. Image location i,j is specified
by the Nth pixel, counting from zero, where N is i+j*width.
The error INVALID_VALUE is generated if <width> or <height> is greater
than the maximum supported value. This value is queried with
GetConvolutionParameterivEXT, setting <target> to CONVOLUTION_2D_EXT and
<pname> to MAX_CONVOLUTION_WIDTH_EXT or MAX_CONVOLUTION_HEIGHT_EXT,
respectively.
A 1-dimensional convolution filter is defined using ConvolutionFilter1DEXT.
Its <target> parameter must be CONVOLUTION_1D_EXT. Its <internalformat>,
<format>, and <type> parameters have identical semantics and accept the
same values as do their 2D counterparts. <image> must point to a
1-dimensional image, however.
The 1-dimensional image is taken from memory and processed as if
ConvolutionFilter2DEXT were called with a height of 1, except that it is
scaled and biased by the two 1D vectors, rather than the 2D vectors.
(The 1D scale and bias vectors are specified using
ConvolutionParameterivEXT with <target> CONVOLUTION_1D_EXT and <pname>
CONVOLUTION_FILTER_SCALE_EXT or CONVOLUTION_FILTER_BIAS_EXT.) The
1-dimensional image is formed with coordinates i such that i increases
from left to right, starting at zero. Image location i is specified by
the ith pixel, counting from zero.
The error INVALID_VALUE is generated if <width> is greater than the
maximum supported value, which is queried using
GetConvolutionParameterivEXT, setting <target> to CONVOLUTION_1D_EXT
and <pname> to MAX_CONVOLUTION_WIDTH_EXT.
If EXT_copy_texture is supported, one and 2-dimensional filters can also
be defined using image data in the framebuffer. Rather than accepting
image data from memory, they copy image data from the color buffer
specified by the current ReadBuffer mode. CopyConvolutionFilter2DEXT
accepts image data from a <width> pixel wide by <height> pixel high
color buffer region whose lower-left pixel has window coordinates <x>,<y>.
If any pixels within this region are outside the window that is
associated with the GL context, the values obtained for those pixels
are undefined.
These pixel values are obtained from the framebuffer exactly as if
ReadPixels had been called with <format> set to RGBA, with processing
continuing through Conversion of RGBA values. At this point all pixel
component values are treated exactly as if ConvolutionFilter2DEXT had
been called, beginning with the scaling of the color components by
CONVOLUTION_FILTER_SCALE_SGI. Pixel ordering is such that lower X
screen coordinates correspond to lower i filter image coordinates, and
lower Y screen coordinates correspond to lower j filter image
coordinates. The semantics and accepted values of the <target> and
<internalformat> parameters are exactly equivalent to their
ConvolutionFilter2DEXT counterparts.
CopyConvolutionFilter1DEXT accepts image data from a <width> pixel wide
by 1 pixel high color buffer region whose left-most pixel has window
coordinates <x>,<y>. If any pixels within this region are outside the
window that is associated with the GL context, the values obtained for
those pixels are undefined.
The pixels are processed just as those of CopyConvolutionFilter2DEXT are,
and they define a filter image such that lower X window coordinates
correspond to lower i filter image coordinates. The semantics and
accepted values of the <target> and <internalformat> parameters are
exactly equivalent to their ConvolutionFilter1DEXT counterparts.
Special facilities are provided for the definition of 2-dimensional
separable filters -- filters whose image can be represented as the
product of two 1-dimensional images, rather than as full
2-dimensional images. A 2-dimensional convolution filter is specified
using SeparableFilter2DEXT. Its <target> parameter must be
SEPARABLE_2D_EXT. Its <internalformat> parameter specifies the formats
of two 1-dimensional images that will be retained; it must be one of
ALPHA, LUMINANCE, LUMINANCE_ALPHA, INTENSITY_EXT, RGB, or RGBA. <row>
and <column> point to two 1-dimensional images in memory. The <row>
image is <width> pixels wide, and is defined by <format> and <type>.
The <column> image is <height> pixels wide, and is also defined by
<format> and <type>.
The two images are extracted from memory and processed just as if
ConvolutionFilter1DEXT were called separately for each, with the resulting
retained images replacing the current 2D separable filter images, except
that each image is scaled and biased using the 2D separable scale and bias
vectors. (These vectors are specified using ConvolutionParameterivEXT with
<target> SEPARABLE_2D_EXT and <pname> CONVOLUTION_FILTER_SCALE_EXT or
CONVOLUTION_FILTER_BIAS_EXT.)
The operations of the convolution filters are added to the GL
Specification in section 3.6.3, "Rasterization of Pixel Rectangles,
immediately following the subsection "Index Lookup", and immediately
prior to the operations described by EXT_histogram. Filters are
enabled and disabled by calling Enable and Disable with filter name
passed as the <cap> parameter. Convolution is performed only for RGBA
groups, though these groups may have been specified as color indexes
and converted to RGBA by index table lookup.
If CONVOLUTION_1D_EXT is enabled, the 1-dimensional convolution filter
is applied only to the image passed to TexImage1D, and to 1-dimensional
textures queried by GetTexImage. If CONVOLUTION_2D_EXT is enabled, the
2-dimensional convolution filter is applied only to the 2D images passed
to DrawPixels, CopyPixels, ReadPixels, TexImage2D, TexSubImage2DEXT,
CopyTexImage2DEXT, CopyTexSubImage2DEXT, and GetTexImage, and to
2-dimensional images queried by GetTexImage. If SEPARABLE_2D_EXT is
enabled, and CONVOLUTION_2D_EXT is disabled, the separable 2-dimensional
convolution filter is applied only to these same images.
The convolution operation is a sum of products of source image pixels
and convolution filter pixels. Source image pixels always have four
components: red, green, blue, and alpha, denoted in the equations below
as Rs, Gs, Bs, and As. Filter pixels may be stored in one of five
formats, with 1, 2, 3, or 4 components. These components are denoted
as Rf, Gf, Bf, Af, Lf, and If in the equations below. The result of the
convolution operation is the 4-tuple R,G,B,A. Depending on the internal
format of the filter, individual color components of each source image
pixel are convolved with one filter component, or are passed unmodified.
The rules for this are:
Filter format
-------------
ALPHA R = Rs G = Gs B = Bs A = convolve(As,Af)
LUMINANCE R = convolve(Rs,Lf) G = convolve(Gs,Lf) B = convolve(Bs,Lf) A = As
LUMINANCE_ALPHA R = convolve(Rs,Lf) G = convolve(Gs,Lf) B = convolve(Bs,Lf) A = convolve(As,Af)
INTENSITY R = convolve(Rs,If) G = convolve(Gs,If) B = convolve(Bs,If) A = convolve(As,If)
RGB R = convolve(Rs,Rf) G = convolve(Gs,Gf) B = convolve(Bs,Bf) A = As
RGBA R = convolve(Rs,Rf) G = convolve(Gs,Gf) B = convolve(Bs,Bf) A = convolve(As,Af)
The convolution operation is defined differently for each of the three
convolution filters. In the following equations the
SUM{}{}equation
notation indicate the sum of the equation evaluated for all combinations
of conditions indicated within the sets of curly brackets. The
variables Wf and Hf refer to the dimensions of the convolution filter.
The variables Ws and Hs refer to the dimensions of the source pixel
image. The pixel indexing nomenclature is decribed in the Pixel
Organization section, above.
The convolution equations are:
1-dimensional filter:
C[i] = SUM{n = 0 through Wf-1}
Cs[i+n] * Cf[n]
2-dimensional filter:
C[i,j] = SUM{n = 0 through Wf-1}
{m = 0 through Hf-1}
Cs[i+n,j+m] * Cf[n,m]
2-dimensional separable filter:
C[i,j] = SUM{n = 0 through Wf-1}
{m = 0 through Hf-1}
Cs[i+n,j+m] * Crow[n] * Ccolumn[m]
If Wf of a 1-dimensional filter is zero, then C[i] is always set to
zero. Likewise, if either Wf or Hf of a 2-dimensional filter is zero,
then C[i,j] is always set to zero.
The convolution border mode for a specific convolution filter is
specified using ConvolutionParameteriEXT with the <target> parameter
set to the name of the filter, the <pname> parameter set to
CONVOLUTION_BORDER_MODE_EXT, and <param> set to REDUCE_EXT. (This
extension defines only a single border mode.) The width and height of
source images convolved with border mode REDUCE_EXT are reduced by
Wf-1 and Hf-1, respectively. If this reduction would generate a
resulting image with zero or negative width and/or height, the output
is simply null, with no error generated. The coordinates of the image
that results from a convolution with border mode REDUCE_EXT are zero
through Ws-Wf in width, and zero through Hs-Hf in height. In
cases where errors can result from the specification of invalid image
dimensions, it is these resulting dimensions that are tested, not the
dimensions of the source image. (A specific example is TexImage1D and
TexImage2D, which specify constraints for image dimensions. Even if
TexImage1D or TexImage2D is called with a null pixel pointer, the
dimensions of the resulting texture image are those that would result
from the convolution of the specified image.)
If a convolution operation is performed, the resulting image is scaled
and biased by parameters specified using the PixelTransfer command.
These operations are:
red = red * POST_CONVOLUTION_RED_SCALE_EXT
+ POST_CONVOLUTION_RED_BIAS_EXT
green = green * POST_CONVOLUTION_GREEN_SCALE_EXT
+ POST_CONVOLUTION_GREEN_BIAS_EXT
blue = blue * POST_CONVOLUTION_BLUE_SCALE_EXT
+ POST_CONVOLUTION_BLUE_BIAS_EXT
alpha = alpha * POST_CONVOLUTION_ALPHA_SCALE_EXT
+ POST_CONVOLUTION_ALPHA_BIAS_EXT
If no convolution operation is performed, the scale and bias are not
performed either.
Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
and the Framebuffer)
The operation of convolution during pixel copy and query operations is
identical to the operation during pixel drawing and texture image
definition.
Additions to Chapter 5 of the 1.0 Specification (Special Functions)
Commands GetConvolutionFilterEXT, GetSeparableFilterEXT,
GetConvolutionParameterivEXT, and GetConvolutionParameterfvEXT are not
included in display lists. They are always executed immediately.
Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
Integer and floating point query functions GetConvolutionParameterivEXT
and GetConvolutionParameterfvEXT are provided. <target> must be
CONVOLUTION_1D_EXT, CONVOLUTION_2D_EXT, or SEPARABLE_2D_EXT. <pname>
is one of CONVOLUTION_FORMAT_EXT, CONVOLUTION_WIDTH_EXT,
CONVOLUTION_HEIGHT_EXT, MAX_CONVOLUTION_WIDTH_EXT, or
MAX_CONVOLUTION_HEIGHT_EXT. The value of the specified parameter is
returned in <params>.
The current contents of a convolution filter image are queried using
GetConvolutionFilterEXT. <target> must be CONVOLUTION_1D_EXT or
CONVOLUTION_2D_EXT. <format> must be one of RED, GREEN, BLUE, ALPHA, RGB,
RGBA, ABGR_EXT, LUMINANCE, or LUMINANCE_ALPHA. <type> must be
UNSIGNED_BYTE, BYTE, UNSIGNED_SHORT, SHORT, UNSIGNED_INT, INT, or FLOAT.
The 1-dimensional or 2-dimensional image is returned to <image>. No pixel
transfer operations are performed on this image, but pixel storage modes
that are applicable to ReadPixels are performed. Color components are
converted from the internal floating point representation to <type>
according to table 2.4. Prior to the conversion, if <type> is one of
UNSIGNED_BYTE, UNSIGNED_SHORT, or UNSIGNED_INT, the color components are
clamped to 0..1, if <type> is one of BYTE, SHORT, or INT, the components are
clamped to -1..1. No clamping is performed if <type> is FLOAT. Color
components that are requested in the specified <format>, but which are not
included in the internal format of the filter image, are returned as zero.
The assignments of internal color components to the components requested by
<format> are
internal component resulting component
------------------ -------------------
red red
green green
blue blue
alpha alpha
luminance red
intensity red
The current contents of a separable filter image are queried using
GetSeparableFilterEXT. <target> must be SEPARABLE_2D_EXT. <format>
and <type> accept the same values as do the corresponding parameters
of GetConvolutionFilterEXT. The row and column images are returned to
<row> and <column> respectively. No change is made to any location
related to <span>. Pixel processing and component mapping are
identical to those of GetConvolutionFilterEXT.
Additions to the GLX Specification
None
GLX Protocol
Thirteen new GL commands are added.
The following six rendering commands are sent to the server as part of
a glXRender request:
CopyConvolutionFilter1DEXT
2 24 rendering command length
2 4107 rendering command opcode
4 ENUM target
4 ENUM internalformat
4 INT32 x
4 INT32 y
4 INT32 width
CopyConvolutionFilter2DEXT
2 28 rendering command length
2 4108 rendering command opcode
4 ENUM target
4 ENUM internalformat
4 INT32 x
4 INT32 y
4 INT32 width
4 INT32 height
ConvolutionParameteriEXT
2 16 rendering command length
2 4105 rendering command opcode
4 ENUM target
4 ENUM pname
0x8013 CONVOLUTION_BORDER_MODE_EXT
4 INT32 param
ConvolutionParameterivEXT
2 12+4*n rendering command length
2 4106 rendering command opcode
4 ENUM target
4 ENUM pname
0x8013 n=1 CONVOLUTION_BORDER_MODE_EXT
0x8014 n=4 CONVOLUTION_FILTER_SCALE_EXT
0x8015 n=4 CONVOLUTION_FILTER_BIAS_EXT
0x8017 n=1 CONVOLUTION_FORMAT_EXT
0x8018 n=1 CONVOLUTION_WIDTH_EXT
0x8019 n=1 CONVOLUTION_HEIGHT_EXT
0x801A n=1 MAX_CONVOLUTION_WIDTH_EXT
0x801B n=1 MAX_CONVOLUTION_HEIGHT_EXT
4*n LISTofINT32 params
ConvolutionParameterfEXT
2 16 rendering command length
2 4103 rendering command opcode
4 ENUM target
4 ENUM pname
0x8013 CONVOLUTION_BORDER_MODE_EXT
4 FLOAT32 param
ConvolutionParameterfvEXT
2 12+4*n rendering command length
2 4104 rendering command opcode
4 ENUM target
4 ENUM pname
0x8013 n=1 CONVOLUTION_BORDER_MODE_EXT
0x8014 n=4 CONVOLUTION_FILTER_SCALE_EXT
0x8015 n=4 CONVOLUTION_FILTER_BIAS_EXT
0x8017 n=1 CONVOLUTION_FORMAT_EXT
0x8018 n=1 CONVOLUTION_WIDTH_EXT
0x8019 n=1 CONVOLUTION_HEIGHT_EXT
0x801A n=1 MAX_CONVOLUTION_WIDTH_EXT
0x801B n=1 MAX_CONVOLUTION_HEIGHT_EXT
4*n LISTofFLOAT32 params
The following three rendering commands contain pixel data and are thus
sent to the server as part of a glXRender request or as part of a
glXRenderLarge request:
ConvolutionFilter1DEXT
2 48+n+p rendering command length
2 4101 rendering command opcode
1 BOOL swap_bytes
1 BOOL lsb_first
2 unused
4 CARD32 row_length
4 CARD32 skip_rows
4 CARD32 skip_pixels
4 CARD32 alignment
4 ENUM target
4 ENUM internalformat
4 INT32 width
4 INT32 height
4 ENUM format
4 ENUM type
n LISTofBYTE pixels
p unused, p=pad(n)
If the command is encoded in a glXRenderLarge request, the
command opcode and command length fields above are expanded to
4 bytes each:
4 52+n+p rendering command length
4 4101 rendering command opcode
If <width> < 0, <format> is invalid or <type> is invalid, then the
command is erroneous and n=0. The structure of <pixels> is described
in Appendix A of the GLX Protocol Specification, "Pixel Data", using
the parameters <swap_bytes>, <lsb_first>, <row_length>, <skip_rows>,
<skip_pixels>, <alignment>, <width>, <format>, and <type> as given
in the request, and a height of 1.
ConvolutionFilter2DEXT
2 48+n+p rendering command length
2 4102 rendering command opcode
1 BOOL swap_bytes
1 BOOL lsb_first
2 unused
4 CARD32 row_length
4 CARD32 skip_rows
4 CARD32 skip_pixels
4 CARD32 alignment
4 ENUM target
4 ENUM internalformat
4 INT32 width
4 INT32 height
4 ENUM format
4 ENUM type
n LISTofBYTE pixels
p unused, p=pad(n)
If the command is encoded in a glXRenderLarge request, the
command opcode and command length fields above are expanded to
4 bytes each:
4 52+n+p rendering command length
4 4102 rendering command opcode
If <width> < 0, <height> < 0, <format> is invalid or <type> is
invalid, then the command is erroneous and n=0. The structure of
<pixels> is described in Appendix A of the GLX Protocol
Specification, "Pixel Data", using the parameters <swap_bytes>,
<lsb_first>, <row_length>, <skip_rows>, <skip_pixels>, <alignment>,
<width>, <height>, <format>, and <type> as given in the request.
SeparableFilter2DEXT
2 48+n1+p1+n2+p2 rendering command length
2 4109 rendering command opcode
1 BOOL swap_bytes
1 BOOL lsb_first
2 unused
4 CARD32 row_length
4 CARD32 skip_rows
4 CARD32 skip_pixels
4 CARD32 alignment
4 ENUM target
4 ENUM internalformat
4 INT32 width
4 INT32 height
4 ENUM format
4 ENUM type
n1 LISTofBYTE row
p1 unused, p=pad(n)
n2 LISTofBYTE column
p2 unused, p=pad(n)
If the command is encoded in a glXRenderLarge request, the
command opcode and command length fields above are expanded
to 4 bytes each:
4 52+n+p rendering command length
4 4109 rendering command opcode
If <width> < 0, <height> < 0, <format> is invalid or <type> is
invalid, then the command is erroneous and n=0. The structure of
<row> is described in Appendix A of the GLX Protocol Specification,
"Pixel Data", using the parameters <swap_bytes>, <lsb_first>,
<row_length>, <skip_rows>, <skip_pixels>, <alignment>, <width>,
<format>, and <type> as given in the request, and and a height of 1.
The structure of <column> is the same (it is also a one-dimensional
image) except that it is <height> pixels wide, instead of <width>
pixels wide.
The remaining commands are non-rendering commands. These commands are
sent separately (i.e., not as part of a glXRender or glXRenderLarge
request), using the glXVendorPrivateWithReply request:
GetConvolutionParameterivEXT
1 CARD8 opcode (X assigned)
1 17 GLX opcode (glXVendorPrivateWithReply)
2 5 request length
4 3 vendor specific opcode
4 GLX_CONTEXT_TAG context tag
4 ENUM target
4 ENUM pname
=>
1 1 reply
1 unused
2 CARD16 sequence number
4 m reply length, m = (n==1 ? 0 : n)
4 unused
4 CARD32 n
if (n=1) this follows:
4 INT32 params
12 unused
otherwise this follows:
16 unused
n*4 LISTofINT32 params
Note that n may be zero, indicating that a GL error occurred.
GetConvolutionParameterfvEXT
1 CARD8 opcode (X assigned)
1 17 GLX opcode (glXVendorPrivateWithReply)
2 5 request length
4 2 vendor specific opcode
4 GLX_CONTEXT_TAG context tag
4 ENUM target
4 ENUM pname
=>
1 1 reply
1 unused
2 CARD16 sequence number
4 m reply length, m = (n==1 ? 0 : n)
4 unused
4 CARD32 n
if (n=1) this follows:
4 FLOAT32 params
12 unused
otherwise this follows:
16 unused
n*4 LISTofFLOAT32 params
Note that n may be zero, indicating that a GL error occurred.
GetConvolutionFilterEXT
1 CARD8 opcode (X assigned)
1 17 GLX opcode (glXVendorPrivateWithReply)
2 7 request length
4 1 vendor specific opcode
4 GLX_CONTEXT_TAG context tag
4 ENUM target
4 ENUM format
4 ENUM type
1 BOOL swap_bytes
3 unused
=>
1 1 reply
1 unused
2 CARD16 sequence number
4 n reply length
8 unused
4 INT32 width
4 INT32 height
8 unused
4*n LISTofBYTE pixels
Note that n may be zero, indicating that a GL error occurred.
If <format> or <type> is invalid then the command is erroneous and
n=0. The structure of <pixels> is described in Appendix A of the GLX
Protocol Specification, "Pixel Data", using the parameters
<swap_bytes>, <format>, and <type>. No extra padding is needed after
<pixels> because the image format already pads to 32 bits.
GetSeparableFilterEXT
1 CARD8 opcode (X assigned)
1 17 GLX opcode (glXVendorPrivateWithReply)
2 7 request length
4 4 vendor specific opcode
4 GLX_CONTEXT_TAG context tag
4 ENUM target
4 ENUM format
4 ENUM type
1 BOOL swap_bytes
3 unused
=>
1 1 reply
1 unused
2 CARD16 sequence number
4 n reply length
8 unused
4 INT32 width
4 INT32 height
8 unused
4*n LISTofBYTE row followed by column
Note that n may be zero, indicating that a GL error occurred.
If <format> or <type> is invalid then the command is erroneous and
n=0. The structure of <pixels> is described in Appendix A of the GLX
Protocol Specification, "Pixel Data", using the parameters
<swap_bytes>, <format>, and <type>. No extra padding is needed after
<pixels> because the image format already pads to 32 bits.
Dependencies on EXT_abgr
If EXT_abgr is supported, the <format> parameters of
ConvolutionFilter1DEXT, ConvolutionFilter2DEXT, GetConvolutionFilterEXT,
SeparableFilter2DEXT, and GetSeparableFilterEXT accept ABGR_EXT.
Otherwise they do not.
Dependencies on EXT_texture
EXT_texture is required. This extension builds on the notion of
internal image format, which is defined by EXT_texture.
Dependencies on EXT_copy_texture
If EXT_copy_texture is not supported, commands CopyConvolutionFilter1DEXT
and CopyConvolutionFilter2DEXT are not supported.
Errors
INVALID_ENUM is generated if ConvolutionFilter1DEXT parameter <target>
is not CONVOLUTION_1D_EXT.
INVALID_ENUM is generated if ConvolutionFilter2DEXT parameter <target>
is not CONVOLUTION_2D_EXT.
INVALID_ENUM is generated if CopyConvolutionFilter1DEXT parameter
<target> is not CONVOLUTION_1D_EXT.
INVALID_ENUM is generated if CopyConvolutionFilter2DEXT parameter
<target> is not CONVOLUTION_2D_EXT.
INVALID_ENUM is generated if SeparableFilter2DEXT parameter <target>
is not SEPARABLE_2D_EXT.
INVALID_ENUM is generated if GetConvolutionFilterEXT parameter <target>
is not CONVOLUTION_1D_EXT or CONVOLUTION_2D_EXT.
INVALID_ENUM is generated if GetSeparableFilterEXT parameter <target>
is not SEPARABLE_2D_EXT.
INVALID_ENUM is generated if ConvolutionParameteriEXT,
ConvolutionParameterfEXT, ConvolutionParameterivEXT,
ConvolutionParameterfvEXT, GetConvolutionParameterivEXT, or
GetConvolutionParameterfvEXT parameter <target> is not
CONVOLUTION_1D_EXT, CONVOLUTION_2D_EXT, or SEPARABLE_2D_EXT.
INVALID_ENUM is generated if ConvolutionFilter1DEXT,
ConvolutionFilter2DEXT, CopyConvolutionFilter1DEXT,
CopyConvolutionFilter2DEXT, or SeparableFilter2DEXT parameter
<internalformat> is not ALPHA, LUMINANCE, LUMINANCE_ALPHA, INTENSITY,
RGB, or RGBA.
INVALID_VALUE is generated if ConvolutionFilter1DEXT parameter <width>
is less than zero, or greater than MAX_CONVOLUTION_WIDTH_EXT as queried
using GetConvolutionParameterivEXT with <target> CONVOLUTION_1D_EXT.
INVALID_VALUE is generated if ConvolutionFilter2DEXT parameter <width>
is less than zero, or greater than MAX_CONVOLUTION_WIDTH_EXT as queried
using GetConvolutionParameterivEXT with <target> CONVOLUTION_2D_EXT.
INVALID_VALUE is generated if CopyConvolutionFilter1DEXT parameter
<width> is less than zero, or greater than MAX_CONVOLUTION_WIDTH_EXT
as queried using GetConvolutionParameterivEXT with <target>
CONVOLUTION_1D_EXT.
INVALID_VALUE is generated if CopyConvolutionFilter2DEXT parameter
<width> is less than zero, or greater than MAX_CONVOLUTION_WIDTH_EXT
as queried using GetConvolutionParameterivEXT with <target>
CONVOLUTION_2D_EXT.
INVALID_VALUE is generated if SeparableFilter2DEXT parameter <width>
is less than zero, or greater than MAX_CONVOLUTION_WIDTH_EXT as queried
using GetConvolutionParameterivEXT with <target> SEPARABLE_2D_EXT.
INVALID_VALUE is generated if ConvolutionFilter2DEXT parameter <height>
is less than zero, or greater than MAX_CONVOLUTION_HEIGHT_EXT as queried
using GetConvolutionParameterivEXT with <target> CONVOLUTION_2D_EXT.
INVALID_VALUE is generated if CopyConvolutionFilter2DEXT parameter
<height> is less than zero, or greater than MAX_CONVOLUTION_HEIGHT_EXT
as queried using GetConvolutionParameterivEXT with <target>
CONVOLUTION_2D_EXT.
INVALID_VALUE is generated if SeparableFilter2DEXT parameter <height>
is less than zero, or greater than MAX_CONVOLUTION_HEIGHT_EXT as queried
using GetConvolutionParameterivEXT with <target> SEPARABLE_2D_EXT.
INVALID_ENUM is generated if ConvolutionFilter1DEXT,
ConvolutionFilter2DEXT, GetConvolutionFilterEXT, SeparableFilter2DEXT,
or GetSeparableFilterEXT parameter <format> is not RED, GREEN, BLUE,
ALPHA, RGB, RGBA, ABGR_EXT, LUMINANCE, or LUMINANCE_ALPHA.
INVALID_ENUM is generated if ConvolutionFilter1DEXT,
ConvolutionFilter2DEXT, GetConvolutionFilterEXT, SeparableFilter2DEXT,
or GetSeparableFilterEXT parameter <type> is not UNSIGNED_BYTE, BYTE,
UNSIGNED_SHORT, SHORT, UNSIGNED_INT, INT, or FLOAT.
INVALID_ENUM is generated if ConvolutionParameterivEXT or
ConvolutionParameterfvEXT parameter <pname> is not
CONVOLUTION_FILTER_SCALE_EXT, CONVOLUTION_FILTER_BIAS_EXT,
or CONVOLUTION_BORDER_MODE_EXT.
INVALID_ENUM is generated if ConvolutionParameteriEXT or
ConvolutionParameterfEXT parameter <pname> is not
CONVOLUTION_BORDER_MODE_EXT.
INVALID_ENUM is generated if ConvolutionParameteriEXT,
ConvolutionParameterfEXT, ConvolutionParameterivEXT, or
ConvolutionParameterfvEXT parameter <pname> is
CONVOLUTION_BORDER_MODE_EXT and parameter <params> is not REDUCE_EXT.
INVALID_ENUM is generated if GetConvolutionParameterivEXT or
GetConvolutionParameterfvEXT parameter <pname> is not
CONVOLUTION_FILTER_SCALE_EXT, CONVOLUTION_FILTER_BIAS_EXT,
CONVOLUTION_BORDER_MODE_EXT, CONVOLUTION_FORMAT_EXT,
CONVOLUTION_WIDTH_EXT, CONVOLUTION_HEIGHT_EXT, MAX_CONVOLUTION_WIDTH_EXT
or MAX_CONVOLUTION_HEIGHT_EXT.
INVALID_ENUM is generated if GetConvolutionParameterivEXT or
GetConvolutionParameterfvEXT parameter <target> is CONVOLUTION_1D_EXT
and <pname> is CONVOLUTION_HEIGHT_EXT or MAX_CONVOLUTION_HEIGHT_EXT.
INVALID_OPERATION is generated if ConvolutionFilter1DEXT,
ConvolutionFilter2DEXT, CopyConvolutionFilter1DEXT,
CopyConvolutionFilter2DEXT, GetConvolutionFilterEXT, SeparableFilter2DEXT,
GetSeparableFilterEXT, ConvolutionParameteriEXT,
ConvolutionParameterivEXT, ConvolutionParameterfEXT,
ConvolutionParameterfvEXT, GetConvolutionParameterivEXT, or
GetConvolutionParameterfvEXT is executed between execution of Begin and
the corresponding execution of End.
New State
Get Value Get Command Type Initial Value Attribute
--------- ----------- ---- ------------- ---------
CONVOLUTION_1D_EXT IsEnabled B False pixel/enable
CONVOLUTION_2D_EXT IsEnabled B False pixel/enable
SEPARABLE_2D_EXT IsEnabled B False pixel/enable
CONVOLUTION_FILTER_SCALE_EXT GetConvolutionParameterivEXT 3 x R4 (1,1,1,1) pixel
CONVOLUTION_FILTER_BIAS_EXT GetConvolutionParameterivEXT 3 x R4 (0,0,0,0) pixel
CONVOLUTION_BORDER_MODE_EXT GetConvolutionParameterivEXT 3 x Z1 REDUCE_EXT pixel
CONVOLUTION_xD (x is 1 or 2) GetConvolutionFilterEXT 2 x I empty -
SEPARABLE_2D GetSeparableFilterEXT 1 x I empty -
CONVOLUTION_FORMAT_EXT GetConvolutionParameterivEXT 3 x Z8 RGBA -
CONVOLUTION_WIDTH_EXT GetConvolutionParameterivEXT 3 x Z+ 0 -
CONVOLUTION_HEIGHT_EXT GetConvolutionParameterivEXT 2 x Z+ 0 -
POST_CONVOLUTION_RED_SCALE_EXT GetFloatv R 1 pixel
POST_CONVOLUTION_GREEN_SCALE_EXT GetFloatv R 1 pixel
POST_CONVOLUTION_BLUE_SCALE_EXT GetFloatv R 1 pixel
POST_CONVOLUTION_ALPHA_SCALE_EXT GetFloatv R 1 pixel
POST_CONVOLUTION_RED_BIAS_EXT GetFloatv R 0 pixel
POST_CONVOLUTION_GREEN_BIAS_EXT GetFloatv R 0 pixel
POST_CONVOLUTION_BLUE_BIAS_EXT GetFloatv R 0 pixel
POST_CONVOLUTION_ALPHA_BIAS_EXT GetFloatv R 0 pixel
New Implementation Dependent State
Get Value Get Command Type Minimum Value
--------- ----------- ---- -------------
MAX_CONVOLUTION_WIDTH_EXT GetConvolutionParameterivEXT 3 x Z+ 3
MAX_CONVOLUTION_HEIGHT_EXT GetConvolutionParameterivEXT 2 x Z+ 3
Revision History
Version 1.32, 2002/06/27 - fixed targets for GetConvolutionFilter and
GetSeparableFilter.
Implementation Support
List of OpenGL implementations supporting the GL_EXT_convolution extension
Original File
Original text file for the GL_EXT_convolution extension
Page generated on Sun Nov 20 18:37:27 2005