playbin

Playbin provides a stand-alone everything-in-one abstraction for an audio and/or video player.

Playbin can handle both audio and video files and features

  • automatic file type recognition and based on that automatic selection and usage of the right audio/video/subtitle demuxers/decoders
  • visualisations for audio files
  • subtitle support for video files. Subtitles can be store in external files.
  • stream selection between different video/audio/subtitles streams
  • meta info (tag) extraction
  • easy access to the last video sample
  • buffering when playing streams over a network
  • volume control with mute option

Usage

A playbin element can be created just like any other element using gst_element_factory_make. The file/URI to play should be set via the uri property. This must be an absolute URI, relative file paths are not allowed. Example URIs are file:///home/joe/movie.avi or http://www.joedoe.com/foo.ogg

Playbin is a GstPipeline. It will notify the application of everything that's happening (errors, end of stream, tags found, state changes, etc.) by posting messages on its GstBus. The application needs to watch the bus.

Playback can be initiated by setting the element to PLAYING state using gst_element_set_state. Note that the state change will take place in the background in a separate thread, when the function returns playback is probably not happening yet and any errors might not have occured yet. Applications using playbin should ideally be written to deal with things completely asynchroneous.

When playback has finished (an EOS message has been received on the bus) or an error has occured (an ERROR message has been received on the bus) or the user wants to play a different track, playbin should be set back to READY or NULL state, then the uri property should be set to the new location and then playbin be set to PLAYING state again.

Seeking can be done using gst_element_seek_simple or gst_element_seek on the playbin element. Again, the seek will not be executed instantaneously, but will be done in a background thread. When the seek call returns the seek will most likely still be in process. An application may wait for the seek to finish (or fail) using gst_element_get_state with -1 as the timeout, but this will block the user interface and is not recommended at all.

Applications may query the current position and duration of the stream via gst_element_query_position and gst_element_query_duration and setting the format passed to GST_FORMAT_TIME. If the query was successful, the duration or position will have been returned in units of nanoseconds.

Advanced Usage: specifying the audio and video sink

By default, if no audio sink or video sink has been specified via the audio-sink or video-sink property, playbin will use the autoaudiosink and autovideosink elements to find the first-best available output method. This should work in most cases, but is not always desirable. Often either the user or application might want to specify more explicitly what to use for audio and video output.

If the application wants more control over how audio or video should be output, it may create the audio/video sink elements itself (for example using gst_element_factory_make) and provide them to playbin using the audio-sink or video-sink property.

GNOME-based applications, for example, will usually want to create gconfaudiosink and gconfvideosink elements and make playbin use those, so that output happens to whatever the user has configured in the GNOME Multimedia System Selector configuration dialog.

The sink elements do not necessarily need to be ready-made sinks. It is possible to create container elements that look like a sink to playbin, but in reality contain a number of custom elements linked together. This can be achieved by creating a GstBin and putting elements in there and linking them, and then creating a sink GstGhostPad for the bin and pointing it to the sink pad of the first element within the bin. This can be used for a number of purposes, for example to force output to a particular format or to modify or observe the data before it is output.

It is also possible to 'suppress' audio and/or video output by using 'fakesink' elements (or capture it from there using the fakesink element's "handoff" signal, which, nota bene, is fired from the streaming thread!).

Retrieving Tags and Other Meta Data

Most of the common meta data (artist, title, etc.) can be retrieved by watching for TAG messages on the pipeline's bus (see above).

Other more specific meta information like width/height/framerate of video streams or samplerate/number of channels of audio streams can be obtained from the negotiated caps on the sink pads of the sinks.

Buffering

Playbin handles buffering automatically for the most part, but applications need to handle parts of the buffering process as well. Whenever playbin is buffering, it will post BUFFERING messages on the bus with a percentage value that shows the progress of the buffering process. Applications need to set playbin to PLAYING or PAUSED state in response to these messages. They may also want to convey the buffering progress to the user in some way. Here is how to extract the percentage information from the message:

 switch (GST_MESSAGE_TYPE (msg)) {
   case GST_MESSAGE_BUFFERING: {
     gint percent = 0;
     gst_message_parse_buffering (msg, &percent);
     g_print ("Buffering (%u percent done)", percent);
     break;
   }
   ...
 }

Note that applications should keep/set the pipeline in the PAUSED state when a BUFFERING message is received with a buffer percent value < 100 and set the pipeline back to PLAYING state when a BUFFERING message with a value of 100 percent is received (if PLAYING is the desired state, that is).

Embedding the video window in your application

By default, playbin (or rather the video sinks used) will create their own window. Applications will usually want to force output to a window of their own, however. This can be done using the GstVideoOverlay interface, which most video sinks implement. See the documentation there for more details.

Specifying which CD/DVD device to use

The device to use for CDs/DVDs needs to be set on the source element playbin creates before it is opened. The most generic way of doing this is to connect to playbin's "source-setup" (or "notify::source") signal, which will be emitted by playbin when it has created the source element for a particular URI. In the signal callback you can check if the source element has a "device" property and set it appropriately. In some cases the device can also be set as part of the URI, but it depends on the elements involved if this will work or not. For example, for DVD menu playback, the following syntax might work (if the resindvd plugin is used): dvd://[/path/to/device]

Handling redirects

Some elements may post 'redirect' messages on the bus to tell the application to open another location. These are element messages containing a structure named 'redirect' along with a 'new-location' field of string type. The new location may be a relative or an absolute URI. Examples for such redirects can be found in many quicktime movie trailers.

Examples

 gst-launch-1.0 -v playbin uri=file:///path/to/somefile.mp4

This will play back the given AVI video file, given that the video and audio decoders required to decode the content are installed. Since no special audio sink or video sink is supplied (via playbin's audio-sink or video-sink properties) playbin will try to find a suitable audio and video sink automatically using the autoaudiosink and autovideosink elements.

 gst-launch-1.0 -v playbin uri=cdda://4

This will play back track 4 on an audio CD in your disc drive (assuming the drive is detected automatically by the plugin).

 gst-launch-1.0 -v playbin uri=dvd://

This will play back the DVD in your disc drive (assuming the drive is detected automatically by the plugin).

Hierarchy

GObject
    ╰──GInitiallyUnowned
        ╰──GstObject
            ╰──GstElement
                ╰──GstBin
                    ╰──GstPipeline
                        ╰──playbin

Factory details

Authors: – Wim Taymans

Classification:Generic/Bin/Player

Rank – none

Plugin – gstplayback

Package – GStreamer Base Plug-ins git

Signals

about-to-finish

about_to_finish_callback (GstElement * playbin,
                          gpointer udata)
def about_to_finish_callback (playbin, udata):
    #python callback for the 'about-to-finish' signal
function about_to_finish_callback(playbin: GstElement * playbin, udata: gpointer udata): {
    // javascript callback for the 'about-to-finish' signal
}

This signal is emitted when the current uri is about to finish. You can set the uri and suburi to make sure that playback continues.

This signal is emitted from the context of a GStreamer streaming thread.

Parameters:

playbin

a playbin

udata
No description available

audio-changed

audio_changed_callback (GstElement * playbin,
                        gpointer udata)
def audio_changed_callback (playbin, udata):
    #python callback for the 'audio-changed' signal
function audio_changed_callback(playbin: GstElement * playbin, udata: gpointer udata): {
    // javascript callback for the 'audio-changed' signal
}

This signal is emitted whenever the number or order of the audio streams has changed. The application will most likely want to select a new audio stream.

This signal may be emitted from the context of a GStreamer streaming thread. You can use gst_message_new_application and gst_element_post_message to notify your application's main thread.

Parameters:

playbin

a playbin

udata
No description available

audio-tags-changed

audio_tags_changed_callback (GstElement * playbin,
                             gint stream,
                             gpointer udata)
def audio_tags_changed_callback (playbin, stream, udata):
    #python callback for the 'audio-tags-changed' signal
function audio_tags_changed_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'audio-tags-changed' signal
}

This signal is emitted whenever the tags of an audio stream have changed. The application will most likely want to get the new tags.

This signal may be emitted from the context of a GStreamer streaming thread. You can use gst_message_new_application and gst_element_post_message to notify your application's main thread.

Parameters:

playbin

a playbin

stream

stream index with changed tags

udata
No description available

convert-sample

GstSample *
convert_sample_callback (GstElement * playbin,
                         GstCaps * caps,
                         gpointer udata)
def convert_sample_callback (playbin, caps, udata):
    #python callback for the 'convert-sample' signal
function convert_sample_callback(playbin: GstElement * playbin, caps: GstCaps * caps, udata: gpointer udata): {
    // javascript callback for the 'convert-sample' signal
}

Action signal to retrieve the currently playing video frame in the format specified by caps. If caps is NULL, no conversion will be performed and this function is equivalent to the sample property.

Parameters:

playbin

a playbin

caps

the target format of the frame

udata
No description available
Returns ( GstSample * ) –

a GstSample of the current video frame converted to caps. The caps on the sample will describe the final layout of the buffer data. NULL is returned when no current buffer can be retrieved or when the conversion failed.


element-setup

element_setup_callback (GstElement * playbin,
                        GstElement * element,
                        gpointer udata)
def element_setup_callback (playbin, element, udata):
    #python callback for the 'element-setup' signal
function element_setup_callback(playbin: GstElement * playbin, element: GstElement * element, udata: gpointer udata): {
    // javascript callback for the 'element-setup' signal
}

This signal is emitted when a new element is added to playbin or any of its sub-bins. This signal can be used to configure elements, e.g. to set properties on decoders. This is functionally equivalent to connecting to the deep-element-added signal, but more convenient.

This signal is usually emitted from the context of a GStreamer streaming thread, so might be called at the same time as code running in the main application thread.

Parameters:

playbin

a playbin

element

an element that was added to the playbin hierarchy

udata
No description available

Since : 1.10


get-audio-pad

GstPad *
get_audio_pad_callback (GstElement * playbin,
                        gint stream,
                        gpointer udata)
def get_audio_pad_callback (playbin, stream, udata):
    #python callback for the 'get-audio-pad' signal
function get_audio_pad_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'get-audio-pad' signal
}

Action signal to retrieve the stream-combiner sinkpad for a specific audio stream. This pad can be used for notifications of caps changes, stream-specific queries, etc.

Parameters:

playbin

a playbin

stream

an audio stream number

udata
No description available
Returns ( GstPad * ) –

a GstPad, or NULL when the stream number does not exist.


get-audio-tags

GstTagList *
get_audio_tags_callback (GstElement * playbin,
                         gint stream,
                         gpointer udata)
def get_audio_tags_callback (playbin, stream, udata):
    #python callback for the 'get-audio-tags' signal
function get_audio_tags_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'get-audio-tags' signal
}

Action signal to retrieve the tags of a specific audio stream number. This information can be used to select a stream.

Parameters:

playbin

a playbin

stream

an audio stream number

udata
No description available
Returns ( GstTagList * ) –

a GstTagList with tags or NULL when the stream number does not exist.


get-text-pad

GstPad *
get_text_pad_callback (GstElement * playbin,
                       gint stream,
                       gpointer udata)
def get_text_pad_callback (playbin, stream, udata):
    #python callback for the 'get-text-pad' signal
function get_text_pad_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'get-text-pad' signal
}

Action signal to retrieve the stream-combiner sinkpad for a specific text stream. This pad can be used for notifications of caps changes, stream-specific queries, etc.

Parameters:

playbin

a playbin

stream

a text stream number

udata
No description available
Returns ( GstPad * ) –

a GstPad, or NULL when the stream number does not exist.


get-text-tags

GstTagList *
get_text_tags_callback (GstElement * playbin,
                        gint stream,
                        gpointer udata)
def get_text_tags_callback (playbin, stream, udata):
    #python callback for the 'get-text-tags' signal
function get_text_tags_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'get-text-tags' signal
}

Action signal to retrieve the tags of a specific text stream number. This information can be used to select a stream.

Parameters:

playbin

a playbin

stream

a text stream number

udata
No description available
Returns ( GstTagList * ) –

a GstTagList with tags or NULL when the stream number does not exist.


get-video-pad

GstPad *
get_video_pad_callback (GstElement * playbin,
                        gint stream,
                        gpointer udata)
def get_video_pad_callback (playbin, stream, udata):
    #python callback for the 'get-video-pad' signal
function get_video_pad_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'get-video-pad' signal
}

Action signal to retrieve the stream-combiner sinkpad for a specific video stream. This pad can be used for notifications of caps changes, stream-specific queries, etc.

Parameters:

playbin

a playbin

stream

a video stream number

udata
No description available
Returns ( GstPad * ) –

a GstPad, or NULL when the stream number does not exist.


get-video-tags

GstTagList *
get_video_tags_callback (GstElement * playbin,
                         gint stream,
                         gpointer udata)
def get_video_tags_callback (playbin, stream, udata):
    #python callback for the 'get-video-tags' signal
function get_video_tags_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'get-video-tags' signal
}

Action signal to retrieve the tags of a specific video stream number. This information can be used to select a stream.

Parameters:

playbin

a playbin

stream

a video stream number

udata
No description available
Returns ( GstTagList * ) –

a GstTagList with tags or NULL when the stream number does not exist.


source-setup

source_setup_callback (GstElement * playbin,
                       GstElement * source,
                       gpointer udata)
def source_setup_callback (playbin, source, udata):
    #python callback for the 'source-setup' signal
function source_setup_callback(playbin: GstElement * playbin, source: GstElement * source, udata: gpointer udata): {
    // javascript callback for the 'source-setup' signal
}

This signal is emitted after the source element has been created, so it can be configured by setting additional properties (e.g. set a proxy server for an http source, or set the device and read speed for an audio cd source). This is functionally equivalent to connecting to the notify::source signal, but more convenient.

This signal is usually emitted from the context of a GStreamer streaming thread.

Parameters:

playbin

a playbin

source

source element

udata
No description available

text-changed

text_changed_callback (GstElement * playbin,
                       gpointer udata)
def text_changed_callback (playbin, udata):
    #python callback for the 'text-changed' signal
function text_changed_callback(playbin: GstElement * playbin, udata: gpointer udata): {
    // javascript callback for the 'text-changed' signal
}

This signal is emitted whenever the number or order of the text streams has changed. The application will most likely want to select a new text stream.

This signal may be emitted from the context of a GStreamer streaming thread. You can use gst_message_new_application and gst_element_post_message to notify your application's main thread.

Parameters:

playbin

a playbin

udata
No description available

text-tags-changed

text_tags_changed_callback (GstElement * playbin,
                            gint stream,
                            gpointer udata)
def text_tags_changed_callback (playbin, stream, udata):
    #python callback for the 'text-tags-changed' signal
function text_tags_changed_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'text-tags-changed' signal
}

This signal is emitted whenever the tags of a text stream have changed. The application will most likely want to get the new tags.

This signal may be emitted from the context of a GStreamer streaming thread. You can use gst_message_new_application and gst_element_post_message to notify your application's main thread.

Parameters:

playbin

a playbin

stream

stream index with changed tags

udata
No description available

video-changed

video_changed_callback (GstElement * playbin,
                        gpointer udata)
def video_changed_callback (playbin, udata):
    #python callback for the 'video-changed' signal
function video_changed_callback(playbin: GstElement * playbin, udata: gpointer udata): {
    // javascript callback for the 'video-changed' signal
}

This signal is emitted whenever the number or order of the video streams has changed. The application will most likely want to select a new video stream.

This signal is usually emitted from the context of a GStreamer streaming thread. You can use gst_message_new_application and gst_element_post_message to notify your application's main thread.

Parameters:

playbin

a playbin

udata
No description available

video-tags-changed

video_tags_changed_callback (GstElement * playbin,
                             gint stream,
                             gpointer udata)
def video_tags_changed_callback (playbin, stream, udata):
    #python callback for the 'video-tags-changed' signal
function video_tags_changed_callback(playbin: GstElement * playbin, stream: gint stream, udata: gpointer udata): {
    // javascript callback for the 'video-tags-changed' signal
}

This signal is emitted whenever the tags of a video stream have changed. The application will most likely want to get the new tags.

This signal may be emitted from the context of a GStreamer streaming thread. You can use gst_message_new_application and gst_element_post_message to notify your application's main thread.

Parameters:

playbin

a playbin

stream

stream index with changed tags

udata
No description available

Properties

async-handling

“async-handling” gboolean

The bin will handle Asynchronous state changes

Flags : Read / Write

Default value : false


audio-filter

“audio-filter” GstElement *

the audio filter(s) to apply, if possible

Flags : Read / Write


audio-sink

“audio-sink” GstElement *

the audio output element to use (NULL = default sink)

Flags : Read / Write


audio-stream-combiner

“audio-stream-combiner” GstElement *

Get or set the current audio stream combiner. By default, an input-selector is created and deleted as-needed.

Flags : Read / Write


auto-flush-bus

“auto-flush-bus” gboolean

Whether to automatically flush the pipeline's bus when going from READY into NULL state

Flags : Read / Write

Default value : true


av-offset

“av-offset” gint64

Control the synchronisation offset between the audio and video streams. Positive values make the audio ahead of the video and negative values make the audio go behind the video.

Flags : Read / Write

Default value : 0


buffer-duration

“buffer-duration” gint64

Buffer duration when buffering network streams

Flags : Read / Write

Default value : 18446744073709551615


buffer-size

“buffer-size” gint

Buffer size when buffering network streams

Flags : Read / Write

Default value : -1


connection-speed

“connection-speed” guint64

Network connection speed in kbps (0 = unknown)

Flags : Read / Write

Default value : 0


current-audio

“current-audio” gint

Get or set the currently playing audio stream. By default the first audio stream with data is played.

Flags : Read / Write

Default value : -1


current-suburi

“current-suburi” gchararray

The currently playing subtitle uri.

Flags : Read

Default value : NULL


current-text

“current-text” gint

Get or set the currently playing subtitle stream. By default the first subtitle stream with data is played.

Flags : Read / Write

Default value : -1


current-uri

“current-uri” gchararray

The currently playing uri.

Flags : Read

Default value : NULL


current-video

“current-video” gint

Get or set the currently playing video stream. By default the first video stream with data is played.

Flags : Read / Write

Default value : -1


delay

“delay” guint64

Expected delay needed for elements to spin up to PLAYING in nanoseconds

Flags : Read / Write

Default value : 0


flags

“flags” Play-flags

Control the behaviour of playbin.

Flags : Read / Write

Default value : soft-colorbalance+deinterlace+soft-volume+text+audio+video


force-aspect-ratio

“force-aspect-ratio” gboolean

When enabled, scaling will respect original aspect ratio

Flags : Read / Write

Default value : true


latency

“latency” guint64

Latency to configure on the pipeline

Flags : Read / Write

Default value : 18446744073709551615


message-forward

“message-forward” gboolean

Forwards all children messages

Flags : Read / Write

Default value : false


mute

“mute” gboolean

Mute the audio channel without changing the volume

Flags : Read / Write

Default value : false


n-audio

“n-audio” gint

Get the total number of available audio streams.

Flags : Read

Default value : 0


n-text

“n-text” gint

Get the total number of available subtitle streams.

Flags : Read

Default value : 0


n-video

“n-video” gint

Get the total number of available video streams.

Flags : Read

Default value : 0


name

“name” gchararray

The name of the object

Flags : Read / Write / Construct

Default value : NULL


parent

“parent” GstObject *

The parent of the object

Flags : Read / Write


ring-buffer-max-size

“ring-buffer-max-size” guint64

The maximum size of the ring buffer in bytes. If set to 0, the ring buffer is disabled. Default 0.

Flags : Read / Write

Default value : 0


sample

“sample” GstSample *

Get the currently rendered or prerolled sample in the video sink. The GstCaps in the sample will describe the format of the buffer.

Flags : Read


source

“source” GstElement *

Source element

Flags : Read


subtitle-encoding

“subtitle-encoding” gchararray

Encoding to assume if input subtitles are not in UTF-8 encoding. If not set, the GST_SUBTITLE_ENCODING environment variable will be checked for an encoding to use. If that is not set either, ISO-8859-15 will be assumed.

Flags : Read / Write

Default value : NULL


subtitle-font-desc

“subtitle-font-desc” gchararray

Pango font description of font to be used for subtitle rendering

Flags : Read / Write

Default value : NULL


suburi

“suburi” gchararray

Set the next subtitle URI that playbin will play. This property can be set from the about-to-finish signal to queue the next subtitle media file.

Flags : Read / Write

Default value : NULL


text-offset

“text-offset” gint64

Control the synchronisation offset between the text and video streams. Positive values make the text ahead of the video and negative values make the text go behind the video.

Flags : Read / Write

Default value : 0


text-sink

“text-sink” GstElement *

the text output element to use (NULL = default subtitleoverlay)

Flags : Read / Write


text-stream-combiner

“text-stream-combiner” GstElement *

Get or set the current text stream combiner. By default, an input-selector is created and deleted as-needed.

Flags : Read / Write


uri

“uri” gchararray

Set the next URI that playbin will play. This property can be set from the about-to-finish signal to queue the next media file.

Flags : Read / Write

Default value : NULL


video-filter

“video-filter” GstElement *

the video filter(s) to apply, if possible

Flags : Read / Write


video-multiview-flags

“video-multiview-flags” Video-multiview-flags

Override details of the multiview frame layout

Flags : Read / Write

Default value : none


video-multiview-mode

“video-multiview-mode” Video-multiview-frame-packing

Re-interpret a video stream as one of several frame-packed stereoscopic modes.

Flags : Read / Write

Default value : none (-1)


video-sink

“video-sink” GstElement *

the video output element to use (NULL = default sink)

Flags : Read / Write


video-stream-combiner

“video-stream-combiner” GstElement *

Get or set the current video stream combiner. By default, an input-selector is created and deleted as-needed.

Flags : Read / Write


vis-plugin

“vis-plugin” GstElement *

the visualization element to use (NULL = default)

Flags : Read / Write


volume

“volume” gdouble

Get or set the current audio stream volume. 1.0 means 100%, 0.0 means mute. This uses a linear volume scale.

Flags : Read / Write

Default value : 1


Named constants

Play-flags

Extra flags to configure the behaviour of the sinks.

Members

video (0x00000001) – Render the video stream
audio (0x00000002) – Render the audio stream
text (0x00000004) – Render subtitles
vis (0x00000008) – Render visualisation when no video is present
soft-volume (0x00000010) – Use software volume
native-audio (0x00000020) – Only use native audio formats
native-video (0x00000040) – Only use native video formats
download (0x00000080) – Attempt progressive download buffering
buffering (0x00000100) – Buffer demuxed/parsed data
deinterlace (0x00000200) – Deinterlace video if necessary
soft-colorbalance (0x00000400) – Use software color balance
force-filters (0x00000800) – Force audio/video filter(s) to be applied

Video-multiview-flags

Members

none (0x00000000) – GST_VIDEO_MULTIVIEW_FLAGS_NONE
right-view-first (0x00000001) – GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST
left-flipped (0x00000002) – GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED
left-flopped (0x00000004) – GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED
right-flipped (0x00000008) – GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED
right-flopped (0x00000010) – GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED
half-aspect (0x00004000) – GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT
mixed-mono (0x00008000) – GST_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO

Video-multiview-frame-packing

Members

none (-1) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_NONE
mono (0) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_MONO
left (1) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_LEFT
right (2) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_RIGHT
side-by-side (3) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_SIDE_BY_SIDE
side-by-side-quincunx (4) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_SIDE_BY_SIDE_QUINCUNX
column-interleaved (5) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_COLUMN_INTERLEAVED
row-interleaved (6) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_ROW_INTERLEAVED
top-bottom (7) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_TOP_BOTTOM
checkerboard (8) – GST_VIDEO_MULTIVIEW_FRAME_PACKING_CHECKERBOARD

The results of the search are