## NVIDIA DRIVE OS Linux SDK API Reference

#### 5.1.9.0 Release

EGL_KHR_stream
Name

KHR_stream
KHR_stream_attrib

Name Strings

EGL_KHR_stream
EGL_KHR_stream_attrib

Contributors

Marcus Lorentzon
Acorn Pooley
Robert Palmer
Greg Prisament
Daniel Kartch
Miguel A. Vico Moya

Contacts

Acorn Pooley, NVIDIA  (apooley 'at' nvidia.com)
Marcus Lorentzon, ST-Ericsson AB (marcus.xm.lorentzon 'at' stericsson.com)
Daniel Kartch, NVIDIA (dkartch 'at' nvidia.com)

Notice

Status

Complete.
Approved by the Khronos Board of Promoters on December 2, 2011.

Version

Version 27 - May 23, 2016

Number

EGL Extension #32

Dependencies

EGL_KHR_stream requires EGL 1.2.

EGL_KHR_stream_attrib requires EGL_KHR_stream and EGL 1.5.

EGL_KHR_stream_attrib interacts with
EGL_KHR_stream_consumer_gltexture.

This extension is written based on the wording of the EGL 1.2
specification.

Overview

This extension defines a new object, the EGLStream, that can be
used to efficiently transfer a sequence of image frames from one
API to another.  The EGLStream has mechanisms that can help keep
audio data synchronized to video data.

Each EGLStream is associated with a "producer" that generates
image frames and inserts them into the EGLStream.  The producer is
responsible for inserting each image frame into the EGLStream at
the correct time so that the consumer can display the image frame
for the appropriate period of time.

Each EGLStream is also associated with a "consumer" that
retrieves image frames from the EGLStream.  The consumer is
responsible for noticing that an image frame is available and
displaying it (or otherwise consuming it).  The consumer is also
responsible for indicating the latency when that is possible (the
latency is the time that elapses between the time it is retrieved
from the EGLStream until the time it is displayed to the user).

Some APIs are stream oriented (examples: OpenMAX IL, OpenMAX AL).
These APIs may be connected directly to an EGLStream as a producer
or consumer.  Once a stream oriented producer is "connected" to an
EGLStream and "started" it may insert image frames into the
EGLStream automatically with no further interaction from the
application. Likewise, once a stream oriented consumer is
"connected" to an EGLStream and "started" it may retrieve image
frames from the EGLStream automatically with no further interaction
from the application.

Some APIs are rendering oriented and require interaction with the
application during the rendering of each frame (examples: OpenGL,
OpenGL ES, OpenVG).  These APIs will not automatically insert or
retrieve image frames into/from the EGLStream.  Instead the
application must take explicit action to cause a rendering
oriented producer to insert an image frame or to cause a rendering
oriented consumer to retrieve an image frame.

The EGLStream conceptually operates as a mailbox.  When the
producer has a new image frame it empties the mailbox (discards
the old contents) and inserts the new image frame into the
mailbox.  The consumer retrieves the image frame from the mailbox
and examines it.  When the consumer is finished examining the
image frame it is either placed back in the mailbox (if the
mailbox is empty) or discarded (if the mailbox is not empty).

Timing is mainly controlled by the producer.  The consumer
operated with a fixed latency that it indicates to the producer
through the EGL_CONSUMER_LATENCY_USEC_KHR attribute.  The consumer
is expected to notice when a new image frame is available in the
EGLStream, retrieve it, and display it to the user in the time
indicated by EGL_CONSUMER_LATENCY_USEC_KHR.  The producer controls
when the image frame will be displayed by inserting it into the
stream at time
T - EGL_CONSUMER_LATENCY_USEC_KHR
where T is the time that the image frame is intended to appear to
the user.

This extension does not cover the details of how a producer or a
consumer works or is "connected" to an EGLStream.  Different kinds
of producers and consumers work differently and are described in
additional extension specifications.  (Examples of producer
specifications:
EGL_KHR_stream_producer_eglsurface
EGL_KHR_stream_producer_aldatalocator
OpenMAX_AL_EGLStream_DataLocator
Example of consumer extension specification:
EGL_KHR_stream_consumer_gltexture
)

Glossary

EGLStream
An EGL object that transfers a sequence of image frames from one
API to another (e.g. video frames from OpenMAX AL to OpenGL ES).

Image frame
A single image in a sequence of images.  The sequence may be
frames of video data decoded from a video file, images output by a
camera sensor, surfaces rendered using OpenGL ES commands, or
generated in some other manner.  An image frame has a period of
time during which it is intended to be displayed on the screen
(starting with the "Image Frame Display Time" and ending with the
"Image Frame Display Time" of the next image frame in the
sequence).

Image Frame Insertion Time
The point in time when the producer inserts the image frame into
the EGLStream.  This is the "Image Frame Intended Display Time"
minus the "Consumer Latency".

Image Frame Intended Display Time
The point in time when the user should first see the image frame
on the display screen.

Image Frame Actual Display Time
The point in time when the user actually first sees the image frame
on the display screen.

Consumer Latency
The elapsed time between an image frame's "Image Frame Insertion
Time" and its "Image Frame Actual Display Time".  The consumer is
responsible for predicting this and indicating its value to the
EGLStream.  The producer is responsible for using this value to
calculate the "Image Frame Insertion Time" for each image frame.
EGL_CONSUMER_LATENCY_USEC attribute.

Producer
The entity that inserts image frames into the EGLStream.  The
producer is responsible for timing: it must insert image frames at
a point in time equal to the "Image Frame Intended Display Time"
minus the "Consumer Latency".

Consumer
The entity that retrieves image frames from the EGLStream.  When
the image frames are to be displayed to the user the consumer is
responsible for calculating the "Consumer Latency" and reporting
it to the EGLSteam.

State (stream state)
At any given time an EGLStream is in one of several states.  See
section "3.10.4.3 EGL_STREAM_STATE_KHR Attribute" in this
extension for a description of the states and what transitions
occur between them.

New Types

This is the type of a handle that represents an EGLStream object.

typedef void* EGLStreamKHR;

This is a 64 bit unsigned integer.

typedef khronos_uint64_t EGLuint64KHR;

New functions defined by EGL_KHR_stream

EGLStreamKHR eglCreateStreamKHR(
EGLDisplay    dpy,
const EGLint *attrib_list);

EGLBoolean eglDestroyStreamKHR(
EGLDisplay   dpy,
EGLStreamKHR stream);

EGLBoolean eglStreamAttribKHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLenum      attribute,
EGLint       value);

EGLBoolean eglQueryStreamKHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLenum      attribute,
EGLint      *value);

EGLBoolean eglQueryStreamu64KHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLenum      attribute,
EGLuint64KHR *value);

New functions defined by EGL_KHR_stream_attrib

EGLStreamKHR eglCreateStreamAttribKHR(
EGLDisplay       dpy,
const EGLAttrib *attrib_list);

EGLBoolean eglSetStreamAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream,
EGLenum          attribute,
EGLAttrib        value);

EGLBoolean eglQueryStreamAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream,
EGLenum          attribute,
EGLAttrib       *value);

EGLBoolean eglStreamConsumerAcquireAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream
const EGLAttrib *attrib_list);

EGLBoolean eglStreamConsumerReleaseAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream,
const EGLAttrib *attrib_list);

New Tokens

This value is returned from eglCreateStreamKHR in the case of an
error. It is an error to attempt to use this value as a parameter
to any EGL or client API function.

EGL_NO_STREAM_KHR                           ((EGLStreamKHR)0)

This enum is accepted as an attribute in the <attrib_list> parameter
of eglCreateStreamKHR and as the <attribute> parameter of
eglStreamAttribKHR, eglSetStreamAttribKHR, eglQueryStreamKHR and
eglQueryStreamAttribKHR.

EGL_CONSUMER_LATENCY_USEC_KHR               0x3210

These enums are accepted as the <attribute> parameter of
eglQueryStreamu64KHR.

EGL_PRODUCER_FRAME_KHR                      0x3212
EGL_CONSUMER_FRAME_KHR                      0x3213

This enum is accepted as the <attribute> parameter of
eglQueryStreamKHR and eglQueryStreamAttribKHR.

EGL_STREAM_STATE_KHR                        0x3214

Returned in the <value> parameter of eglQueryStreamKHR or
eglQueryStreamAttribKHR when <attribute> is EGL_STREAM_STATE.

EGL_STREAM_STATE_CREATED_KHR                0x3215
EGL_STREAM_STATE_CONNECTING_KHR             0x3216
EGL_STREAM_STATE_EMPTY_KHR                  0x3217
EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR    0x3218
EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR    0x3219
EGL_STREAM_STATE_DISCONNECTED_KHR           0x321A

These errors may be generated by EGLStream calls.

Add a new section "2.5 Streams" after section "2.4 Shared State"

EGL allows efficient interoperation between APIs through the
EGLStream object.  An EGLStream represents a sequence of image
frames.

Each EGLStream is associated with a producer that generates image
frames and inserts them into the EGLStream.  Each EGLStream is
also associated with a consumer that retrieves image frames from
the EGLStream.

Add a new section "3.10 EGLStreams" after section "3.9 Posting the
Color Buffer"

3.10 EGLStreams

EGL provides functions to create and destroy EGLStreams, for
querying and setting attributes of EGLStreams, and for connecting
EGLStreams to producers and consumers.

Each EGLStream may be connected to only one producer and one
consumer.  Once an EGLStream is connected to a consumer, it will
be connected to that consumer until the EGLStream is destroyed.
Likewise, once an EGLStream is connected to a producer it will be
connected to that producer until the EGLStream is destroyed.
Further semantics are described for each type of consumer and
producer that can be connected.

Add subsection 3.10.1 to section "3.10 EGLStreams"

3.10.1 Creating an EGLStream

Call

EGLStreamKHR eglCreateStreamKHR(
EGLDisplay    dpy,
const EGLint *attrib_list);

to create a new EGLStream. <dpy> specifies the EGLDisplay used for
this operation. The function returns a handle to the created
EGLStream.

The EGLStream cannot be used until it has been connected to a
consumer and then to a producer (refer to section "3.10.2
Connecting an EGLStream to a consumer" and section "3.10.3
Connecting an EGLStream to a producer").  It must be connected to
a consumer before being connected to a producer.

There is no way for the application to query the size,
colorformat, or number of buffers used in the EGLStream (although
these attributes may be available from the producer's API or the
consumer's API depending on what type of producer/consumer is
connected to the EGLStream).

The parameter <attrib_list> contains a list of attributes and
values to set for the EGLStream.  Attributes not in the list are
set to default values.  EGLStream attributes are described in
section "3.10.4 EGLStream Attributes".

If an error occurs eglCreateStreamKHR will return
EGL_NO_STREAM_KHR and generate an error.

- EGL_BAD_ATTRIBUTE is generated if any of the parameters in
attrib_list is not a valid EGLStream attribute.

- EGL_BAD_ACCESS is generated if any of the parameters in

- EGL_BAD_PARAMETER is generated if any of the values in
attrib_list is outside the valid range for the attribute.

- EGL_BAD_ALLOC is generated if not enough resources are
available to create the EGLStream.

- EGL_BAD_DISPLAY is generated if <dpy> is not a valid,
initialized EGLDisplay.

If EGL_KHR_stream_attrib is present, add to the end of this section

Streams may also be created by calling

EGLStreamKHR eglCreateStreamAttribKHR(
EGLDisplay       dpy,
const EGLAttrib *attrib_list);

This is equivalent to eglCreateStreamKHR, but allows pointer
and handle attributes to be provided on 64-bit systems.

Add section 3.10.2 to section "3.10 EGLStreams"

3.10.2 Connecting an EGLStream to a consumer.

Before using an EGLStream it must be connected to a consumer.

Refer to sections 3.10.2.1 and following for different ways to
connect a consumer to an EGLStream.

Once an EGLStream is connected to a consumer it will remain
connected to the same consumer until the EGLStream is destroyed.

If the consumer is destroyed then the EGLStream's state will
become EGL_STREAM_STATE_DISCONNECTED_KHR.

Any attempt to connect an EGLStream which is not in state
EGL_STREAM_STATE_CREATED_KHR will fail and generate an

When an EGLStream is connected to a consumer its state becomes
EGL_STREAM_STATE_CONNECTING_KHR.

3.10.2.1 No way to connect consumer to EGLStream

EGL does not currently define any mechanisms to connect a consumer

(Example: See extension specification
EGL_KHR_stream_consumer_gltexture)

If EGL_KHR_stream_attrib is present, add to the end of this section

3.10.2.2 Acquiring and releasing consumer frames

Methods for acquiring frames from a stream and releasing them back
to a stream are dependent on the type of consumer. Some consumers
support calling

EGLBoolean eglStreamConsumerAcquireAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream
const EGLAttrib *attrib_list);

to acquire the next available frame in <stream> and

EGLBoolean eglStreamConsumerReleaseAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream,
const EGLAttrib *attrib_list);

to release a frame back to the stream.

Not all consumers are required to support either or both of these
functions. Where supported, the specific behavior is defined by the
consumer type, and may be affected by the contents of <attrib_list>.
<attrib_list> must either be NULL or a pointer to a list of
name/value pairs terminated by EGL_NONE. Valid attributes are
listed in tables 3.10.2.1 and 3.10.2.2.

Attribute                 Type        Section
------------------------  ----------  -------
Currently no acquire attributes are defined

Table 3.10.2.1 EGLStream Consumer Acquire Attributes

Attribute                 Type        Section
------------------------  ----------  -------
Currently no release attributes are defined

Table 3.10.2.2 EGLStream Consumer Release Attributes

If no new image frame is available in the stream,
eglStreamConsumerAcquireAtrribKHR may block, retrieve an old frame,
or return an error, as defined by the type of consumer. If one or
more image frames are already acquired by the consumer when
eglStreamConsumerAcquireAttribKHR is called, the behavior is
determined by the type of consumer.

If successful, eglStreamConsumerAcquireAttribKHR returns EGL_TRUE
and an image frame from <stream> will be bound into the address
space of the consumer as defined for its type.

On failure, the function returns EGL_FALSE and generates an error.
become invalid, as determined by the consumer type.

- EGL_BAD_ACCESS is generated if the consumer of <stream> does
not support acquiring frames through
eglStreamConsumerAcquireAttribKHR.

- EGL_BAD_STATE_KHR is no frame is available for acquisition
after any timeout determined by the consumer.

- EGL_BAD_ATTRIBUTE is generated if an attribute name in
<attrib_list> is not recognized or is not supported by the
consumer.

- EGL_BAD_STREAM_KHR is generated if <stream> is not a valid
EGLStream created for <dpy>.

- EGL_BAD_DISPLAY is generated if <dpy> is not a valid
EGLDisplay.

- EGL_NOT_INITIALIZED is generated if <dpy> is not initialized.

Calling eglStreamConsumerReleaseAttribKHR will release a frame held
by the consumer back to the stream. If more than one frame is held
by the consumer, the frame returned is determined by the consumer
type and the contents of <attrib_list>. If no frames are currently
held, the behavior is determined by the consumer type. Once
returned, the consumer may no longer access the contents of the
frame, and attempts to do so will result in errors as determined by
the consumer type. Upon success, eglStreamConsumerReleaseAttribKHR
returns EGL_TRUE.

If eglStreamConsumerReleaseAttribKHR fails, EGL_FALSE is returned
and an error is generated.

- EGL_BAD_ACCESS is generated if the consumer of <stream> does
not support releasing frames through
eglStreamConsumerReleaseAttribKHR.

- EGL_BAD_STATE_KHR is generated if <stream> is not in state
EGL_STREAM_STATE_EMPTY_KHR,
EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR or
EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR.

- EGL_BAD_ATTRIBUTE is generated if an attribute name in
<attrib_list> is not recognized or is not supported by the
consumer.

- EGL_BAD_STREAM_KHR is generated if <stream> is not a valid
EGLStream created for <dpy>.

- EGL_BAD_DISPLAY is generated if <dpy> is not a valid
EGLDisplay.

- EGL_NOT_INITIALIZED is generated if <dpy> is not initialized.

If EGL_KHR_stream_consumer_gltexture is present in addition to
EGL_KHR_stream_attrib, the eglStreamConsumerAcquireKHR function is
equivalent to eglStreamConsumerAcquireAttribKHR with <attrib_list> set
to NULL, the eglStreamConsumerReleaseKHR function is equivalent to
eglStreamConsumerReleaseAttribKHR with <attrib_list> set to NULL, and
the definitions provided for those functions define their behavior for
a GL texture consumer.

Add section 3.10.3 to section "3.10 EGLStreams"

3.10.3 Connecting an EGLStream to a producer.

Before using an EGLStream it must be connected to a producer.  The
EGLStream must be connected to a consumer before it may be
connected to a producer.

The size and colorformat of the images in the EGLStream are
determined by the EGL implementation based on the requirements of
the producer and the consumer.  The EGL implementation may
determine these at the time the producer is connected to the
EGLStream, at the time that the first image frame is inserted into
the EGLStream, or any time in between (this is left up to the
implementation).

It is the responsibility of the producer to convert the images to
a form that the consumer can consume.  The producer may negotiate
with the consumer as to what formats and sizes the consumer is
able to consume, but this negotiation (whether it occurs and how
it works) is an implementation detail.  If the producer is unable
to convert the images to a form that the consumer can consume then
the attempt to connect the producer to the EGLStream will fail and

Refer to sections 3.10.3.1 and following for different ways to
connect a producer to an EGLStream.

Once an EGLStream is connected to a producer it will remain
connected to the same producer until the EGLStream is destroyed.
If the producer is destroyed then the EGLStream's state will
become EGL_STREAM_STATE_DISCONNECTED_KHR (refer to "3.10.4.3
EGL_STREAM_STATE_KHR Attribute").

Any attempt to connect an EGLStream which is not in state
EGL_STREAM_STATE_CONNECTING_KHR will fail and generate an

When an EGLStream is connected to a producer its state becomes
EGL_STREAM_STATE_EMPTY_KHR.  At this point the producer may begin
inserting image frames and the consumer may begin consuming image
frames, so the state may immediately change to
EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR and/or
EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR.

3.10.3.1 No way to connect producer to EGLStream

EGL does not currently define any mechanisms to connect a producer

(For example see extension specifications
EGL_KHR_stream_producer_eglsurface
EGL_KHR_stream_producer_aldatalocator
OpenMAX_AL_EGLStream_DataLocator
.)

Add section 3.10.4 to section "3.10 EGLStreams"

3.10.4 EGLStream Attributes

Each EGLStream contains a set of attributes and values as
described in table 3.10.4.4.  Each attribute has a type and a
only (io - meaning it may be set in the attrib_list but not
changed once the EGLStream is created).

--------------------------  ----------   ------        --------
EGL_STREAM_STATE_KHR            ro       EGLint        3.10.4.3
EGL_PRODUCER_FRAME_KHR          ro       EGLuint64KHR  3.10.4.4
EGL_CONSUMER_FRAME_KHR          ro       EGLuint64KHR  3.10.4.5
EGL_CONSUMER_LATENCY_USEC_KHR   rw       EGLint        3.10.4.6

Table 3.10.4.4 EGLStream Attributes

3.10.4.1 Setting EGLStream Attributes

Call

EGLBoolean eglStreamAttribKHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLint       attribute,
EGLint       value);

to set the value of an attribute for an EGLStream.  The <value> is
the new value for <attribute>.  Only read/write (rw) attributes
with type EGLint may be set with eglStreamAttribKHR (see "Table
3.10.4.4 EGLStream Attributes").

If an error occurs, EGL_FALSE is returned and an error is
generated.

- EGL_BAD_STATE_KHR is generated if <stream> is in
EGL_STREAM_STATE_DISCONNECTED_KHR state.

- EGL_BAD_ATTRIBUTE is generated if <attribute> is not a valid
EGLStream attribute.

- EGL_BAD_PARAMETER is generated if value is outside the valid
range for <attribute>.

- EGL_BAD_STREAM_KHR is generated if <stream> is not a valid
EGLStream created for <dpy>.

- EGL_BAD_DISPLAY is generated if <dpy> is not a valid,
initialized EGLDisplay.

3.10.4.2 Querying EGLStream Attributes

Call

EGLBoolean eglQueryStreamKHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLint       attribute,
EGLint      *value);

to query the value of an EGLStream's attribute with type EGLint
and call

EGLBoolean eglQueryStreamu64KHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLenum      attribute,
EGLuint64KHR *value);

to query the value of an EGLStream's attribute with type
EGLuint64KHR.

If an error occurs EGL_FALSE is returned and an error is
generated.

- EGL_BAD_STREAM_KHR is generated if <stream> is not a valid
EGLStream created for <dpy>.

- EGL_BAD_ATTRIBUTE is generated by eglQueryStreamKHR if
<attribute> is not a valid EGLStream attribute with type
EGLint.

- EGL_BAD_ATTRIBUTE is generated by eglQueryStreamu64KHR if
<attribute> is not a valid EGLStream attribute with type
EGLuint64KHR.

3.10.4.3 EGL_STREAM_STATE_KHR Attribute

The EGL_STREAM_STATE_KHR attribute is read only.  It indicates the
state of the EGLStream.  The EGLStream may be in one of the
following states:

- EGL_STREAM_STATE_CREATED_KHR - The EGLStream has been created
but not yet connected to a producer or a consumer.

- EGL_STREAM_STATE_CONNECTING_KHR - The EGLStream has been
connected to a consumer but not yet connected to a producer.

- EGL_STREAM_STATE_EMPTY_KHR - the EGLStream has been connected
to a consumer and a producer, but the producer has not yet
inserted any image frames.

- EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR - the producer has
inserted at least one image frame that the consumer has not
yet retrieved.

- EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR - the producer has
inserted at least one image frame, and the consumer has
already retrieved the most recently inserted image frame.

- EGL_STREAM_STATE_DISCONNECTED_KHR - either the producer or the
consumer (or both) are no longer connected to the EGLStream
(e.g.  because they have been destroyed).  Once the
EGLStream is in this state it will remain in this state
until the EGLStream is destroyed.  In this state only
eglQueryStreamKHR and eglDestroyStreamKHR are valid
operations.

Only the following state transitions may occur:

-> EGL_STREAM_STATE_CREATED_KHR
A new EGLStream is created in this state.

EGL_STREAM_STATE_CREATED_KHR ->
EGL_STREAM_STATE_CONNECTING_KHR
Occurs when a consumer is connected to the EGLStream.

EGL_STREAM_STATE_CONNECTING_KHR ->
EGL_STREAM_STATE_EMPTY_KHR
Occurs when a producer is connected to the EGLStream.

EGL_STREAM_STATE_EMPTY_KHR ->
EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR
Occurs the first time the producer inserts an image frame.

EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR ->
EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR
Occurs when the consumer begins examining a newly inserted
image frame.

EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR ->
EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR
Occurs when the producer inserts a new image frame.

* ->
EGL_STREAM_STATE_DISCONNECTED_KHR
Occurs when the producer or consumer is destroyed or is
otherwise unable to function normally.

3.10.4.4 EGL_PRODUCER_FRAME_KHR Attribute

The EGL_PRODUCER_FRAME_KHR attribute indicates how many image
frames have been inserted into the EGLStream by the producer.
This is also known as the "frame number" of the most recently
inserted frame (where the first frame inserted has a frame number
of 1).  When EGL_STREAM_STATE_KHR is EGL_STREAM_STATE_CREATED_KHR,
EGL_STREAM_STATE_CONNECTING_KHR, or EGL_STREAM_STATE_EMPTY_KHR
then this value is 0.  This value will wrap back to 0 after

3.10.4.4 EGL_CONSUMER_FRAME_KHR Attribute

The EGL_CONSUMER_FRAME_KHR attribute indicates the frame number of
the image frame that the consumer most recently retrieved.  This is
the value that EGL_PRODUCER_FRAME_KHR contained just after this
image frame was inserted into the EGLStream.

3.10.4.5 EGL_CONSUMER_LATENCY_USEC_KHR Attribute

This attribute indicates the number of microseconds that elapse (on
average) from the time that an image frame is inserted into the
EGLStream by the producer until the image frame is visible to the
user.

It is the responsibility of the consumer to set this value.  Some
types of consumers may simply set this value to zero or an
implementation constant value.  Other consumers may adjust this
value dynamically as conditions change.

It is the responsibility of the producer to use this information to
insert image frames into the EGLStream at an appropriate time.
The producer should insert each image frame into the stream at the
time that frame should appear to the user MINUS the
EGL_CONSUMER_LATENCY_USEC_KHR value.  Some types of producers may
ignore this value.

The application may modify this value to adjust the timing of the
stream (e.g. to make video frames coincide with an audio track
under direction from a user).  However the value set by the
application may be overridden by some consumers that dynamically
adjust the value.  This will be noted in the description of
consumers which do this.

If EGL_KHR_stream_attrib is present, add to the end of section "3.10.4.1
Setting EGLStream Attributes"

Attributes may also be set by calling

EGLBoolean eglSetStreamAttribKHR(
EGLDisplay   dpy,
EGLStreamKHR stream,
EGLenum      attribute,
EGLAttrib    value);

This is equivalent to eglStreamAttribKHR, but allows attributes
with pointer and handle types, in addition to EGLint.

If EGL_KHR_stream_attrib is present, add to the end of section "3.10.4.2
Querying EGLStream Attributes"

Attributes may also be queried by calling

EGLBoolean eglQueryStreamAttribKHR(
EGLDisplay       dpy,
EGLStreamKHR     stream,
EGLenum          attribute,
EGLAttrib       *value);

This is equivalent to eglQueryStreamKHR, but allows attributes with
pointer and handle types, in addition to EGLint.

Add sections 3.10.5 and 3.10.6 to section "3.10 EGLStreams"

3.10.5 EGLStream operation

3.10.5.1 EGLStream operation in mailbox mode

The EGLStream conceptually operates as a mailbox.

When the producer has a new image frame it empties the mailbox and
inserts the new image frame into the mailbox.  If the image frame
is intended to be displayed at time T then the producer must
insert it into the EGLStream at time
T - EGL_CONSUMER_LATENCY_USEC_KHR

The consumer retrieves the image frame from the mailbox and
examines it.  When the consumer is finished examining the image
frame it is either placed back in the mailbox (if the mailbox is
empty) or discarded (if the mailbox is not empty).

This operation implies 2 things:

- If the consumer consumes frames slower than the producer
inserts frames, then some frames may be lost (never seen by
the consumer).

- If the consumer consumes frames faster than the producer
inserts frames, then the consumer may see some frames more
than once.

Some details of EGLStream operation are dependent on the type of
producer and consumer that are connected to it.  Refer to the
documentation for the producer and consumer for more details
(section 3.10.2.* and 3.10.3.*).

3.10.6 Destroying an EGLStream

Call

EGLBoolean eglDestroyStreamKHR(
EGLDisplay   dpy,
EGLStreamKHR stream);

to mark an EGLStream for deletion.  After this call returns the
<stream> will no longer be a valid stream handle.  The resources
associated with the EGLStream may not be deleted until the
producer and consumer have released their references to the
resources (if any).  Exactly how this is done is dependent on the
type of consumer and producer that is connected to the EGLStream.

If an error occurs, EGL_FALSE is returned and an error is
generated.

- EGL_BAD_STREAM_KHR is generated if <stream> is not a valid
EGLStream created for <dpy>.

Issues
1.  Are EGL_WIDTH and EGL_HEIGHT parameters needed?

RESOLVED: No.  The width and height of images managed by the
stream are determined by the producer.  No application access
to the size is currently required.

2.  Is EGL_BUFFER_SHOW_ALL_KHR required, or should the stream always
act as EGL_BUFFER_REPLACE_KHR?

RESOLVED: this has been removed.  The old
EGL_BUFFER_SHOW_ALL_KHR behavior is described in a separate
extension: EGL_KHR_stream_fifo

3.  What are the exact semantics of the producer?

RESOLVED:  The exact semantics vary depending on the type of
producer.  Refer to the extension that defines the type of

In general, the producer is responsible for inserting image
frames into the EGLStream at the correct time.  The correct
time depends on how the image frames are being created and on
the value of EGL_CONSUMER_LATENCY_USEC_KHR.

4.  What are the exact semantics of the consumer?

RESOLVED:  The exact semantics vary depending on the type of
consumer.  Refer to the extension that defines the type of

In general, the consumer is responsible for retrieving image
frames from the EGLStream when they become available.  The
consumer is also responsible for setting the
EGL_CONSUMER_LATENCY_USEC_KHR when that is possible.

5.  When will the EGLStream resources be deleted?

RESOLVED: this depends on the type of consumer and producer.
Refer to the description of the consumer and producer (e.g. in
the extension that describes them).

6.  How does A/V sync work?

RESOLVED: The producer is responsible for A/V sync, but the
consumer needs to help.  The consumer indicates the latency
(the average time that it takes the consumer to retrieve an
image from the EGLStream and place it on the display screen)
by setting the EGL_CONSUMER_LATENCY_USEC_KHR.  The producer
uses knowledge about the audio stream to determine the correct
time to display an image frame, and inserts the image frame at
that time MINUS the EGL_CONSUMER_LATENCY_USEC_KHR.

7.  What if the consumer cannot determine the latency?

RESOLVED: If the consumer does not set the
EGL_CONSUMER_LATENCY_USEC_KHR attribute then its default value
will be used.  This default value is implementation defined
and may be zero.  See the description of the specific type of
consumer you are using (e.g. the extension that defines it)
for more details related to that consumer.

8.  What colorformats are supported by EGLStream

RESOLVED: No specific formats are required, but it is expected
that this work with the main YUV formats supported by the
platform's video HW and the main RGB(A) formats supported by
the platform's OpenGL (ES) hardware.  It is the responsibility
of the producer to negotiate a format that will work with the
consumer.  If the internal formats supported by the producer
do not coincide with the internal formats supported by the
consumer then the producer may choose to convert to a format
that the consumer understands, or it may choose to fail and
generate an error when an attempt is made to connect it to the
EGLStream.  Exactly which it does for which formats is further
discussed in the producer endpoint documentation (refer to the
extension that describes the producer endpoint).

9.  Is any EGLImage extension required by this extension?

RESOLVED: No. This extension may be implemented using some of
the same code that is used to implement EGLImages, but there
is no dependency on EGLImages.

10. Why describe the "io" attribute type if no attributes use it.

RESOLVED: Future extensions will add attributes of "io" type
(initialize only - meaning they can be set in the attribute
list when creating the EGLStream, but not modified once the
EGLStream is created).  Rather than requiring each such
extension to describe the "io" type (and possibly getting
slightly different definitions or types in different
extensions) the "io" type is defined here so that other
extensions can easily use it.  This helps layered
extensions to all use the same language.

Revision History

#27 (May 23, 2016) Daniel Kartch
- For compatibility with EGL 1.5 and support of 64-bit
platforms, add EGL_KHR_stream_attrib extension with variants
of original functions that accept attributes of type
EGLAttrib.
- Corrected line length violations.

#26 (July 12, 2012) Acorn Pooley
- Fix error in description of consumer latency.

#25 (October 12, 2011) Acorn Pooley

#24 (October 11, 2011) Acorn Pooley
- add error condition to eglDestroyStreamKHR

#23 (October 5, 2011) Acorn Pooley
- refer to related EGL_KHR_... extension specs rather than
EGL_NV_... ones.

#22 (September 27, 2011) Acorn Pooley
- Fix enum value for EGL_STREAM_STATE_KHR (bug 8064)

#21 (September 27, 2011) Acorn Pooley
- Assign enum values (bug 8064)

#20 (September 23, 2011) Acorn Pooley
- Rename EGL_NO_IMAGE_STREAM_KHR to EGL_NO_STREAM_KHR

#19 (Aug 3, 2011) Acorn Pooley
- fix some error conditions

#18 (Aug 2, 2011) Acorn Pooley
- make EGL_PRODUCER_FRAME_KHR and EGL_CONSUMER_FRAME_KHR 64
bit.

#17 (Aug 2, 2011) Acorn Pooley
- fix grammar

#16 (July 6, 2011) Acorn Pooley
- rename from EGL_KHR_image_stream to EGL_KHR_stream

#15 (June 29, 2011) Acorn Pooley
- major re-write
- remove EGL_SWAP_MODE_KHR and EGL_BUFFER_SHOW_ALL_KHR
eglStreamAttribKHR
eglQueryStreamKHR
EGL_CONSUMER_LATENCY_USEC_KHR
EGL_PRODUCER_FRAME_KHR
EGL_CONSUMER_FRAME_KHR
EGL_STREAM_STATE_KHR
- add more thorough overview section
- place the functions in section 3 of the spec (were in
section 2)
- mention some of the consumer and producer specs that may be
needed to make use of this extension.
- remove very old issues that no longer make any sense
- add new issues and resolutions

#14 (June 4, 2010) Greg Prisament
- fix minor typo

#13 (June 2, 2010) Marcus Lorentzon

#12 (May 21, 2010) Marcus Lorentzon
- add clarifications on swap modes

#11 (April 13, 2010) Marcus Lorentzon
- fix tyops
- make eglDestroyStream return EGLBoolean, not void

#10 (March 17, 2010) Marcus Lorentzon
- fix typo
- remove obsolete text
- update issue 2 resolution

#9  (December 15, 2009) Marcus Lorentzon
- move EGL_IMAGE_USE_* attributes to the endpoint extension
- resolved issue 5

#8  (December 6, 2009) Marcus Lorentzon
- remove EGL_INIT_COLOR_KHR
- relax the definition of the Producer to allow not only video
frames to be generated
- clean up the language of recently produced, supplied, pending
images

#7  (October 19, 2009) Acorn Pooley
- Update based on comments from Robert and Bruce
- remove mention of OpenWF
- make EGL_BUFFER_REPLACE_KHR be the default EGL_SWAP_MODE_KHR
- remove EGLAPI and EGLAPIENTRY

#6  (September 16, 2009) Acorn Pooley
- remove EGL_WIDTH and EGL_HEIGHT parameters
- clarify swap modes
- other clarifications and simplifications

#5  (July 2, 2009) Acorn Pooley
- remove reference to no-longer-existing <images> parameter.
- mention dependancy on EGL_KHR_image_uses extension.
- add description of EGL_IMAGE_USE_AS_* enums.

#4  (June 3, 2009) Acorn Pooley
- Fix typos: change old EGLImageStream occurances to EGLStream

#3  (April 22, 2009) Marcus Lorentzon