GstMessage

Gst.Message

Gst.Message.prototype.new_application

function Gst.Message.prototype.new_application(src: Gst.Object, structure: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_application'
}

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

Gst.Message.prototype.new_async_done

function Gst.Message.prototype.new_async_done(src: Gst.Object, running_time: Number): {
    // javascript wrapper for 'gst_message_new_async_done'
}

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.

Gst.Message.prototype.new_async_start

function Gst.Message.prototype.new_async_start(src: Gst.Object): {
    // javascript wrapper for 'gst_message_new_async_start'
}

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

Gst.Message.prototype.new_buffering

function Gst.Message.prototype.new_buffering(src: Gst.Object, percent: Number): {
    // javascript wrapper for 'gst_message_new_buffering'
}

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.

Gst.Message.prototype.new_clock_lost

function Gst.Message.prototype.new_clock_lost(src: Gst.Object, clock: Gst.Clock): {
    // javascript wrapper for 'gst_message_new_clock_lost'
}

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.

Gst.Message.prototype.new_clock_provide

function Gst.Message.prototype.new_clock_provide(src: Gst.Object, clock: Gst.Clock, ready: Number): {
    // javascript wrapper for 'gst_message_new_clock_provide'
}

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.

Gst.Message.prototype.new_custom

function Gst.Message.prototype.new_custom(type: Gst.MessageType, src: Gst.Object, structure: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_custom'
}

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 null.

Gst.Message.prototype.new_device_added

function Gst.Message.prototype.new_device_added(src: Gst.Object, device: Gst.Device): {
    // javascript wrapper for 'gst_message_new_device_added'
}

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

Since : 1.4

Gst.Message.prototype.new_device_changed

function Gst.Message.prototype.new_device_changed(src: Gst.Object, device: Gst.Device, changed_device: Gst.Device): {
    // javascript wrapper for 'gst_message_new_device_changed'
}

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

Since : 1.16

Gst.Message.prototype.new_device_removed

function Gst.Message.prototype.new_device_removed(src: Gst.Object, device: Gst.Device): {
    // javascript wrapper for 'gst_message_new_device_removed'
}

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

Since : 1.4

Gst.Message.prototype.new_duration_changed

function Gst.Message.prototype.new_duration_changed(src: Gst.Object): {
    // javascript wrapper for 'gst_message_new_duration_changed'
}

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.

Gst.Message.prototype.new_element

function Gst.Message.prototype.new_element(src: Gst.Object, structure: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_element'
}

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 null.

Gst.Message.prototype.new_eos

function Gst.Message.prototype.new_eos(src: Gst.Object): {
    // javascript wrapper for 'gst_message_new_eos'
}

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.

Gst.Message.prototype.new_error

function Gst.Message.prototype.new_error(src: Gst.Object, error: GError (not introspectable), debug: String): {
    // javascript wrapper for 'gst_message_new_error'
}

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.

Gst.Message.prototype.new_error_with_details

function Gst.Message.prototype.new_error_with_details(src: Gst.Object, error: GError (not introspectable), debug: String, details: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_error_with_details'
}

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.

Since : 1.10

Gst.Message.prototype.new_have_context

function Gst.Message.prototype.new_have_context(src: Gst.Object, context: Gst.Context): {
    // javascript wrapper for 'gst_message_new_have_context'
}

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

Since : 1.2

Gst.Message.prototype.new_info

function Gst.Message.prototype.new_info(src: Gst.Object, error: GError (not introspectable), debug: String): {
    // javascript wrapper for 'gst_message_new_info'
}

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

Gst.Message.prototype.new_info_with_details

function Gst.Message.prototype.new_info_with_details(src: Gst.Object, error: GError (not introspectable), debug: String, details: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_info_with_details'
}

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

Since : 1.10

Gst.Message.prototype.new_instant_rate_request

function Gst.Message.prototype.new_instant_rate_request(src: Gst.Object, rate_multiplier: Number): {
    // javascript wrapper for 'gst_message_new_instant_rate_request'
}

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.

Since : 1.18

Gst.Message.prototype.new_latency

function Gst.Message.prototype.new_latency(src: Gst.Object): {
    // javascript wrapper for 'gst_message_new_latency'
}

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

Gst.Message.prototype.new_need_context

function Gst.Message.prototype.new_need_context(src: Gst.Object, context_type: String): {
    // javascript wrapper for 'gst_message_new_need_context'
}

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

Since : 1.2

Gst.Message.prototype.new_new_clock

function Gst.Message.prototype.new_new_clock(src: Gst.Object, clock: Gst.Clock): {
    // javascript wrapper for 'gst_message_new_new_clock'
}

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

Gst.Message.prototype.new_progress

function Gst.Message.prototype.new_progress(src: Gst.Object, type: Gst.ProgressType, code: String, text: String): {
    // javascript wrapper for 'gst_message_new_progress'
}

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.

Gst.Message.prototype.new_property_notify

function Gst.Message.prototype.new_property_notify(src: Gst.Object, property_name: String, val: GObject.Value): {
    // javascript wrapper for 'gst_message_new_property_notify'
}

Since : 1.10

Gst.Message.prototype.new_qos

function Gst.Message.prototype.new_qos(src: Gst.Object, live: Number, running_time: Number, stream_time: Number, timestamp: Number, duration: Number): {
    // javascript wrapper for 'gst_message_new_qos'
}

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.

Gst.Message.prototype.new_redirect

function Gst.Message.prototype.new_redirect(src: Gst.Object, location: String, tag_list: Gst.TagList, entry_struct: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_redirect'
}

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 Gst.Message.prototype.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.

Since : 1.10

Gst.Message.prototype.new_request_state

function Gst.Message.prototype.new_request_state(src: Gst.Object, state: Gst.State): {
    // javascript wrapper for 'gst_message_new_request_state'
}

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.

Gst.Message.prototype.new_reset_time

function Gst.Message.prototype.new_reset_time(src: Gst.Object, running_time: Number): {
    // javascript wrapper for 'gst_message_new_reset_time'
}

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

Gst.Message.prototype.new_segment_done

function Gst.Message.prototype.new_segment_done(src: Gst.Object, format: Gst.Format, position: Number): {
    // javascript wrapper for 'gst_message_new_segment_done'
}

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.

Gst.Message.prototype.new_segment_start

function Gst.Message.prototype.new_segment_start(src: Gst.Object, format: Gst.Format, position: Number): {
    // javascript wrapper for 'gst_message_new_segment_start'
}

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.

Gst.Message.prototype.new_state_changed

function Gst.Message.prototype.new_state_changed(src: Gst.Object, oldstate: Gst.State, newstate: Gst.State, pending: Gst.State): {
    // javascript wrapper for 'gst_message_new_state_changed'
}

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

Gst.Message.prototype.new_state_dirty

function Gst.Message.prototype.new_state_dirty(src: Gst.Object): {
    // javascript wrapper for 'gst_message_new_state_dirty'
}

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.

Gst.Message.prototype.new_step_done

function Gst.Message.prototype.new_step_done(src: Gst.Object, format: Gst.Format, amount: Number, rate: Number, flush: Number, intermediate: Number, duration: Number, eos: Number): {
    // javascript wrapper for 'gst_message_new_step_done'
}

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.

Gst.Message.prototype.new_step_start

function Gst.Message.prototype.new_step_start(src: Gst.Object, active: Number, format: Gst.Format, amount: Number, rate: Number, flush: Number, intermediate: Number): {
    // javascript wrapper for 'gst_message_new_step_start'
}

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.

Gst.Message.prototype.new_stream_collection

function Gst.Message.prototype.new_stream_collection(src: Gst.Object, collection: Gst.StreamCollection): {
    // javascript wrapper for 'gst_message_new_stream_collection'
}

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

Since : 1.10

Gst.Message.prototype.new_stream_start

function Gst.Message.prototype.new_stream_start(src: Gst.Object): {
    // javascript wrapper for 'gst_message_new_stream_start'
}

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.

Gst.Message.prototype.new_stream_status

function Gst.Message.prototype.new_stream_status(src: Gst.Object, type: Gst.StreamStatusType, owner: Gst.Element): {
    // javascript wrapper for 'gst_message_new_stream_status'
}

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

Gst.Message.prototype.new_streams_selected

function Gst.Message.prototype.new_streams_selected(src: Gst.Object, collection: Gst.StreamCollection): {
    // javascript wrapper for 'gst_message_new_streams_selected'
}

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.EventType.SELECT_STREAMS event, or when an element (such as decodebin3) makes an initial selection of streams.

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

Users of Gst.Message.prototype.new_streams_selected can add the selected streams with Gst.Message.prototype.streams_selected_add.

Since : 1.10

Gst.Message.prototype.new_structure_change

function Gst.Message.prototype.new_structure_change(src: Gst.Object, type: Gst.StructureChangeType, owner: Gst.Element, busy: Number): {
    // javascript wrapper for 'gst_message_new_structure_change'
}

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.

Gst.Message.prototype.new_tag

function Gst.Message.prototype.new_tag(src: Gst.Object, tag_list: Gst.TagList): {
    // javascript wrapper for 'gst_message_new_tag'
}

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.

Gst.Message.prototype.new_toc

function Gst.Message.prototype.new_toc(src: Gst.Object, toc: Gst.Toc, updated: Number): {
    // javascript wrapper for 'gst_message_new_toc'
}

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

Gst.Message.prototype.new_warning

function Gst.Message.prototype.new_warning(src: Gst.Object, error: GError (not introspectable), debug: String): {
    // javascript wrapper for 'gst_message_new_warning'
}

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

Gst.Message.prototype.new_warning_with_details

function Gst.Message.prototype.new_warning_with_details(src: Gst.Object, error: GError (not introspectable), debug: String, details: Gst.Structure): {
    // javascript wrapper for 'gst_message_new_warning_with_details'
}

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

Since : 1.10

Gst.Message.prototype.add_redirect_entry

function Gst.Message.prototype.add_redirect_entry(location: String, tag_list: Gst.TagList, entry_struct: Gst.Structure): {
    // javascript wrapper for 'gst_message_add_redirect_entry'
}

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.

Since : 1.10

Gst.Message.prototype.get_details

function Gst.Message.prototype.get_details(): {
    // javascript wrapper for 'gst_message_get_details'
}

Returns the optional details structure of the message. May be NULL if none.

The returned structure must not be freed.

Since : 1.26

Gst.Message.prototype.get_num_redirect_entries

function Gst.Message.prototype.get_num_redirect_entries(): {
    // javascript wrapper for 'gst_message_get_num_redirect_entries'
}

Since : 1.10

Gst.Message.prototype.get_seqnum

function Gst.Message.prototype.get_seqnum(): {
    // javascript wrapper for 'gst_message_get_seqnum'
}

Retrieve the sequence number of a message.

Messages have ever-incrementing sequence numbers, which may also be set explicitly via Gst.Message.prototype.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.

Gst.Message.prototype.get_stream_status_object

function Gst.Message.prototype.get_stream_status_object(): {
    // javascript wrapper for 'gst_message_get_stream_status_object'
}

Extracts the object managing the streaming thread from message.

Gst.Message.prototype.get_structure

function Gst.Message.prototype.get_structure(): {
    // javascript wrapper for 'gst_message_get_structure'
}

Access the structure of the message.

Gst.Message.prototype.has_name

function Gst.Message.prototype.has_name(name: String): {
    // javascript wrapper for 'gst_message_has_name'
}

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

Gst.Message.prototype.parse_async_done

function Gst.Message.prototype.parse_async_done(): {
    // javascript wrapper for 'gst_message_parse_async_done'
}

Extract the running_time from the async_done message.

MT safe.

Gst.Message.prototype.parse_buffering

function Gst.Message.prototype.parse_buffering(): {
    // javascript wrapper for 'gst_message_parse_buffering'
}

Extracts the buffering percent from the GstMessage. see also Gst.Message.prototype.new_buffering.

MT safe.

Gst.Message.prototype.parse_buffering_stats

function Gst.Message.prototype.parse_buffering_stats(): {
    // javascript wrapper for 'gst_message_parse_buffering_stats'
}

Extracts the buffering stats values from message.

Gst.Message.prototype.parse_clock_lost

function Gst.Message.prototype.parse_clock_lost(): {
    // javascript wrapper for 'gst_message_parse_clock_lost'
}

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

MT safe.

Gst.Message.prototype.parse_clock_provide

function Gst.Message.prototype.parse_clock_provide(): {
    // javascript wrapper for 'gst_message_parse_clock_provide'
}

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

MT safe.