| XXX - Not complete. |
| |
| Name |
| |
| SGIX_mpeg1 |
| |
| Name Strings |
| |
| GL_SGIX_mpeg1 |
| |
| Version |
| |
| $Date: 1997/06/07 01:23:57 $ $Revision: 1.10 $ |
| |
| Number |
| |
| ??? |
| |
| Dependencies |
| |
| SGIX_image_compression is required. |
| |
| Overview |
| |
| This extension provides support for MPEG1-compressed images. |
| MPEG1 compression is considered a pixel storage mode. Predictor |
| frames are supported and are managed as objects in a manner |
| similar to texture objects. |
| |
| MPEG images may be uncompressed when transferred from client |
| memory during the unpacking phase of pixel operations. Images may |
| be compressed when transferred to client memory during the packing |
| phase of pixel operations. |
| |
| MPEG predictor frames are stored as two-dimensional RGB images of |
| unspecified type. The predictors are referred to by numerical |
| names. The allocation and deallocation of memory to store the |
| predictor images takes place through the GL routines |
| AllocMPEGPredictorsSGIX and DeleteMPEGPredictorsSGIX which are |
| defined by this extension. |
| |
| Support of this extension does not imply conformance to the MPEG1 |
| standard (ISO 11172), although the following guarantees are made: |
| |
| - During decode, the picture_coding_type piece of the picture |
| coding header is extracted and interpreted correctly. The |
| treatment of the resulting value is discussed below. |
| |
| Issues |
| |
| * Some systems may not support predictors. Should we split the |
| extension into two: one for intraframe only and a second |
| which allows predictors? |
| |
| A: Predictors are pretty fundamental to MPEG, so we will |
| leave them in the spec. Implementations that do not |
| support them can do a partial implementation and not |
| advertise the extension. |
| |
| * Should we introduce the concept of "residency" for predictors |
| as we did for texture objects? |
| |
| A: No. Caching of predictors would be far less useful than |
| caching textures. If we find an application which could |
| use this capability, we'll add another extension. |
| |
| * When drawing from a predictor object, we always take the |
| entire image. Should we allow a way to take a subregion of |
| the predictor? A similar question arises for drawing to a |
| predictor object. |
| |
| A: Supporting this functionality could be difficult to |
| impossible for systems using specialized compression and |
| decompression hardware. Therefore, we will leave it for |
| another extension. |
| |
| * Currently, we require that the user allocate a predictor |
| before using any predictors. That is, there is no default |
| predictor created at context init. Is this the correct |
| behavior? In the texture object extension, there is a |
| default texture which is used. |
| |
| A: Since predictors are used as sources, destinations, and |
| forward and backward predictors, choosing the correct |
| number of default predictors and bindings for them which |
| would be at all useful would be difficult if not |
| impossible. Textures are a simpler case since they are |
| basically only used for one thing. Additionally, having |
| default predictors would require implementations to |
| reserve space for the predictors at context init (which |
| would waste space since the vast majority of applications |
| will not use MPEG compression) or to allocate the space |
| during a pixel command (which could cause the pixel |
| command to generate an out-of-memory error). Therefore, |
| we will stick with the current approach. |
| |
| * Should we add "error recovery" bind points? These predictors |
| could be used by the implementation to replace regions of a |
| decoded image which were determined to be bogus because of |
| image data errors. Frank Bernard says this is a fairly |
| common technique. |
| |
| A: We'll leave this for another extension. |
| |
| * Do we need a proxy mechanism to determine the amount of |
| predictor space available? |
| |
| * Do we need a more straightforward way to copy predictors from |
| the frame buffer? Something like CopyMPEGPredictorSGIX? |
| |
| * We guarantee that the picture_structure and picture_type |
| fields are interpreted and set correctly. We do this so that |
| we can make guarantees about which predictors will be used |
| and updated. Should we make this less restrictive? |
| |
| * Drawing from predictors is still a little awkward. We |
| require the user to draw a zero-size MPEG-compressed image. |
| The user needs to have a legal picture header. Should we add |
| some more direct way to accomplish this step? |
| |
| Reasoning |
| |
| * We have used a scheme for predictor management which is |
| slightly different from the scheme for texture objects. |
| Specifically, we have an allocation routine |
| (AllocMPEGPredictorsSGIX), but textures are allocated on |
| download. The reason for this is that it removes the need to |
| allocate memory during commands like DrawPixels and |
| ReadPixels. Failure of either of these commands due to an |
| out-of-memory error would be highly counterintuitive. |
| |
| * To simplify state management and queries, we perform |
| upsampling prior to motion compensation and predictor |
| storage. |
| |
| * We manage quantization tables using a syntax similar to that |
| of pixel maps instead of managing them as pixel data since |
| they update the pack and unpack state. Using and |
| simultaneously updating the state would be awkward. Also, |
| the values are always one unscaled component, meaning that |
| the added flexibility of a user-specified type and format |
| would be virtually useless. |
| |
| New Procedures and Functions |
| |
| void GenMPEGPredictorsSGIX(sizei n, |
| uint *predictors); |
| |
| void AllocMPEGPredictorsSGIX(sizei width, |
| sizei height, |
| sizei n, |
| uint *predictors); |
| |
| void DeleteMPEGPredictorsSGIX(sizei n, |
| uint *predictors); |
| |
| boolean IsMPEGPredictorSGIX(uint predictor); |
| |
| void MPEGPredictorSGIX(enum target, |
| enum format, |
| enum type, |
| void *pixels); |
| |
| void GetMPEGPredictorSGIX(enum target, |
| enum format, |
| enum type, |
| void *pixels); |
| |
| void SwapMPEGPredictorsSGIX(enum target0, |
| enum target1); |
| |
| void GetMPEGParameterfvSGIX(enum target, |
| enum pname, |
| float *params); |
| |
| void GetMPEGParameterivSGIX(enum target, |
| enum pname, |
| int *params); |
| |
| void MPEGQuantTableubv(enum target, |
| ubyte *values); |
| |
| void GetMPEGQuantTableubv(enum target, |
| ubyte *values); |
| |
| New Tokens |
| |
| Accepted by the <target> parameter of GetMPEGParameterfvSGIX and |
| GetMPEGParameterivSGIX; by the <target0> and <target1> parameters |
| of SwapMPEGPredictorsSGIX; by the <param> parameter of PixelStoref |
| and PixelStorei; and by the <pname> parameter of GetBooleanv, |
| GetIntegerv, GetFloatv, and GetDoublev: |
| |
| PACK_MPEG_PREDICTOR_FWD_SGIX ???? |
| PACK_MPEG_PREDICTOR_BACK_SGIX ???? |
| |
| UNPACK_MPEG_PREDICTOR_FWD_SGIX ???? |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX ???? |
| |
| Accepted by the <pname> parameter of PixelStoref, PixelStorei, |
| GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev: |
| |
| PACK_MPEG_PREDICTOR_STORE_SGIX ???? |
| PACK_MPEG_PREDICTOR_STORE_SINK_SGIX ???? |
| PACK_MPEG_PREDICTOR_READ_SGIX ???? |
| UNPACK_MPEG_PREDICTOR_STORE_SGIX ???? |
| UNPACK_MPEG_PREDICTOR_STORE_SINK_SGIX ???? |
| UNPACK_MPEG_PREDICTOR_READ_SGIX ???? |
| |
| PACK_MPEG_PICTURE_TYPE_SGIX ???? |
| PACK_MPEG_ADAPT_QUANT_SCALE ???? |
| |
| Accepted by the <param> parameter of PixelStoref and PixelStorei: |
| |
| MPEG1_SGIX ???? |
| MPEG_IFRAME_SGIX ???? |
| MPEG_PFRAME_SGIX ???? |
| MPEG_BFRAME_SGIX ???? |
| |
| Accepted by the <pname> parameter of GetMPEGParameterfvSGIX and |
| GetMPEGParameterivSGIX: |
| |
| MPEG_PREDICTOR_WIDTH_SGIX ???? |
| MPEG_PREDICTOR_HEIGHT_SGIX ???? |
| |
| Accepted by the <target> parameter of MPEGQuantTableubv and |
| GetMPEGQuantTableubv: |
| |
| PACK_MPEG_INTRA_QUANT ???? |
| PACK_MPEG_NON_INTRA_QUANT ???? |
| UNPACK_MPEG_INTRA_QUANT ???? |
| UNPACK_MPEG_NON_INTRA_QUANT ???? |
| |
| Additions to Chapter 2 of the 1.1 Specification (OpenGL Operation) |
| |
| None. |
| |
| Additions to Chapter 3 of the 1.1 Specification (Rasterization) |
| |
| The pixel storage modes are augmented to support MPEG compressed |
| images in memory. The following entries are added to Table 3.1: |
| |
| Parameter Name Type Initial Value Valid Range |
| -------------- ---- ------------- ----------- |
| UNPACK_MPEG_PREDICTOR_FWD_SGIX integer 0 [0, infinity] |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX integer 0 [0, infinity] |
| UNPACK_MPEG_PREDICTOR_STORE_SGIX Z3 NONE NONE, UNPACK_MPEG_PREDICTOR_FWD_SGIX, UNPACK_MPEG_PREDICTOR_BACK_SGIX |
| UNPACK_MPEG_PREDICTOR_STORE_SINK_SGIX boolean FALSE |
| UNPACK_MPEG_PREDICTOR_READ_SGIX Z3 NONE NONE, UNPACK_MPEG_PREDICTOR_FWD_SGIX, UNPACK_MPEG_PREDICTOR_BACK_SGIX |
| |
| Additionally, the value MPEG1_SGIX is added to the valid range of |
| PACK_COMPRESSION_TYPE_SGIX and UNPACK_COMPRESSION_TYPE_SGIX. |
| |
| The following should be added to the end of section 3.6.1 (Pixel |
| Storage Modes): |
| |
| In addition to PixelStoref and PixelStorei, several commands |
| control the unpacking of MPEG-compressed images. The command: |
| |
| MPEGQuantTableubv(enum target, ubyte *values); |
| |
| allows the specification of custom quantization tables for MPEG |
| decode. The following are legal values for the <target> |
| parameter: PACK_MPEG_INTRA_QUANT, PACK_MPEG_NON_INTRA_QUANT, |
| UNPACK_MPEG_INTRA_QUANT, and UNPACK_MPEG_NON_INTRA_QUANT. If the |
| value of <target> is not legal, the error INVALID_ENUM is |
| generated. <values> points to a 64-element array of values |
| representing the quantizer grid which will update the state |
| specified by <target>. The organization of the elements in the |
| grid is not specified by this extension. |
| |
| Several other commands are used to manage predictor objects for |
| MPEG compressed images. Predictor objects represent |
| two-dimensional images allocated by GL. The images are stored in |
| a YUV format. Each component is stored as a number of unspecified |
| precision. Predictor objects are referred to by unsigned integer |
| names. A predictor name is considered "in use" when an image |
| (including a zero-size image) is associated with it. The name |
| zero is reserved for the GL and is permanently associated with a |
| zero-size image. |
| |
| Predictor frame names are allocated using the command: |
| |
| void GenMPEGPredictorsSGIX( sizei n, uint *predictors ); |
| |
| The parameter <predictors> points to an array of <n> unsigned |
| integers. GenMPEGPredictorsSGIX places <n> predictor names in |
| <predictors>. Names are chosen in an unspecified manner, the only |
| conditions being that only names that were not in use immediately |
| prior to the call to GenMPEGPredictorsSGIX will be returned, zero |
| will not be returned, and each name returned will be unique. An |
| image with width and height equal to zero is associated with each |
| name returned. |
| |
| Images associated with MPEG predictor names are allocated using |
| the command: |
| |
| AllocMPEGPredictorsSGIX( sizei width, sizei height, |
| sizei n, uint *predictors ); |
| |
| This function associates an image of size <width> by <height> with |
| each of the <n> predictors whose names are in <predictors>. The |
| parameters <width> and <height> specify the size of images to be |
| associated with the predictor objects. If a name was previously |
| in use, the image previously associated with it is deleted, just |
| as though DeleteMPEGPredictorsSGIX (see below) had been called. |
| The name zero may not be included in the list of predictor objects |
| or the error INVALID_OPERATION results. After allocation, the |
| contents of the allocated images are undefined. |
| |
| Predictor frames are deleted by calling: |
| |
| DeleteMPEGPredictorsSGIX( sizei n, uint *predictors ); |
| |
| with <predictors> pointing to a list of <n> predictor names of |
| objects to be deleted. When an object is deleted, the memory |
| associated with its image is freed. After the object is deleted, |
| it has no image size or contents and its name is considered no |
| longer in use. If a predictor object which is currently bound is |
| deleted, the binding reverts to zero. DeleteMPEGPredictorsSGIX |
| ignores names which do not correspond to predictor objects. The |
| name zero is also silently ignored. |
| |
| Predictors are associated with bind points which define their |
| usage during pixel download and readback operations. The valid |
| bind points are: PACK_MPEG_PREDICTOR_FWD_SGIX, |
| PACK_MPEG_PREDICTOR_BACK_SGIX, PACK_MPEG_PREDICTOR_BACK_SGIX, and |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX. The use of each bind point is |
| described in detail in either section 3.6.3 (Rasterization of |
| Pixel Rectangles) or in the section of Chapter 4 entitled "Packing |
| of Compressed Images." To bind a predictor to a bind point, the |
| commands PixelStorei and PixelStoref are used. The parameter |
| <pname> gives the name of a bind point and the parameter <param> |
| gives the numerical name of a predictor object. If <param> is not |
| a predictor object, the error INVALID_VALUE is generated. |
| |
| The command |
| |
| MPEGPredictorSGIX(enum target, enum format, enum type, |
| void *pixels); |
| |
| is used to download images from client memory to the predictor |
| bound to the bind point <target>. If <target> is not the name of |
| a predictor bind point, the error INVALID_ENUM is generated. |
| <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. <pixels> points to a two-dimensional image stored as |
| specified by <format> and <type>. The width and height of the |
| image are assumed to be the same as the width and height of the |
| predictor bound to <target>. The image is extracted from memory |
| and processed just as if DrawPixels were called, stopping after |
| the Final Expansion to RGBA step. |
| |
| The command |
| |
| SwapMPEGPredictorsSGIX(enum target0, enum target1); |
| |
| is used to swap the predictor objects associated with two |
| predictor bind points. The predictor bound to <target0> is bound |
| to <target1> and the predictor bound to <target1> is bound to |
| <target0>. The error INVALID_ENUM is generated if <target0> or |
| <target1> is not the name of a predictor bind point. |
| |
| 3.6.3 Rasterization of Pixel Rectangles |
| |
| The following should be added to the "Unpacking of Compressed |
| Images" subsection of section 3.6.3 (Rasterization of Pixel |
| Rectangles) following the paragraph which begins "Once the byte |
| stream has been taken from host memory...": If |
| UNPACK_COMPRESSION_TYPE_SGIX is equal to MPEG1_SGIX, the byte |
| stream is assumed to represent an MPEG1 picture header followed by |
| picture data. MPEG1 images are classified as one of three frame |
| types: I-frame, P-frame, or B-frame. The frame type is determined |
| by the value of the picture_type field in the picture header. |
| This extraction and interpretation takes place as described in the |
| MPEG specification (ISO 11172). The initial steps of MPEG |
| decompression are the same for all frames, but later steps are |
| dependent upon the frame type. |
| |
| The size of the image represented by the byte stream is determined |
| by the width and height values as computed in the |
| SGIX_image_compression extension. Only image sizes for which the |
| width and height are multiples of 16 are valid. Specification of |
| an invalid size for the decompressed image will result in the |
| error INVALID_OPERATION. |
| |
| Entropy decoding, inverse quantization, and inverse discrete |
| cosine transform operations are applied to the image. This |
| extension does not specify the algorithm used, nor does it imply |
| conformance to the MPEG2 specification. |
| |
| The IDCT step produces three output images: Y, Cr, and Cb. The |
| images are upsampled as determined by the setting of |
| UNPACK_UPSAMPLE_SGIX. The upsampling is performed as described in |
| SGIX_image_compression. The output of the upsampling step is a |
| single width by height YCrCB image. The contents of the image and |
| how it is handled after the upsampling step is determined by the |
| type of MPEG frame. |
| |
| The frame conversion step is described below for each of the |
| types. For all frame types, the output of the conversion step is |
| a single YCrCb image of the same width and height as the output of |
| the upsampling step. |
| |
| If the image is an I-frame, no predictors are used to compute the |
| output image, but the quantizer table UNPACK_MPEG_INTRA_QUANT may |
| be used. The quantizer table contents may also be changed during |
| the decompression if the byte stream contains an embedded |
| quantization table. Any changes made are reflected in the GL state |
| and persist until the quantizer table is respecified through a |
| call to MPEGQuantTableubv or during decompression of another |
| I-frame. The exact algorithm used to compute the output image is |
| not specified in this extension. |
| |
| If the image is a P-frame, the image represents a predicted picture. |
| The output of the frame conversion step is determined by the |
| contents of the image and by the contents of the predictor object |
| bound to the UNPACK_MPEG_PREDICTOR_BACK_SGIX bind point. This |
| predictor must be the same size as the current image or the error |
| INVALID_OPERATION is generated and processing of the image |
| terminates. The quantizer table UNPACK_MPEG_NON_INTRA_QUANT may |
| be used and possibly changed during the decompression. |
| |
| If the image is a B-frame, the image represents a bidirectionally |
| predicted picture. The output of the frame conversion step is |
| determined by the contents of the image and by the contents of the |
| predictor objects bound to the UNPACK_MPEG_PREDICTOR_BACK_SGIX and |
| UNPACK_MPEG_PREDICTOR_FWD_SGIX bind points. The predictor objects |
| must be the same size as the current image or the error |
| INVALID_OPERATION is generated and processing of the image |
| terminates. The quantizer table UNPACK_MPEG_NON_INTRA_QUANT may |
| be used and possibly changed during the decompression. The |
| algorithm used to compute the output image is not specified in |
| this extension. |
| |
| After the frame conversion step, the YCrCb image may be used to |
| update the predictor bound to UNPACK_MPEG_PREDICTOR_FORWARD_SGIX |
| or UNPACK_MPEG_PREDICTOR_BACK_SGIX in the predictor update step |
| described here. The predictor to be updated is specified using |
| the parameter UNPACK_MPEG_PREDICTOR_STORE_SGIX. If this value is |
| NONE, the predictor update step is skipped. Otherwise, the YCrCb |
| image from the frame conversion step overwrites the current |
| contents of the predictor bound to the target which was |
| specified with UNPACK_MPEG_PREDICTOR_STORE_SGIX. The affected |
| predictor's size must be the same as that of the current image or |
| the error INVALID_OPERATION is generated. Also, a predictor may |
| not be updated if it is being used in a previous step of the |
| decompression process or the error INVALID_OPERATION is generated. |
| This means that the UNPACK_MPEG_PREDICTOR_STORE_SGIX may not be |
| set to UNPACK_MPEG_PREDICTOR_BACK_SGIX during the download of a P- |
| or B-frame and that UNPACK_MPEG_PREDICTOR_STORE_SGIX may not be |
| set to UNPACK_MPEG_PREDICTOR_FORWARD_SGIX during the download of a |
| B-frame. If an error is generated during the predictor update |
| step, processing terminates and the contents of the predictor are |
| left unchanged. |
| |
| If UNPACK_MPEG_PREDICTOR_STORE_SINK_SGIX is TRUE, the operation |
| terminates after the update step (even if no update was |
| performed). |
| |
| After the predictor update step, the YCrCb image from the frame |
| conversion step may be replaced by the predictor bound to |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX or UNPACK_MPEG_PREDICTOR_FWD_SGIX |
| as specified by UNPACK_MPEG_PREDICTOR_READ_SGIX. If We refer to |
| this step as the source replacement step. If |
| UNPACK_MPEG_PREDICTOR_READ_SGIX is equal to NONE, the image from |
| the conversion step is unchanged. If |
| UNPACK_MPEG_PREDICTOR_READ_SGIX is |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX, the image is replaced by the |
| predictor image bound to UNPACK_MPEG_PREDICTOR_BACK_SGIX. If |
| UNPACK_MPEG_PREDICTOR_READ_SGIX is |
| UNPACK_MPEG_PREDICTOR_FORWARD_SGIX, the image is replaced by the |
| predictor image bound to UNPACK_MPEG_PREDICTOR_FORWARD_SGIX. When |
| replacement occurs, the image passed to the next stage in the |
| unpacking process has the same size and contents as the specified |
| predictor. Therefore, a predictor may be downloaded from a bind |
| point by setting UNPACK_MPEG_PREDICTOR_READ_SGIX appropriately and |
| drawing a zero-size MPEG image. |
| |
| Predictors may not be used for replacement if they were written |
| during a previous step of the same operation. That is to say, |
| UNPACK_MPEG_PREDICTOR_READ_SGIX may not be set to the same value |
| as UNPACK_MPEG_PREDICTOR_STORE_SGIX unless that value is NONE. |
| Also, UNPACK_MPEG_PREDICTOR_READ_SGIX and |
| UNPACK_MPEG_PREDICTOR_STORE_SGIX may not specify bind points to |
| which the same predictor is bound, even if the bind points are |
| different. If either error condition occurs, the error |
| INVALID_OPERATION is generated and the operation terminates. The |
| termination of the operation occurs prior to the predictor update |
| step, so if the error occurs the contents of the predictors are |
| left unchanged. |
| |
| After the replacement step, the YCrCb image is converted to RGB. |
| If UNPACK_TO_RGB_SGIX is enabled, an RGB image is produced using |
| an unspecified algorithm. If UNPACK_TO_RGB_SGIX is disabled, the |
| RGB image is producted by setting R to Y, G to Cr, and B to Cb. |
| The output image is treated as an RGB floating-point image. |
| |
| Additions to Chapter 4 of the 1.1 Specification (Per-Fragment Operations |
| and the Frame Buffer) |
| |
| The following entries are added to Table 4.5: |
| |
| Parameter Name Type Initial Value Valid Range |
| -------------- ---- ------------- ----------- |
| PACK_MPEG_PREDICTOR_FWD_SGIX integer 0 [0, infinity] |
| PACK_MPEG_PREDICTOR_BACK_SGIX integer 0 [0, infinity] |
| PACK_MPEG_PREDICTOR_STORE_SGIX Z3 NONE NONE, PACK_MPEG_PREDICTOR_FWD_SGIX, PACK_MPEG_PREDICTOR_BACK_SGIX |
| PACK_MPEG_PREDICTOR_STORE_SINK_SGIX boolean FALSE TRUE/FALSE |
| PACK_MPEG_PREDICTOR_READ_SGIX Z3 NONE NONE, PACK_MPEG_PREDICTOR_FWD_SGIX, PACK_MPEG_PREDICTOR_BACK_SGIX |
| PACK_MPEG_PICTURE_TYPE_SGIX Z3 NONE MPEG_IFRAME_SGIX, MPEG_PFRAME_SGIX, MPEG_BFRAME_SGIX |
| PACK_MPEG_ADAPT_QUANT_SCALE b FALSE TRUE/FALSE |
| |
| The following is added to the "Packing of Compressed Images" |
| subsection following the paragraph beginning "If image compression |
| is on...": For MPEG1-compressed images (PACK_COMPRESSION_TYPE_SGIX |
| equal to MPEG1_SGIX), only image sizes for which width and height |
| are multiples of 16 are permitted. Other image sizes result in |
| the generation of the error INVALID_OPERATION. The type of frame |
| to be created is determined by the setting of |
| PACK_MPEG_PICTURE_TYPE_SGIX. During MPEG1 compression, if this |
| value is not equal to MPEG_IFRAME_SGIX, MPEG_PFRAME_SGIX, or |
| MPEG_BFRAME_SGIX, the error INVALID_ENUM is generated and no |
| processing takes place. |
| |
| If PACK_TO_RGB_SGIX is TRUE, the RGBA input image is converted |
| to a YCrCb image using an unspecified algorithm. If |
| PACK_TO_RGB_SGIX is FALSE, the input image is converted to YCrCb |
| by setting the Y equal to R, Cr equal to G, and Cb equal to B. |
| |
| The MPEG predictor bound to the bind point specified by |
| PACK_MPEG_PREDICTOR_STORE_SGIX is overwritten by the current image |
| if the value of PACK_MPEG_PREDICTOR_STORE_SGIX is not equal to |
| NONE. The update of PACK_MPEG_PREDICTOR_SGIX takes place in the |
| same manner as the update of UNPACK_MPEG_PREDICTOR_SGIX described |
| in section 3.6.3 (including the generation of errors and possible |
| termination of processing), except that the appropriate PACK |
| values are used in place of the UNPACK values. |
| |
| As with decompression, the value PACK_MPEG_PREDICTOR_READ_SGIX may |
| be used to specify a bind point whose contents will replace the |
| current image in all subsequent processing. This update is |
| identical to that described in section 3.6.3 (including the |
| generation of errors and possible termination of processing), |
| except that the appropriate PACK values are used in place of the |
| UNPACK values. |
| |
| The YCrCb image as downsampled is specified by PACK_SAMPLE_SGIX. |
| The operation is described in SGIX_image_compression. |
| |
| The output of the downsampling step is converted based upon the |
| frame type specified by PACK_MPEG_PICTURE_TYPE_SGIX. In this |
| extension, we do not specify the algorithms used. We list the GL |
| state used to control the algorithm, but the interpretation of |
| this state is implementation-dependent. All algorithms may be |
| effected by the setting of PACK_MPEG_ADAPT_QUANT_SCALE. Other |
| parameters affect different frame types in different ways and will |
| be discussed in the paragraphs below. |
| |
| If the frame type is MPEG_IFRAME_SGIX, the conversion does not use |
| any predictors. The conversion may use the contents of the |
| quantizer table PACK_MPEG_INTRA_QUANT_SGIX. Unlike during |
| decompression, the contents of the quant tables may not be changed |
| by the compression operation. |
| |
| If the frame type is MPEG_PFRAME_SGIX, the data is converted using |
| the predictor bound to PACK_MPEG_PREDICTOR_BACK_SGIX. If the |
| image size is not equal to the size of the predictor, the error |
| INVALID_OPERATION is generated and the operation is terminated. |
| The conversion may also use the contents of the quantizer table |
| PACK_MPEG_NON_INTRA_QUANT_SGIX, but the contents of the quantizer |
| may not be changed by the compression operation. |
| |
| If the frame type is MPEG_BFRAME_SGIX, the data is converted using |
| the predictors bound to PACK_MPEG_PREDICTOR_BACK_SGIX and |
| PACK_MPEG_PREDICTOR_FWD_SGIX. If the sizes of the predictors are |
| not equal to the image size, the error INVALID_OPERATION is |
| generated and the operation is terminated. The algorithms used in |
| the compression are not defined by this extension. The conversion |
| may also use the contents of the quantizer table |
| PACK_MPEG_NON_INTRA_QUANT_SGIX. The contents of table not may be |
| changed by the compression operation. |
| |
| The output of MPEG1 compression is a byte stream containing an |
| MPEG1 picture header followed by picture data. |
| |
| Additions to Chapter 5 of the 1.1 Specification (Special Functions) |
| |
| All of the procedures and functions added by this extension are |
| not included in display lists, but instead are executed |
| immediately. |
| |
| Additions to Chapter 6 of the 1.1 Specification (State and State Requests) |
| |
| The routine |
| |
| void GetMPEGQuantTableubv(enum target, ubyte *values); |
| |
| is used to read back the contents of an MPEG quantizer table. The |
| valid values for the parameter <target> are: |
| PACK_MPEG_INTRA_QUANT_SGIX, PACK_MPEG_NON_INTRA_QUANT_SGIX, |
| UNPACK_MPEG_INTRA_QUANT_SGIX, and |
| UNPACK_MPEG_NON_INTRA_QUANT_SGIX. If the value of <target> is not |
| legal, the error INVALID_ENUM is generated. <values> points to a |
| 64-element array. The organization of data in the array is not |
| specified by this extension. |
| |
| The routine |
| |
| void GetMPEGPredictorSGIX(enum target, enum format, enum type, |
| void *pixels); |
| |
| is used to read back the contents of the predictor bound to a bind |
| point specified by <target>. The error INVALID_ENUM is generated |
| if <target> is not one of UNPACK_MPEG_PREDICTOR_FWD_SGIX, |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX, PACK_MPEG_PREDICTOR_FWD_SGIX, or |
| PACK_MPEG_PREDICTOR_BACK_SGIX. <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. If <format> |
| or <type> does not give a legal value, the error INVALID_ENUM is |
| generated. The two-dimensional image is returned to <pixels>. No |
| pixel transfer operations are performed on this image, but pixel |
| storage modes (including possibly MPEG compression) that are |
| applicable to ReadPixels are performed. Since the predictor does |
| not contain an alpha channel, any alpha values which are returned |
| are set to zero. If the pixel store operations applied would |
| change the contents of the predictor bound to <target>, the error |
| INVALID_OPERATION is generated. |
| |
| The routines |
| |
| void GetMPEGParameterfvSGIX(enum target, enum pname, |
| float *params); |
| |
| and |
| |
| void GetMPEGParameterivSGIX(enum target, enum pname, |
| int *params); |
| |
| are used to return attributes of a predictor object bound to |
| <target> as floating-point or integer values (respectively). |
| <target> must specify one of UNPACK_MPEG_PREDICTOR_FWD_SGIX, |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX, PACK_MPEG_PREDICTOR_FWD_SGIX, or |
| PACK_MPEG_PREDICTOR_BACK_SGIX or the error INVALID_ENUM is |
| generated. <pname> specifies the attribute to be returned and |
| must be MPEG_PREDICTOR_WIDTH_SGIX or MPEG_PREDICTOR_HEIGHT_SGIX. |
| These values cause the width or height of the predictor to be |
| returned to the location in client memory specified by <params>. |
| If <pname> does not specify a legal value, the error INVALID_ENUM |
| is generated. |
| |
| Additions to the GLX Specification |
| |
| None. |
| |
| GLX Protocol |
| |
| XXX |
| |
| Errors |
| |
| INVALID_ENUM is generated if the parameter <target> to |
| MPEGQuantTableubv is not one of the legal values listed above. |
| |
| INVALID_OPERATION is generated if the name zero is passed as one |
| of the predictors to AllocMPEGPredictorsSGIX. |
| |
| INVALID_VALUE is generated if the parameter <pname> to PixelStorei |
| or PixelStoref indicates a predictor bind point but <param> is not |
| the name of a predictor object. |
| |
| INVALID_OPERATION is generated if parameter <format> to |
| MPEGPredictorSGIX is not one of RED, GREEN, BLUE, ALPHA, RGB, |
| RGBA, ABGR_EXT, LUMINANCE, or LUMINANCE_ALPHA. |
| |
| INVALID_OPERATION is generated if parameter <type> to |
| MPEGPredictorSGIX is not one of UNSIGNED_BYTE, BYTE, |
| UNSIGNED_SHORT, SHORT, UNSIGNED_INT, INT, or FLOAT. |
| |
| INVALID_ENUM is generated if either or both of the parameters |
| <target0> and <target1> to the command SwapMPEGPredictorsSGIX is |
| not the name of a valid predictor bind point. |
| |
| INVALID_OPERATION is generated if UNPACK_COMPRESSION_TYPE_SGIX is |
| MPEG1_SGIX and during a pixel download the values width and height |
| (as computed in SGIX_image_compression) are not legal for MPEG1 |
| decompression. |
| |
| INVALID_OPERATION is generated if UNPACK_MPEG_PREDICTOR_STORE_SGIX |
| is set to UNPACK_MPEG_PREDICTOR_BACK_SGIX during the download of a |
| P- or B-frame or if UNPACK_MPEG_PREDICTOR_STORE_SGIX is set to |
| UNPACK_MPEG_PREDICTOR_FORWARD_SGIX during the download of a |
| B-frame. |
| |
| INVALID_OPERATION is generated if UNPACK_MPEG_PREDICTOR_READ_SGIX |
| and UNPACK_MPEG_PREDICTOR_STORE_SGIX are set to the same value |
| during a MPEG decompression and that value is not NONE. |
| |
| INVALID_OPERATION is generated if during MPEG decompression |
| UNPACK_MPEG_PREDICTOR_READ_SGIX and |
| UNPACK_MPEG_PREDICTOR_STORE_SGIX specify bind points to which the |
| same predictor is bound. |
| |
| INVALID_OPERATION is generated if PACK_COMPRESSION_TYPE_SGIX is |
| MPEG1_SGIX and during a pixel readback the values width and height |
| (as computed in SGIX_image_compression) are not legal for MPEG1 |
| compression. |
| |
| INVALID_OPERATION is generated if PACK_MPEG_PREDICTOR_STORE_SGIX |
| is set to PACK_MPEG_PREDICTOR_BACK_SGIX during the readback of a |
| P- or B-frame or if PACK_MPEG_PREDICTOR_STORE_SGIX is set to |
| PACK_MPEG_PREDICTOR_FORWARD_SGIX during the readback of a B-frame. |
| |
| INVALID_OPERATION is generated if PACK_MPEG_PREDICTOR_READ_SGIX |
| and PACK_MPEG_PREDICTOR_STORE_SGIX are set to the same value |
| during a MPEG compression and that value is not NONE. |
| |
| INVALID_OPERATION is generated if during MPEG decompression |
| PACK_MPEG_PREDICTOR_READ_SGIX and PACK_MPEG_PREDICTOR_STORE_SGIX |
| specify bind points to which the same predictor is bound. |
| |
| INVALID_ENUM is generated if the <target> parameter to |
| GetMPEGPredictorSGIX is not a legal value. |
| |
| INVALID_ENUM is generated if the <format> parameter to |
| GetMPEGPredictorSGIX is not one of the accepted values. |
| |
| INVALID_ENUM is generated if the <type> parameter to |
| GetMPEGPredictorSGIX is not one of the accepted values. |
| |
| INVALID_OPERATION is generated if the pixel storage modes in |
| operation when GetMPEGPredictorSGIX is called would change the |
| contents of the predictor bound to <target>. |
| |
| INVALID_ENUM is generated if the <target> parameter to |
| GetMPEGParameterfvSGIX or GetMPEGParameterivSGIX is not one of the |
| accepted values. |
| |
| INVALID_ENUM is generated if the <pname> parameter to |
| GetMPEGParameterfvSGIX or GetMPEGParameterivSGIX is not one of the |
| accepted values. |
| |
| INVALID_OPERATION is generated if any of the commands defined in this |
| extension is executed between the execution of Begin and the |
| corresponding execution of End. |
| |
| New State |
| Initial |
| Get Value Get Command Type Value Attrib |
| --------- ----------- ---- ------- ------ |
| PACK_MPEG_PREDICTOR_DST_SGIX GetIntegerv Z+ 0 client |
| PACK_MPEG_PREDICTOR_SRC_SGIX GetIntegerv Z+ 0 client |
| PACK_MPEG_PREDICTOR_FWD_SGIX GetIntegerv Z+ 0 client |
| PACK_MPEG_PREDICTOR_BACK_SGIX GetIntegerv Z+ 0 client |
| UNPACK_MPEG_PREDICTOR_DST_SGIX GetIntegerv Z+ 0 client |
| UNPACK_MPEG_PREDICTOR_SRC_SGIX GetIntegerv Z+ 0 client |
| UNPACK_MPEG_PREDICTOR_FWD_SGIX GetIntegerv Z+ 0 client |
| UNPACK_MPEG_PREDICTOR_BACK_SGIX GetIntegerv Z+ 0 client |
| |
| PACK_MPEG_PREDICTOR_TO_DST_SGI GetIntegerv B 0 client |
| PACK_MPEG_PREDICTOR_FROM_SRC_SGIX GetIntegerv B 0 client |
| PACK_MPEG_PREDICTOR_TO_DST_SINK_SGIX GetIntegerv B 0 client |
| UNPACK_MPEG_PREDICTOR_TO_DST_SGIX GetIntegerv B 0 client |
| UNPACK_MPEG_PREDICTOR_FROM_SRC_SGIX GetIntegerv B 0 client |
| UNPACK_MPEG_PREDICTOR_TO_DST_SINK_SGIX GetIntegerv B 0 client |
| |
| PACK_MPEG_INTRA_QUANT GetMPEGQuantTableubv 64*Z+ ( 8,16,19,22,26,27,29,34, client |
| 16,16,22,24,47,49,34,37, |
| 19,22,26,27,29,34,34,38, |
| 22,22,26,27,29,34,37,40, |
| 22,26,27,29,32,35,40,48, |
| 26,27,29,32,35,40,48,58, |
| 26,27,29,34,38,46,56,69, |
| 27,29,35,38,46,56,69,83) |
| PACK_MPEG_NON_INTRA_QUANT GetMPEGQuantTableubv 64*Z+ (16,16,16,16,16,16,16,16, client |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16) |
| UNPACK_MPEG_INTRA_QUANT GetMPEGQuantTableubv 64*Z+ ( 8,16,19,22,26,27,29,34, client |
| 16,16,22,24,47,49,34,37, |
| 19,22,26,27,29,34,34,38, |
| 22,22,26,27,29,34,37,40, |
| 22,26,27,29,32,35,40,48, |
| 26,27,29,32,35,40,48,58, |
| 26,27,29,34,38,46,56,69, |
| 27,29,35,38,46,56,69,83) |
| UNPACK_MPEG_NON_INTRA_QUANT GetMPEGQuantTableubv 64*Z+ (16,16,16,16,16,16,16,16, client |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16, |
| 16,16,16,16,16,16,16,16) |
| MPEG_PREDICTOR_WIDTH_SGIX GetMPEGParameterivSGIX 3 x Z+ 0 client |
| MPEG_PREDICTOR_HEIGHT_SGIX GetMPEGParameterivSGIX 3 x Z+ 0 client |
| |
| New Implementation Dependent State |
| |
| None. |