blob: 90fb96ecd78430a655760a80a9dcbaf6a881acd9 [file] [log] [blame]
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.