NVIDIA DRIVE OS Linux API Reference Release
For Test and Development only

 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages


Name Strings



    Daniel Kartch
    Adam Cheney


    Daniel Kartch, NVIDIA (dkartch 'at' nvidia.com)




    Version 4 - October 27, 2016


    EGL Extension #111

Extension Type

    EGL display extension


    Requires EGL_KHR_stream_fifo

Interactions with EGL_NV_stream_sync and

    This extension affects implementations of stream synchronization and
    GL texture consumer extensions in that it alters when functions
    waiting for new frames will be unblocked. However, as these waits
    are still tied to transitions to the
    required to the wording of those specifications.


    On platforms which support asynchronous rendering, frames may be
    inserted into a stream by the producer and become available to the
    consumer before rendering of the images has completed. When this
    happens, commands issued by the consumer which read from the image
    must implicitly wait before they can be executed. In many use cases,
    this is desirable behavior. Rendering pipelines are kept full, and
    frames are created and processed as fast as possible.

    However, in the case of a compositor which is consuming frames from
    multiple producers at once, combining them into a single output
    image, this can slow the compositor to the frame rate of the slowest
    producer. If the application acquires and uses an image from one
    producer which requires a long time to finish rendering, it will be
    prevented from presenting new frames from faster producers in a
    timely fashion. In this case, the compositor would prefer to reuse
    an older frame from the slower producer until the new one is ready.

    This could be handled with existing interfaces by the producer
    issuing appropriate Finish call before inserting the frame into the
    stream. However this requires the producer to have knowledge of the
    consumer's use case, and also introduces undesirable bubbles into
    the producer's pipeline which will slow it even further.

    This extension allows streams to be configured to defer the
    availability of new frames inserted by the producer until they are
    ready to be used. The producer proceeds as normal, but the frames
    visible to the consumer through query and acquire operations do not
    update immediately.

    Interactions of this feature with a stream operating in mailbox mode
    would be hard to define. Because newly inserted frames replace
    previous unacquired ones, it is possible that the consumer would
    never see a completed frame become available. Therefore this feature
    is only available for streams operating in FIFO mode.

New Types


New Functions


New Tokens

    Accepted as an attribute name in the <attrib_list> parameter of
    eglCreateStreamKHR and a the <attribute> parameter of

        EGL_STREAM_FIFO_SYNCHRONOUS_NV                 0x3336

Add new entry to table " EGLStream Attributes" in the
EGL_KHR_stream extension

        Attribute                      Read/Write    Type    Section
        ------------------------------ ---------- ---------- --------
        EGL_STREAM_FIFO_SYNCHRONOUS_NV     io     EGLBoolean 3.10.4.y

Add new subsection to section "3.10.4 EGLStream Attributes" in the
EGL_KHR_stream extension


    The EGL_STREAM_FIFO_SYNCHRONOUS_NV attribute controls whether frames
    inserted by the producer become available to the consumer
    synchronously or asynchronously.  If set to EGL_FALSE, then when a
    present operation for a new frame successfully completes, the state
    will immediately become EGL_STREAM_NEW_FRAME_AVAILABLE_KHR, queries
    of the most recently produced frame will indicate this frame, and
    acquire operations will be able to retrieve this frame. If set to
    EGL_TRUE, then until any asynchronous rendering for this frame
    completes, the state will not update, any queries of the most
    recently produced frame will only indicate the frame whose rendering
    most recently completed, and acquire operations will only obtain
    older completed frames.

    The default value is EGL_FALSE. If set to EGL_TRUE, the value of
    EGL_STREAM_FIFO_LENGTH_KHR must be non-zero, or an EGL_BAD_MATCH
    error will be generated.

Replace first two sentences of section " EGL_PRODUCER_FRAME
Attribute" in the EGL_KHR_stream extension

    The EGL_PRODUCER_FRAME_KHR attribute indicates how many image
    frames have become available for the consumer to acquire.  This is
    also known as the "frame number" of the most recent ready frame
    (where the first frame inserted has a frame number of 1). In
    asynchronous operation, this is the frame most recently inserted by
    the producer. In synchronous operation, this is the frame whose
    image content generation has most recently finished.

Replace contents of section "3.10.4.x+3 EGL_STREAM_TIME_PRODUCER_KHR" in
the EGL_KHR_stream_fifo extension

    This indicates the timestamp of the most recent ready frame in the
    EGLStream (i.e. frame number EGL_PRODUCER_FRAME_KHR).

Replace the second through fifth paragraphs of " EGLStream operation
in fifo mode" in the EGL_KHR_stream_fifo extension.

    In fifo mode the EGLStream conceptually operates as a fifo. An image
    frame in the fifo is considered "ready" if all operations on the
    image scheduled prior to its insertion in the stream have completed,

    When the consumer wants to consume a new image frame, behavior
    depends on the state of the EGLStream.  If the state is
    EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR then the image frame at the
    tail of the fifo is ready, and is removed from the fifo. If the
    state is EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR then the fifo has
    no ready image frames and the consumer consumes the same frame that
    it most recently consumed.  Otherwise there are no image frames
    available to consume (behavior in this case is described in the
    documentation for each type of consumer - see section "3.10.2
    Connecting an EGLStream to a consumer").

    operations which read from the image frame must implicitly wait for
    any producer operations used to generate the image contents to
    complete. Apart from the assumption that any such operations will
    eventually finish, there are no guaranteed bounds on the time
    required, and therefore no guaranteed bounds on when the consumer's
    operations will complete. In cases where reusing a previous frame is
    preferable to unknown latency between the time a consumer acquires a
    new frame and the time its processing of that frame is done,

    If there is no new ready frame at the tail of the fifo when the
    consumer is finished consuming an image frame then the consumer
    holds on to the image frame in case it needs to be consumed again
    later (this happens if the consumer wants to consume another image
    frame before the producer has inserted a new image frame into the
    fifo, or before any such frame has finished rendering in the case of
    synchronous operation).  In this case the state of the EGLStream
    will be EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR until a new image
    frame is ready (or until the state becomes

    The producer inserts image frames at the head of the fifo.  If the
    fifo is full (already contains <L> image frames, where <L> is the
    value of the EGL_STREAM_FIFO_LENGTH_KHR attribute) then the producer
    is stalled until the fifo is no longer full.  When there is at
    least one ready frame at the tail of the fifo, the EGLStream state



Revision History

    #4  (October 27, 2016) Daniel Kartch
        - Clean up for publication

    #3  (September 30, 2015) Daniel Kartch
        - Reserve enum.

    #2  (March 30, 2015) Daniel Kartch
        - Fix grammatical and typographical errors.

    #1  (March 27, 2015) Daniel Kartch
        - Initial draft