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.