| Name | |
| 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. | |
| New Procedures and Functions | |
| 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); | |
| New Tokens | |
| 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. |