XXX - Not complete yet!!!

Name

    SGI_cushion

Name Strings

    GLX_SGI_cushion

Version

    $Date: 2005/06/02 18:12:31 $ $Revision: 1.1 $

Number

    62

Dependencies

    SGI_swap_control is required
    SGIX_fbconfig affects the definition of this extension

Overview

    This extension is directed at constant frame-rate applications.  Such
    applications are written to ensure that a new image is generated every
    N video frame periods, where N is itself a small constant integer.
    If the application is unable to generate a frame within N video frame
    periods, it is said to have dropped a frame.  Dropping a frame is a
    *bad thing*.

    Constant frame-rate applications make every effort to avoid dropping
    frames.  In particular, they monitor the utilization of graphics
    resources during the rendering of the current frame in order to predict
    the behavior of subsequent frames.  If such prediction indicates that
    a frame may be dropped, the rendering complexity of the frame is
    reduced (e.g. by using models of lower geometric resolution) so as to
    avoid the overload condition.

    Unfortunately, because exact prediction is not possible, and because
    there is no elasticity in the buffering of images, it is necessary
    for constant frame-rate applications to under utilize the graphics
    hardware.  This extension adds elasticity to the buffering of completed
    images, in order to allow constant frame-rate applications to make full
    use of the available graphics computation without dropping frames.
    It further allows this elasticity to be controlled by the application in
    order to minimize the introduction of latency that could otherwise
    occur.

    Applications that will benefit from this extension include simulation,
    walk-through, and multimedia playback.

    WARNING - Silicon Graphics has filed for patent protection for some
	      of the techniques described in this extension document.

Issues

    *	This spec should talk about the vertical retrace interrupt, but I
	can't find any mention of it in any other extension.  Where is such
	an interrupt specified?

    *	Are additional queries of rendering performance required to make
	extension useful?

    *	How should this extension interact with SGI_video_sync?

    *	How is the cushion value queried?

    *	Can this be implemented efficiently on current hardware systems?

New Procedures and Functions

    void glXCushionSGI(Display *dpy, Window window, float cushion);

New Tokens

    Accepted by the <attribList> parameter of glXChooseVisual, and by the
    <attrib> parameter of glXGetConfig:

	GLX_CUSHION_BUFFERS_SGI

Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)

    None

Additions to Chapter 3 of the 1.0 Specification (Rasterization)

    None

Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
and the Frame Buffer)

    None

Additions to Chapter 5 of the 1.0 Specification (Special Functions)

    None

Additions to Chapter 6 of the 1.0 Specification (State and State Requests)

    None

Additions to the GLX Specification

    This extension increases the number of color buffers of a double
    buffered visual.  The additional buffers are referred to as cushion
    buffers.  It is not possible for an application to directly access
    a cushion buffer -- access is provided only to the front and back
    buffers (as before).

    When glXSwapBuffers is executed, the contents of the back buffer are
    transferred to the front buffer, which is itself appended onto a queue
    of displayable buffers.  However, the contents of the front buffer
    will not typically be transferred to the back buffer.  Instead, the
    contents of the back buffer are undefined.  Said another way, the
    front buffer is the color buffer most recently appended to the queue
    of displayable buffers, and the back buffer is the color buffer that
    will next be appended to this queue.

    When a buffer is appended onto the queue of displayable buffers, the
    current value of the swap interval (specified by glXSwapIntervalSGI) is
    stored with it.  The display is always driven by the oldest displayable
    buffer in the queue of displayable buffers.  After the oldest buffer in
    the queue has been displayed for its specified number of video frame
    periods, it is removed from the queue, exposing the next-to-oldest
    buffer for display.  If there is only one buffer in the queue of
    displayable buffers, the removal is deferred until another buffer
    becomes displayable, and then until the next video frame boundary.

    Cushion buffers are used to store displayable buffers on the queue.
    There can be at most N+1 buffers in the queue of displayable buffers,
    where N is the number of cushion buffers.  N is queried by calling
    glXGetConfig with <attrib> set to GLX_CUSHION_BUFFERS_SGI.

    The new command

	voidglXCushionSGI(Display *dpy, Window window, float cushion)

    specifies a cushion value for a window.  This value is silently clamped
    to the continuous range [0,N], where N is the number of cushion buffers.
    When a window is created, the cushion value is initialized to zero.

    Let the remaining display time T for a buffer in the queue of
    displayable buffers be the swap interval value for that buffer, minus
    the (fractional) number of video periods that the buffer has already
    been displayed.  If T thus defined would be negative, then let T be
    the fraction of the current video display period that remains.  (During
    the "vertical retrace period" this fraction is zero.)  Let Q be the sum
    of the remaining display times T for each buffer in the queue of
    displayable buffers.  If Q is greater than the product of the current
    cushion value and the current swap interval, then glXSwapBuffers stalls
    until at least the moment that Q becomes less than this product.  While
    glXSwapBuffers is stalled, the queueing of the back buffer as the next
    displayable buffer is deferred, and the calling process is either not
    allowed to proceed (glXSwapBuffers doesn't return) or the subsequent GL
    command is not allowed to be issued.
    
    (An interrupt could be generated at the moment that Q becomes equal to
    the product of the current cushion value and the current swap interval.)

    The <attribList> parameter of glXChooseVisual may include
    GLX_CUSHION_BUFFERS_SGI, followed by an integer specifying the minimum
    number of cushion buffers.  (If GLX_CUSHION_BUFFERS_SGI is not included
    in the attribute list, then the minimum is zero.)  glXChooseVisual gives
    preference to the conforming visual with the smallest number of cushion
    buffers that is greater than or equal to the specified minimum.

    Notes
    -----

	*   This extension is designed so that cushion buffers can be added
	    to existing visuals.  It is intended that the semantics of this
	    extension be identical to the pre-extension semantics while the
	    cushion value is zero.  Cushion buffers need not be allocated
	    until the cushion is set greater than zero.

	*   The extension can be implemented with data copies, in which case
	    a potentially large number of cushion buffers can be supported.
	    Or it can be implemented using the 4 stereo buffers (and while
	    holding the left/right signal constant at right).  Using the
	    stereo buffers eliminates the need for data copies, thus
	    increasing the performance.

	*   This specification applies to both mono and stereo visuals,
	    but implementations will probably not support stereo visuals.

	*   An implementation can support the extension without providing
	    any cushion buffer visuals.

GLX Protocol

    XXX - not done yet

Dependencies on SGI_swap_control

    This extension requires SGI_swap_control.

Dependencies on SGI_video_sync

    XXX - not done yet

Dependencies on SGIX_fbconfig

    XXX - not done yet

Errors

    XXX - not done yet

New State
						Initial
    Get Value		Get Command	Type	Value	Attrib
    ---------		-----------	----	-------	------
    GLX_CUSHION_SGI	?		Z+	0.0	window state

New Implementation Dependent State

    None
