Message

class Message(*args, **kwargs)

Messages are implemented as a subclass of MiniObject with a generic Structure as the content. This allows for writing custom messages without requiring an API change while allowing a wide range of different types of messages.

Messages are posted by objects in the pipeline and are passed to the application using the Bus.

The basic use pattern of posting a message on a Bus is as follows:

gst_bus_post (bus, :func:`~gi.repository.Gst.Message.new_eos`);

A Element usually posts messages on the bus provided by the parent container using post_message().

Constructors

class Message

classmethod new_application(src: Object | None, structure: Structure) → Message

Create a new application-typed message. GStreamer will never create these messages; they are a gift from us to you. Enjoy.

Parameters:

src – The object originating the message.
structure – the structure for the message. The message will take ownership of the structure.

classmethod new_async_done(src: Object | None, running_time: int) → Message

The message is posted when elements completed an ASYNC state change. running_time contains the time of the desired running_time when this elements goes to PLAYING. A value of GST_CLOCK_TIME_NONE for running_time means that the element has no clock interaction and thus doesn’t care about the running_time of the pipeline.

Parameters:

src – The object originating the message.
running_time – the desired running_time

classmethod new_async_start(src: Object | None = None) → Message

This message is posted by elements when they start an ASYNC state change.

Parameters:: src – The object originating the message.

classmethod new_buffering(src: Object | None, percent: int) → Message

Create a new buffering message. This message can be posted by an element that needs to buffer data before it can continue processing. percent should be a value between 0 and 100. A value of 100 means that the buffering completed.

When percent is < 100 the application should PAUSE a PLAYING pipeline. When percent is 100, the application can set the pipeline (back) to PLAYING. The application must be prepared to receive BUFFERING messages in the PREROLLING state and may only set the pipeline to PLAYING after receiving a message with percent set to 100, which can happen after the pipeline completed prerolling.

MT safe.

Parameters:

src – The object originating the message.
percent – The buffering percent

classmethod new_clock_lost(src: Object | None, clock: Clock) → Message

Create a clock lost message. This message is posted whenever the clock is not valid anymore.

If this message is posted by the pipeline, the pipeline will select a new clock again when it goes to PLAYING. It might therefore be needed to set the pipeline to PAUSED and PLAYING again.

Parameters:

src – The object originating the message.
clock – the clock that was lost

classmethod new_clock_provide(src: Object | None, clock: Clock, ready: bool) → Message

Create a clock provide message. This message is posted whenever an element is ready to provide a clock or lost its ability to provide a clock (maybe because it paused or became EOS).

This message is mainly used internally to manage the clock selection.

Parameters:

src – The object originating the message.
clock – the clock it provides
ready – True if the sender can provide a clock

classmethod new_custom(type: MessageType, src: Object | None = None, structure: Structure | None = None) → Message

Create a new custom-typed message. This can be used for anything not handled by other message-specific functions to pass a message to the app. The structure field can be None.

Parameters:

type – The MessageType to distinguish messages
src – The object originating the message.
structure – the structure for the message. The message will take ownership of the structure.

classmethod new_device_added(src: Object | None, device: Device) → Message

Creates a new device-added message. The device-added message is produced by DeviceProvider or a DeviceMonitor. They announce the appearance of monitored devices.

Added in version 1.4.

Parameters:

src – The Object that created the message
device – The new Device

classmethod new_device_changed(src: Object | None, device: Device, changed_device: Device) → Message

Creates a new device-changed message. The device-changed message is produced by DeviceProvider or a DeviceMonitor. They announce that a device properties has changed and device represent the new modified version of changed_device.

Added in version 1.16.

Parameters:

src – The Object that created the message
device – The newly created device representing changed_device with its new configuration.
changed_device – The old version of the device.

classmethod new_device_removed(src: Object | None, device: Device) → Message

Creates a new device-removed message. The device-removed message is produced by DeviceProvider or a DeviceMonitor. They announce the disappearance of monitored devices.

Added in version 1.4.

Parameters:

src – The Object that created the message
device – The removed Device

classmethod new_duration_changed(src: Object | None = None) → Message

Create a new duration changed message. This message is posted by elements that know the duration of a stream when the duration changes. This message is received by bins and is used to calculate the total duration of a pipeline.

Parameters:: src – The object originating the message.

classmethod new_element(src: Object | None, structure: Structure) → Message

Create a new element-specific message. This is meant as a generic way of allowing one-way communication from an element to an application, for example “the firewire cable was unplugged”. The format of the message should be documented in the element’s documentation. The structure field can be None.

Parameters:

src – The object originating the message.
structure – The structure for the message. The message will take ownership of the structure.

classmethod new_eos(src: Object | None = None) → Message

Create a new eos message. This message is generated and posted in the sink elements of a GstBin. The bin will only forward the EOS message to the application if all sinks have posted an EOS message.

Parameters:: src – The object originating the message.

classmethod new_error(src: Object | None, error: GError, debug: str) → Message

Create a new error message. The message will copy error and debug. This message is posted by element when a fatal event occurred. The pipeline will probably (partially) stop. The application receiving this message should stop the pipeline.

Parameters:

src – The object originating the message.
error – The GError for this message.
debug – A debugging string.

classmethod new_error_with_details(src: Object | None, error: GError, debug: str, details: Structure | None = None) → Message

Added in version 1.10.

Parameters:

src – The object originating the message.
error – The GError for this message.
debug – A debugging string.
details – A GstStructure with details

classmethod new_have_context(src: Object | None, context: Context) → Message

This message is posted when an element has a new local Context.

Added in version 1.2.

Parameters:

src – The object originating the message.
context – the context

classmethod new_info(src: Object | None, error: GError, debug: str) → Message

Create a new info message. The message will make copies of error and debug.

Parameters:

src – The object originating the message.
error – The GError for this message.
debug – A debugging string.

classmethod new_info_with_details(src: Object | None, error: GError, debug: str, details: Structure | None = None) → Message

Create a new info message. The message will make copies of error and debug.

Added in version 1.10.

Parameters:

src – The object originating the message.
error – The GError for this message.
debug – A debugging string.
details – A GstStructure with details

classmethod new_instant_rate_request(src: Object | None, rate_multiplier: float) → Message

Creates a new instant-rate-request message. Elements handling the instant-rate-change event must post this message. The message is handled at the pipeline, and allows the pipeline to select the running time when the rate change should happen and to send an GST_EVENT_INSTANT_RATE_SYNC_TIME event to notify the elements in the pipeline.

Added in version 1.18.

Parameters:

src – The Object that posted the message
rate_multiplier – the rate multiplier factor that should be applied

classmethod new_latency(src: Object | None = None) → Message

This message can be posted by elements when their latency requirements have changed.

Parameters:: src – The object originating the message.

classmethod new_need_context(src: Object | None, context_type: str) → Message

This message is posted when an element needs a specific Context.

Added in version 1.2.

Parameters:

src – The object originating the message.
context_type – The context type that is needed

classmethod new_new_clock(src: Object | None, clock: Clock) → Message

Create a new clock message. This message is posted whenever the pipeline selects a new clock for the pipeline.

Parameters:

src – The object originating the message.
clock – the new selected clock

classmethod new_progress(src: Object | None, type: ProgressType, code: str, text: str) → Message

Progress messages are posted by elements when they use an asynchronous task to perform actions triggered by a state change.

code contains a well defined string describing the action. text should contain a user visible string detailing the current action.

Parameters:

src – The object originating the message.
type – a ProgressType
code – a progress code
text – free, user visible text describing the progress

classmethod new_property_notify(src: Object, property_name: str, val: Any | None = None) → Message

Added in version 1.10.

Parameters:

src – The Object whose property changed (may or may not be a Element)
property_name – name of the property that changed
val – new property value, or None

classmethod new_qos(src: Object | None, live: bool, running_time: int, stream_time: int, timestamp: int, duration: int) → Message

A QOS message is posted on the bus whenever an element decides to drop a buffer because of QoS reasons or whenever it changes its processing strategy because of QoS reasons (quality adjustments such as processing at lower accuracy).

This message can be posted by an element that performs synchronisation against the clock (live) or it could be dropped by an element that performs QoS because of QOS events received from a downstream element (!live).

running_time, stream_time, timestamp, duration should be set to the respective running-time, stream-time, timestamp and duration of the (dropped) buffer that generated the QoS event. Values can be left to GST_CLOCK_TIME_NONE when unknown.

Parameters:

src – The object originating the message.
live – if the message was generated by a live element
running_time – the running time of the buffer that generated the message
stream_time – the stream time of the buffer that generated the message
timestamp – the timestamps of the buffer that generated the message
duration – the duration of the buffer that generated the message

classmethod new_redirect(src: Object | None, location: str, tag_list: TagList | None = None, entry_struct: Structure | None = None) → Message

Creates a new redirect message and adds a new entry to it. Redirect messages are posted when an element detects that the actual data has to be retrieved from a different location. This is useful if such a redirection cannot be handled inside a source element, for example when HTTP 302/303 redirects return a non-HTTP URL.

The redirect message can hold multiple entries. The first one is added when the redirect message is created, with the given location, tag_list, entry_struct arguments. Use add_redirect_entry() to add more entries.

Each entry has a location, a tag list, and a structure. All of these are optional. The tag list and structure are useful for additional metadata, such as bitrate statistics for the given location.

By default, message recipients should treat entries in the order they are stored. The recipient should therefore try entry ``0`` first, and if this entry is not acceptable or working, try entry ``1`` etc. Senders must make sure that they add entries in this order. However, recipients are free to ignore the order and pick an entry that is “best” for them. One example would be a recipient that scans the entries for the one with the highest bitrate tag.

The specified location string is copied. However, ownership over the tag list and structure are transferred to the message.

Added in version 1.10.

Parameters:

src – The Object whose property changed (may or may not be a Element)
location – location string for the new entry
tag_list – tag list for the new entry
entry_struct – structure for the new entry

classmethod new_request_state(src: Object | None, state: State) → Message

This message can be posted by elements when they want to have their state changed. A typical use case would be an audio server that wants to pause the pipeline because a higher priority stream is being played.

Parameters:

src – The object originating the message.
state – The new requested state

classmethod new_reset_time(src: Object | None, running_time: int) → Message

This message is posted when the pipeline running-time should be reset to running_time, like after a flushing seek.

Parameters:

src – The object originating the message.
running_time – the requested running-time

classmethod new_segment_done(src: Object | None, format: Format, position: int) → Message

Create a new segment done message. This message is posted by elements that finish playback of a segment as a result of a segment seek. This message is received by the application after all elements that posted a segment_start have posted the segment_done.

Parameters:

src – The object originating the message.
format – The format of the position being done
position – The position of the segment being done

classmethod new_segment_start(src: Object | None, format: Format, position: int) → Message

Create a new segment message. This message is posted by elements that start playback of a segment as a result of a segment seek. This message is not received by the application but is used for maintenance reasons in container elements.

Parameters:

src – The object originating the message.
format – The format of the position being played
position – The position of the segment being played

classmethod new_state_changed(src: Object | None, oldstate: State, newstate: State, pending: State) → Message

Create a state change message. This message is posted whenever an element changed its state.

Parameters:

src – The object originating the message.
oldstate – the previous state
newstate – the new (current) state
pending – the pending (target) state

classmethod new_state_dirty(src: Object | None = None) → Message

Create a state dirty message. This message is posted whenever an element changed its state asynchronously and is used internally to update the states of container objects.

Parameters:: src – The object originating the message

classmethod new_step_done(src: Object | None, format: Format, amount: int, rate: float, flush: bool, intermediate: bool, duration: int, eos: bool) → Message

This message is posted by elements when they complete a part, when intermediate set to True, or a complete step operation.

duration will contain the amount of time (in GST_FORMAT_TIME) of the stepped amount of media in format format.

Parameters:

src – The object originating the message.
format – the format of amount
amount – the amount of stepped data
rate – the rate of the stepped amount
flush – is this an flushing step
intermediate – is this an intermediate step
duration – the duration of the data
eos – the step caused EOS

classmethod new_step_start(src: Object | None, active: bool, format: Format, amount: int, rate: float, flush: bool, intermediate: bool) → Message

This message is posted by elements when they accept or activate a new step event for amount in format.

active is set to False when the element accepted the new step event and has queued it for execution in the streaming threads.

active is set to True when the element has activated the step operation and is now ready to start executing the step in the streaming thread. After this message is emitted, the application can queue a new step operation in the element.

Parameters:

src – The object originating the message.
active – if the step is active or queued
format – the format of amount
amount – the amount of stepped data
rate – the rate of the stepped amount
flush – is this an flushing step
intermediate – is this an intermediate step

classmethod new_stream_collection(src: Object | None, collection: StreamCollection) → Message

Creates a new stream-collection message. The message is used to announce new StreamCollection

Added in version 1.10.

Parameters:

src – The Object that created the message
collection – The StreamCollection

classmethod new_stream_start(src: Object | None = None) → Message

Create a new stream_start message. This message is generated and posted in the sink elements of a GstBin. The bin will only forward the STREAM_START message to the application if all sinks have posted an STREAM_START message.

Parameters:: src – The object originating the message.

classmethod new_stream_status(src: Object | None, type: StreamStatusType, owner: Element) → Message

Create a new stream status message. This message is posted when a streaming thread is created/destroyed or when the state changed.

Parameters:

src – The object originating the message.
type – The stream status type.
owner – the owner element of src.

classmethod new_streams_selected(src: Object | None, collection: StreamCollection) → Message

Creates a new steams-selected message. The message is used to announce that an array of streams has been selected. This is generally in response to a GST_EVENT_SELECT_STREAMS event, or when an element (such as decodebin3) makes an initial selection of streams.

The message also contains the StreamCollection to which the various streams belong to.

Users of new_streams_selected() can add the selected streams with streams_selected_add().

Added in version 1.10.

Parameters:

src – The Object that created the message
collection – The StreamCollection

classmethod new_structure_change(src: Object | None, type: StructureChangeType, owner: Element, busy: bool) → Message

Create a new structure change message. This message is posted when the structure of a pipeline is in the process of being changed, for example when pads are linked or unlinked.

src should be the sinkpad that unlinked or linked.

Parameters:

src – The object originating the message.
type – The change type.
owner – The owner element of src.
busy – Whether the structure change is busy.

classmethod new_tag(src: Object | None, tag_list: TagList) → Message

Create a new tag message. The message will take ownership of the tag list. The message is posted by elements that discovered a new taglist.

Parameters:

src – The object originating the message.
tag_list – the tag list for the message.

classmethod new_toc(src: Object | None, toc: Toc, updated: bool) → Message

Create a new TOC message. The message is posted by elements that discovered or updated a TOC.

Parameters:

src – the object originating the message.
toc – Toc structure for the message.
updated – whether TOC was updated or not.

classmethod new_warning(src: Object | None, error: GError, debug: str) → Message

Create a new warning message. The message will make copies of error and debug.

Parameters:

src – The object originating the message.
error – The GError for this message.
debug – A debugging string.

classmethod new_warning_with_details(src: Object | None, error: GError, debug: str, details: Structure | None = None) → Message

Create a new warning message. The message will make copies of error and debug.

Added in version 1.10.

Parameters:

src – The object originating the message.
error – The GError for this message.
debug – A debugging string.
details – A GstStructure with details

Methods

class Message

add_redirect_entry(location: str, tag_list: TagList | None = None, entry_struct: Structure | None = None) → None

Creates and appends a new entry.

The specified location string is copied. However, ownership over the tag list and structure are transferred to the message.

Added in version 1.10.

Parameters:

location – location string for the new entry
tag_list – tag list for the new entry
entry_struct – structure for the new entry

get_num_redirect_entries() → int: Added in version 1.10.

get_seqnum() → int

Retrieve the sequence number of a message.

Messages have ever-incrementing sequence numbers, which may also be set explicitly via set_seqnum(). Sequence numbers are typically used to indicate that a message corresponds to some other set of messages or events, for example a SEGMENT_DONE message corresponding to a SEEK event. It is considered good practice to make this correspondence when possible, though it is not required.

Note that events and messages share the same sequence number incrementor; two events or messages will never have the same sequence number unless that correspondence was made explicitly.

get_stream_status_object() → Any | None: Extracts the object managing the streaming thread from message.

get_structure() → Structure | None: Access the structure of the message.

has_name(name: str) → bool

Checks if message has the given name. This function is usually used to check the name of a custom message.

Parameters:: name – name to check

parse_async_done() → int

Extract the running_time from the async_done message.

MT safe.

parse_buffering() → int

Extracts the buffering percent from the GstMessage. see also new_buffering().

MT safe.

parse_buffering_stats() → tuple[BufferingMode, int, int, int]: Extracts the buffering stats values from message.

parse_clock_lost() → Clock

Extracts the lost clock from the GstMessage. The clock object returned remains valid until the message is freed.

MT safe.

parse_clock_provide() → tuple[Clock, bool]

Extracts the clock and ready flag from the GstMessage. The clock object returned remains valid until the message is freed.

MT safe.

parse_context_type() → tuple[bool, str]: Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.

Added in version 1.2.

parse_device_added() → Device: Parses a device-added message. The device-added message is produced by DeviceProvider or a DeviceMonitor. It announces the appearance of monitored devices.

Added in version 1.4.

parse_device_changed() → tuple[Device, Device]: Parses a device-changed message. The device-changed message is produced by DeviceProvider or a DeviceMonitor. It announces the disappearance of monitored devices. * It announce that a device properties has changed and device represents the new modified version of changed_device.

Added in version 1.16.

parse_device_removed() → Device: Parses a device-removed message. The device-removed message is produced by DeviceProvider or a DeviceMonitor. It announces the disappearance of monitored devices.

Added in version 1.4.

parse_error() → tuple[GError, str]

Extracts the GError and debug string from the GstMessage. The values returned in the output arguments are copies; the caller must free them when done.

Typical usage of this function might be:

...
switch (GST_MESSAGE_TYPE (msg)) {
  case GST_MESSAGE_ERROR: {
    GError *err = NULL;
    gchar *dbg_info = NULL;

    gst_message_parse_error (msg, &err, &dbg_info);
    g_printerr ("ERROR from element ``%s``: ``%s``\n",
        GST_OBJECT_NAME (msg->src), err->message);
    g_printerr ("Debugging info: ``%s``\n", (dbg_info) ? dbg_info : "none");
    g_error_free (err);
    g_free (dbg_info);
    break;
  }
  ...
}
...

MT safe.

parse_error_details() → Structure: Returns the optional details structure, may be NULL if none. The returned structure must not be freed.

Added in version 1.10.

parse_group_id() → tuple[bool, int]: Extract the group from the STREAM_START message.

Added in version 1.2.

parse_have_context() → Context

Extract the context from the HAVE_CONTEXT message.

MT safe.

Added in version 1.2.

parse_info() → tuple[GError, str]

Extracts the GError and debug string from the GstMessage. The values returned in the output arguments are copies; the caller must free them when done.

MT safe.

parse_info_details() → Structure: Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Added in version 1.10.

parse_instant_rate_request() → float: Parses the rate_multiplier from the instant-rate-request message.

Added in version 1.18.

parse_new_clock() → Clock

Extracts the new clock from the GstMessage. The clock object returned remains valid until the message is freed.

MT safe.

parse_progress() → tuple[ProgressType, str, str]: Parses the progress type, code and text.

parse_property_notify() → tuple[Object, str, Any]: Parses a property-notify message. These will be posted on the bus only when set up with add_property_notify_watch() or add_property_deep_notify_watch().

Added in version 1.10.

parse_qos() → tuple[bool, int, int, int, int]

Extract the timestamps and live status from the QoS message.

The returned values give the running_time, stream_time, timestamp and duration of the dropped buffer. Values of GST_CLOCK_TIME_NONE mean unknown values.

MT safe.

parse_qos_stats() → tuple[Format, int, int]

Extract the QoS stats representing the history of the current continuous pipeline playback period.

When format is GST_FORMAT_UNDEFINED both dropped and processed are invalid. Values of -1 for either processed or dropped mean unknown values.

MT safe.

parse_qos_values() → tuple[int, float, int]

Extract the QoS values that have been calculated/analysed from the QoS data

MT safe.

parse_redirect_entry(entry_index: int) → tuple[str, TagList, Structure]

Parses the location and/or structure from the entry with the given index. The index must be between 0 and get_num_redirect_entries() - 1. Returned pointers are valid for as long as this message exists.

Added in version 1.10.

Parameters:: entry_index – index of the entry to parse

parse_request_state() → State

Extract the requested state from the request_state message.

MT safe.

parse_reset_time() → int

Extract the running-time from the RESET_TIME message.

MT safe.

parse_segment_done() → tuple[Format, int]

Extracts the position and format from the segment done message.

MT safe.

parse_segment_start() → tuple[Format, int]

Extracts the position and format from the segment start message.

MT safe.

parse_state_changed() → tuple[State, State, State]

Extracts the old and new states from the GstMessage.

Typical usage of this function might be:

...
switch (GST_MESSAGE_TYPE (msg)) {
  case GST_MESSAGE_STATE_CHANGED: {
    GstState old_state, new_state;

    gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
    g_print ("Element ``%s`` changed state from ``%s`` to ``%s``.\n",
        GST_OBJECT_NAME (msg->src),
        gst_element_state_get_name (old_state),
        gst_element_state_get_name (new_state));
    break;
  }
  ...
}
...

MT safe.

parse_step_done() → tuple[Format, int, float, bool, bool, int, bool]

Extract the values the step_done message.

MT safe.

parse_step_start() → tuple[bool, Format, int, float, bool, bool]

Extract the values from step_start message.

MT safe.

parse_stream_collection() → StreamCollection: Parses a stream-collection message.

Added in version 1.10.

parse_stream_status() → tuple[StreamStatusType, Element]

Extracts the stream status type and owner the GstMessage. The returned owner remains valid for as long as the reference to message is valid and should thus not be unreffed.

MT safe.

parse_streams_selected() → StreamCollection: Parses a streams-selected message.

Added in version 1.10.

parse_structure_change() → tuple[StructureChangeType, Element, bool]

Extracts the change type and completion status from the GstMessage.

MT safe.

parse_tag() → TagList

Extracts the tag list from the GstMessage. The tag list returned in the output argument is a copy; the caller must free it when done.

Typical usage of this function might be:

...
switch (GST_MESSAGE_TYPE (msg)) {
  case GST_MESSAGE_TAG: {
    GstTagList *tags = NULL;

    gst_message_parse_tag (msg, &tags);
    g_print ("Got tags from element ``%s``\n", GST_OBJECT_NAME (msg->src));
    handle_tags (tags);
    gst_tag_list_unref (tags);
    break;
  }
  ...
}
...

MT safe.

parse_toc() → tuple[Toc, bool]

Extract the TOC from the Message. The TOC returned in the output argument is a copy; the caller must free it with toc_unref() when done.

MT safe.

parse_warning() → tuple[GError, str]

Extracts the GError and debug string from the GstMessage. The values returned in the output arguments are copies; the caller must free them when done.

MT safe.

parse_warning_details() → Structure: Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Added in version 1.10.

set_buffering_stats(mode: BufferingMode, avg_in: int, avg_out: int, buffering_left: int) → None

Configures the buffering stats values in message.

Parameters:

mode – a buffering mode
avg_in – the average input rate
avg_out – the average output rate
buffering_left – amount of buffering time left in milliseconds

set_group_id(group_id: int) → None

Sets the group id on the stream-start message.

All streams that have the same group id are supposed to be played together, i.e. all streams inside a container file should have the same group id but different stream ids. The group id should change each time the stream is started, resulting in different group ids each time a file is played for example.

MT safe.

Added in version 1.2.

Parameters:: group_id – the group id

set_qos_stats(format: Format, processed: int, dropped: int) → None

Set the QoS stats representing the history of the current continuous pipeline playback period.

When format is GST_FORMAT_UNDEFINED both dropped and processed are invalid. Values of -1 for either processed or dropped mean unknown values.

MT safe.

Parameters:

format – Units of the ‘processed’ and ‘dropped’ fields. Video sinks and video filters will use GST_FORMAT_BUFFERS (frames). Audio sinks and audio filters will likely use GST_FORMAT_DEFAULT (samples).
processed – Total number of units correctly processed since the last state change to READY or a flushing operation.
dropped – Total number of units dropped since the last state change to READY or a flushing operation.

set_qos_values(jitter: int, proportion: float, quality: int) → None

Set the QoS values that have been calculated/analysed from the QoS data

MT safe.

Parameters:

jitter – The difference of the running-time against the deadline.
proportion – Long term prediction of the ideal rate relative to normal rate to get optimal quality.
quality – An element dependent integer value that specifies the current quality level of the element. The default maximum quality is 1000000.

set_seqnum(seqnum: int) → None

Set the sequence number of a message.

This function might be called by the creator of a message to indicate that the message relates to other messages or events. See get_seqnum() for more information.

MT safe.

Parameters:: seqnum – A sequence number.

set_stream_status_object(object: Any) → None

Configures the object handling the streaming thread. This is usually a GstTask object but other objects might be added in the future.

Parameters:: object – the object controlling the streaming

streams_selected_add(stream: Stream) → None

Adds the stream to the message.

Added in version 1.10.

Parameters:: stream – a Stream to add to message

streams_selected_get_size() → int: Returns the number of streams contained in the message.

Added in version 1.10.

streams_selected_get_stream(idx: int) → Stream | None

Retrieves the Stream with index index from the message.

Added in version 1.10.

Parameters:: idx – Index of the stream to retrieve

writable_structure() → Structure: Get a writable version of the structure.

Added in version 1.14.

Fields

class Message

cond

lock

mini_object: The parent structure

seqnum: The sequence number of the message

src: The src of the message

timestamp: The timestamp of the message

type: The MessageType of the message