# GstMessage

Messages are implemented as a subclass of GstMiniObject with a generic GstStructure 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 GstBus.

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

       gst_bus_post (bus, gst_message_new_eos());

A GstElement usually posts messages on the bus provided by the parent container using gst_element_post_message.

## GstMessage

A GstMessage.

### Members

`mini_object` (GstMiniObject) –

the parent structure

`type` (GstMessageType) –

the GstMessageType of the message

`timestamp` (guint64) –

the timestamp of the message

`src` (GstObject *) –

the src of the message

`seqnum` (guint32) –

the sequence number of the message

## Gst.Message

A Gst.Message.

### Members

`mini_object` (Gst.MiniObject) –

the parent structure

`type` (Gst.MessageType) –

the Gst.MessageType of the message

`timestamp` (Number) –

the timestamp of the message

`src` (Gst.Object) –

the src of the message

`seqnum` (Number) –

the sequence number of the message

## Gst.Message

A Gst.Message.

### Members

`mini_object` (Gst.MiniObject) –

the parent structure

`type` (Gst.MessageType) –

the Gst.MessageType of the message

`timestamp` (int) –

the timestamp of the message

`src` (Gst.Object) –

the src of the message

`seqnum` (int) –

the sequence number of the message

### Constructors

#### gst_message_new_application

    GstMessage *
    gst_message_new_application (GstObject * src,
                                 GstStructure * structure)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`structure` ( [transfer: full]) –

the structure for the message. The message will take ownership of the structure.

Returns ( [transfer: full]) –

The new application message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`structure` (Gst.Structure) –

the structure for the message. The message will take ownership of the structure.

Returns (Gst.Message) –

The new application message.

MT safe.

#### Gst.Message.new_application

    def Gst.Message.new_application (src, structure):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`structure` (Gst.Structure) –

the structure for the message. The message will take ownership of the structure.

Returns (Gst.Message) –

The new application message.

MT safe.

#### gst_message_new_async_done

    GstMessage *
    gst_message_new_async_done (GstObject * src,
                                GstClockTime running_time)

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` ( [transfer: none][nullable]) –

The object originating the message.

`running_time` –

the desired running_time

Returns ( [transfer: full]) –

The new async_done message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`running_time` (Number) –

the desired running_time

Returns (Gst.Message) –

The new async_done message.

MT safe.

#### Gst.Message.new_async_done

    def Gst.Message.new_async_done (src, running_time):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`running_time` (int) –

the desired running_time

Returns (Gst.Message) –

The new async_done message.

MT safe.

#### gst_message_new_async_start

    GstMessage *
    gst_message_new_async_start (GstObject * src)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

Returns ( [transfer: full]) –

The new async_start message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new async_start message.

MT safe.

#### Gst.Message.new_async_start

    def Gst.Message.new_async_start (src):
        #python wrapper for 'gst_message_new_async_start'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new async_start message.

MT safe.

#### gst_message_new_buffering

    GstMessage *
    gst_message_new_buffering (GstObject * src,
                               gint percent)

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` ( [transfer: none][nullable]) –

The object originating the message.

`percent` –

The buffering percent

Returns ( [transfer: full]) –

The new buffering message.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`percent` (Number) –

The buffering percent

Returns (Gst.Message) –

The new buffering message.

#### Gst.Message.new_buffering

    def Gst.Message.new_buffering (src, percent):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`percent` (int) –

The buffering percent

Returns (Gst.Message) –

The new buffering message.

#### gst_message_new_clock_lost

    GstMessage *
    gst_message_new_clock_lost (GstObject * src,
                                GstClock * clock)

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` ( [transfer: none][nullable]) –

The object originating the message.

`clock` ( [transfer: none]) –

the clock that was lost

Returns ( [transfer: full]) –

The new clock lost message.

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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`clock` (Gst.Clock) –

the clock that was lost

Returns (Gst.Message) –

The new clock lost message.

MT safe.

#### Gst.Message.new_clock_lost

    def Gst.Message.new_clock_lost (src, clock):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`clock` (Gst.Clock) –

the clock that was lost

Returns (Gst.Message) –

The new clock lost message.

MT safe.

#### gst_message_new_clock_provide

    GstMessage *
    gst_message_new_clock_provide (GstObject * src,
                                   GstClock * clock,
                                   gboolean ready)

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` ( [transfer: none][nullable]) –

The object originating the message.

`clock` ( [transfer: none]) –

the clock it provides

`ready` –

TRUE if the sender can provide a clock

Returns ( [transfer: full]) –

the new provide clock message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`clock` (Gst.Clock) –

the clock it provides

`ready` (Number) –

true if the sender can provide a clock

Returns (Gst.Message) –

the new provide clock message.

MT safe.

#### Gst.Message.new_clock_provide

    def Gst.Message.new_clock_provide (src, clock, ready):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`clock` (Gst.Clock) –

the clock it provides

`ready` (bool) –

True if the sender can provide a clock

Returns (Gst.Message) –

the new provide clock message.

MT safe.

#### gst_message_new_custom

    GstMessage *
    gst_message_new_custom (GstMessageType type,
                            GstObject * src,
                            GstStructure * structure)

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.

Parameters:

`type` –

The GstMessageType to distinguish messages

`src` ( [transfer: none][nullable]) –

The object originating the message.

`structure` ( [transfer: full][nullable]) –

the structure for the message. The message will take ownership of the structure.

Returns ( [transfer: full]) –

The new message.

MT safe.

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

Parameters:

`type` (Gst.MessageType) –

The Gst.MessageType to distinguish messages

`src` (Gst.Object) –

The object originating the message.

`structure` (Gst.Structure) –

the structure for the message. The message will take ownership of the structure.

Returns (Gst.Message) –

The new message.

MT safe.

#### Gst.Message.new_custom

    def Gst.Message.new_custom (type, src, structure):
        #python 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 None.

Parameters:

`type` (Gst.MessageType) –

The Gst.MessageType to distinguish messages

`src` (Gst.Object) –

The object originating the message.

`structure` (Gst.Structure) –

the structure for the message. The message will take ownership of the structure.

Returns (Gst.Message) –

The new message.

MT safe.

#### gst_message_new_device_added

    GstMessage *
    gst_message_new_device_added (GstObject * src,
                                  GstDevice * device)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that created the message

`device` ( [transfer: none]) –

The new GstDevice

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.4

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

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`device` (Gst.Device) –

The new Gst.Device

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.4

#### Gst.Message.new_device_added

    def Gst.Message.new_device_added (src, device):
        #python 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.

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`device` (Gst.Device) –

The new Gst.Device

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.4

#### gst_message_new_device_changed

    GstMessage *
    gst_message_new_device_changed (GstObject * src,
                                    GstDevice * device,
                                    GstDevice * changed_device)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that created the message

`device` ( [transfer: none]) –

The newly created device representing changed_device with its new configuration.

`changed_device` ( [transfer: none]) –

The old version of the device.

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.16

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

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`device` (Gst.Device) –

The newly created device representing changed_device with its new configuration.

`changed_device` (Gst.Device) –

The old version of the device.

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.16

#### Gst.Message.new_device_changed

    def Gst.Message.new_device_changed (src, device, changed_device):
        #python 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.

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`device` (Gst.Device) –

The newly created device representing changed_device with its new configuration.

`changed_device` (Gst.Device) –

The old version of the device.

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.16

#### gst_message_new_device_monitor_started

    GstMessage *
    gst_message_new_device_monitor_started (GstObject * src,
                                            gboolean success)

Creates a new device-monitor-started message. The device-monitor-started message is produced by a GstDeviceMonitor once it has started probing devices. It does not indicate whether any GstDeviceProvider instances support monitoring at all, only whether at least one was able to start probing.

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that created the message

`success` –

Whether the monitor was started successfully

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.28

#### Gst.Message.prototype.new_device_monitor_started

    function Gst.Message.prototype.new_device_monitor_started(src: Gst.Object, success: Number): {
        // javascript wrapper for 'gst_message_new_device_monitor_started'
    }

Creates a new device-monitor-started message. The device-monitor-started message is produced by a Gst.DeviceMonitor once it has started probing devices. It does not indicate whether any Gst.DeviceProvider instances support monitoring at all, only whether at least one was able to start probing.

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`success` (Number) –

Whether the monitor was started successfully

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.28

#### Gst.Message.new_device_monitor_started

    def Gst.Message.new_device_monitor_started (src, success):
        #python wrapper for 'gst_message_new_device_monitor_started'

Creates a new device-monitor-started message. The device-monitor-started message is produced by a Gst.DeviceMonitor once it has started probing devices. It does not indicate whether any Gst.DeviceProvider instances support monitoring at all, only whether at least one was able to start probing.

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`success` (bool) –

Whether the monitor was started successfully

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.28

#### gst_message_new_device_removed

    GstMessage *
    gst_message_new_device_removed (GstObject * src,
                                    GstDevice * device)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that created the message

`device` ( [transfer: none]) –

The removed GstDevice

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.4

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

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`device` (Gst.Device) –

The removed Gst.Device

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.4

#### Gst.Message.new_device_removed

    def Gst.Message.new_device_removed (src, device):
        #python 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.

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`device` (Gst.Device) –

The removed Gst.Device

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.4

#### gst_message_new_duration_changed

    GstMessage *
    gst_message_new_duration_changed (GstObject * src)

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` ( [transfer: none][nullable]) –

The object originating the message.

Returns ( [transfer: full]) –

The new duration-changed message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new duration-changed message.

MT safe.

#### Gst.Message.new_duration_changed

    def Gst.Message.new_duration_changed (src):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new duration-changed message.

MT safe.

#### gst_message_new_element

    GstMessage *
    gst_message_new_element (GstObject * src,
                             GstStructure * structure)

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.

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`structure` ( [transfer: full]) –

The structure for the message. The message will take ownership of the structure.

Returns ( [transfer: full]) –

The new element message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`structure` (Gst.Structure) –

The structure for the message. The message will take ownership of the structure.

Returns (Gst.Message) –

The new element message.

MT safe.

#### Gst.Message.new_element

    def Gst.Message.new_element (src, structure):
        #python 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 None.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`structure` (Gst.Structure) –

The structure for the message. The message will take ownership of the structure.

Returns (Gst.Message) –

The new element message.

MT safe.

#### gst_message_new_eos

    GstMessage *
    gst_message_new_eos (GstObject * src)

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` ( [transfer: none][nullable]) –

The object originating the message.

Returns ( [transfer: full]) –

The new eos message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new eos message.

MT safe.

#### Gst.Message.new_eos

    def Gst.Message.new_eos (src):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new eos message.

MT safe.

#### gst_message_new_error

    GstMessage *
    gst_message_new_error (GstObject * src,
                           GError * error,
                           const gchar * debug)

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` ( [transfer: none][nullable]) –

The object originating the message.

`error` ( [transfer: none]) –

The GError for this message.

`debug` ( [nullable]) –

A debugging string.

Returns ( [transfer: full]) –

the new error message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (String) –

A debugging string.

Returns (Gst.Message) –

the new error message.

MT safe.

#### Gst.Message.new_error

    def Gst.Message.new_error (src, error, debug):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (str) –

A debugging string.

Returns (Gst.Message) –

the new error message.

MT safe.

#### gst_message_new_error_with_details

    GstMessage *
    gst_message_new_error_with_details (GstObject * src,
                                        GError * error,
                                        const gchar * debug,
                                        GstStructure * 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.

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`error` ( [transfer: none]) –

The GError for this message.

`debug` ( [nullable]) –

A debugging string.

`details` ( [transfer: full][nullable]) –

A GstStructure with details

Returns ( [transfer: full]) –

the new error message.

Since : 1.10

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (String) –

A debugging string.

`details` (Gst.Structure) –

A GstStructure with details

Returns (Gst.Message) –

the new error message.

Since : 1.10

#### Gst.Message.new_error_with_details

    def Gst.Message.new_error_with_details (src, error, debug, details):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (str) –

A debugging string.

`details` (Gst.Structure) –

A GstStructure with details

Returns (Gst.Message) –

the new error message.

Since : 1.10

#### gst_message_new_have_context

    GstMessage *
    gst_message_new_have_context (GstObject * src,
                                  GstContext * context)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`context` ( [transfer: full]) –

the context

Returns ( [transfer: full]) –

The new have-context message.

MT safe.

Since : 1.2

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`context` (Gst.Context) –

the context

Returns (Gst.Message) –

The new have-context message.

MT safe.

Since : 1.2

#### Gst.Message.new_have_context

    def Gst.Message.new_have_context (src, context):
        #python wrapper for 'gst_message_new_have_context'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`context` (Gst.Context) –

the context

Returns (Gst.Message) –

The new have-context message.

MT safe.

Since : 1.2

#### gst_message_new_info

    GstMessage *
    gst_message_new_info (GstObject * src,
                          GError * error,
                          const gchar * debug)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`error` ( [transfer: none]) –

The GError for this message.

`debug` ( [nullable]) –

A debugging string.

Returns ( [transfer: full]) –

the new info message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (String) –

A debugging string.

Returns (Gst.Message) –

the new info message.

MT safe.

#### Gst.Message.new_info

    def Gst.Message.new_info (src, error, debug):
        #python wrapper for 'gst_message_new_info'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (str) –

A debugging string.

Returns (Gst.Message) –

the new info message.

MT safe.

#### gst_message_new_info_with_details

    GstMessage *
    gst_message_new_info_with_details (GstObject * src,
                                       GError * error,
                                       const gchar * debug,
                                       GstStructure * details)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`error` ( [transfer: none]) –

The GError for this message.

`debug` ( [nullable]) –

A debugging string.

`details` ( [transfer: full][nullable]) –

A GstStructure with details

Returns ( [transfer: full]) –

the new warning message.

Since : 1.10

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (String) –

A debugging string.

`details` (Gst.Structure) –

A GstStructure with details

Returns (Gst.Message) –

the new warning message.

Since : 1.10

#### Gst.Message.new_info_with_details

    def Gst.Message.new_info_with_details (src, error, debug, details):
        #python wrapper for 'gst_message_new_info_with_details'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (str) –

A debugging string.

`details` (Gst.Structure) –

A GstStructure with details

Returns (Gst.Message) –

the new warning message.

Since : 1.10

#### gst_message_new_instant_rate_request

    GstMessage *
    gst_message_new_instant_rate_request (GstObject * src,
                                          gdouble rate_multiplier)

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.

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that posted the message

`rate_multiplier` –

the rate multiplier factor that should be applied

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.18

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

Parameters:

`src` (Gst.Object) –

The Gst.Object that posted the message

`rate_multiplier` (Number) –

the rate multiplier factor that should be applied

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.18

#### Gst.Message.new_instant_rate_request

    def Gst.Message.new_instant_rate_request (src, rate_multiplier):
        #python 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.

Parameters:

`src` (Gst.Object) –

The Gst.Object that posted the message

`rate_multiplier` (float) –

the rate multiplier factor that should be applied

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.18

#### gst_message_new_latency

    GstMessage *
    gst_message_new_latency (GstObject * src)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

Returns ( [transfer: full]) –

The new latency message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new latency message.

MT safe.

#### Gst.Message.new_latency

    def Gst.Message.new_latency (src):
        #python wrapper for 'gst_message_new_latency'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new latency message.

MT safe.

#### gst_message_new_need_context

    GstMessage *
    gst_message_new_need_context (GstObject * src,
                                  const gchar * context_type)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`context_type` –

The context type that is needed

Returns ( [transfer: full]) –

The new need-context message.

MT safe.

Since : 1.2

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`context_type` (String) –

The context type that is needed

Returns (Gst.Message) –

The new need-context message.

MT safe.

Since : 1.2

#### Gst.Message.new_need_context

    def Gst.Message.new_need_context (src, context_type):
        #python wrapper for 'gst_message_new_need_context'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`context_type` (str) –

The context type that is needed

Returns (Gst.Message) –

The new need-context message.

MT safe.

Since : 1.2

#### gst_message_new_new_clock

    GstMessage *
    gst_message_new_new_clock (GstObject * src,
                               GstClock * clock)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`clock` ( [transfer: none]) –

the new selected clock

Returns ( [transfer: full]) –

The new new clock message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`clock` (Gst.Clock) –

the new selected clock

Returns (Gst.Message) –

The new new clock message.

MT safe.

#### Gst.Message.new_new_clock

    def Gst.Message.new_new_clock (src, clock):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`clock` (Gst.Clock) –

the new selected clock

Returns (Gst.Message) –

The new new clock message.

MT safe.

#### gst_message_new_progress

    GstMessage *
    gst_message_new_progress (GstObject * src,
                              GstProgressType type,
                              const gchar * code,
                              const gchar * text)

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` ( [transfer: none][nullable]) –

The object originating the message.

`type` –

a GstProgressType

`code` –

a progress code

`text` –

free, user visible text describing the progress

Returns ( [transfer: full]) –

The new qos message.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`type` (Gst.ProgressType) –

a Gst.ProgressType

`code` (String) –

a progress code

`text` (String) –

free, user visible text describing the progress

Returns (Gst.Message) –

The new qos message.

#### Gst.Message.new_progress

    def Gst.Message.new_progress (src, type, code, text):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`type` (Gst.ProgressType) –

a Gst.ProgressType

`code` (str) –

a progress code

`text` (str) –

free, user visible text describing the progress

Returns (Gst.Message) –

The new qos message.

#### gst_message_new_property_notify

    GstMessage *
    gst_message_new_property_notify (GstObject * src,
                                     const gchar * property_name,
                                     GValue * val)

Parameters:

`src` ( [transfer: none]) –

The GstObject whose property changed (may or may not be a GstElement)

`property_name` –

name of the property that changed

`val` ( [nullable][transfer: full]) –

new property value, or NULL

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.10

#### 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'
    }

Parameters:

`src` (Gst.Object) –

The Gst.Object whose property changed (may or may not be a Gst.Element)

`property_name` (String) –

name of the property that changed

`val` (GObject.Value) –

new property value, or null

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### Gst.Message.new_property_notify

    def Gst.Message.new_property_notify (src, property_name, val):
        #python wrapper for 'gst_message_new_property_notify'

Parameters:

`src` (Gst.Object) –

The Gst.Object whose property changed (may or may not be a Gst.Element)

`property_name` (str) –

name of the property that changed

`val` (GObject.Value) –

new property value, or None

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### gst_message_new_qos

    GstMessage *
    gst_message_new_qos (GstObject * src,
                         gboolean live,
                         guint64 running_time,
                         guint64 stream_time,
                         guint64 timestamp,
                         guint64 duration)

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` ( [transfer: none][nullable]) –

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

Returns ( [transfer: full]) –

The new qos message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`live` (Number) –

if the message was generated by a live element

`running_time` (Number) –

the running time of the buffer that generated the message

`stream_time` (Number) –

the stream time of the buffer that generated the message

`timestamp` (Number) –

the timestamps of the buffer that generated the message

`duration` (Number) –

the duration of the buffer that generated the message

Returns (Gst.Message) –

The new qos message.

MT safe.

#### Gst.Message.new_qos

    def Gst.Message.new_qos (src, live, running_time, stream_time, timestamp, duration):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`live` (bool) –

if the message was generated by a live element

`running_time` (int) –

the running time of the buffer that generated the message

`stream_time` (int) –

the stream time of the buffer that generated the message

`timestamp` (int) –

the timestamps of the buffer that generated the message

`duration` (int) –

the duration of the buffer that generated the message

Returns (Gst.Message) –

The new qos message.

MT safe.

#### gst_message_new_redirect

    GstMessage *
    gst_message_new_redirect (GstObject * src,
                              const gchar * location,
                              GstTagList * tag_list,
                              GstStructure * entry_struct)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject whose property changed (may or may not be a GstElement)

`location` ( [transfer: none]) –

location string for the new entry

`tag_list` ( [transfer: full][nullable]) –

tag list for the new entry

`entry_struct` ( [transfer: full][nullable]) –

structure for the new entry

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.10

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

Parameters:

`src` (Gst.Object) –

The Gst.Object whose property changed (may or may not be a Gst.Element)

`location` (String) –

location string for the new entry

`tag_list` (Gst.TagList) –

tag list for the new entry

`entry_struct` (Gst.Structure) –

structure for the new entry

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### Gst.Message.new_redirect

    def Gst.Message.new_redirect (src, location, tag_list, entry_struct):
        #python 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.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.

Parameters:

`src` (Gst.Object) –

The Gst.Object whose property changed (may or may not be a Gst.Element)

`location` (str) –

location string for the new entry

`tag_list` (Gst.TagList) –

tag list for the new entry

`entry_struct` (Gst.Structure) –

structure for the new entry

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### gst_message_new_request_state

    GstMessage *
    gst_message_new_request_state (GstObject * src,
                                   GstState 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.

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`state` –

The new requested state

Returns ( [transfer: full]) –

the new request state message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`state` (Gst.State) –

The new requested state

Returns (Gst.Message) –

the new request state message.

MT safe.

#### Gst.Message.new_request_state

    def Gst.Message.new_request_state (src, state):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`state` (Gst.State) –

The new requested state

Returns (Gst.Message) –

the new request state message.

MT safe.

#### gst_message_new_reset_time

    GstMessage *
    gst_message_new_reset_time (GstObject * src,
                                GstClockTime running_time)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`running_time` –

the requested running-time

Returns ( [transfer: full]) –

The new reset_time message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`running_time` (Number) –

the requested running-time

Returns (Gst.Message) –

The new reset_time message.

MT safe.

#### Gst.Message.new_reset_time

    def Gst.Message.new_reset_time (src, running_time):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`running_time` (int) –

the requested running-time

Returns (Gst.Message) –

The new reset_time message.

MT safe.

#### gst_message_new_segment_done

    GstMessage *
    gst_message_new_segment_done (GstObject * src,
                                  GstFormat format,
                                  gint64 position)

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` ( [transfer: none][nullable]) –

The object originating the message.

`format` –

The format of the position being done

`position` –

The position of the segment being done

Returns ( [transfer: full]) –

the new segment done message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`format` (Gst.Format) –

The format of the position being done

`position` (Number) –

The position of the segment being done

Returns (Gst.Message) –

the new segment done message.

MT safe.

#### Gst.Message.new_segment_done

    def Gst.Message.new_segment_done (src, format, position):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`format` (Gst.Format) –

The format of the position being done

`position` (int) –

The position of the segment being done

Returns (Gst.Message) –

the new segment done message.

MT safe.

#### gst_message_new_segment_start

    GstMessage *
    gst_message_new_segment_start (GstObject * src,
                                   GstFormat format,
                                   gint64 position)

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` ( [transfer: none][nullable]) –

The object originating the message.

`format` –

The format of the position being played

`position` –

The position of the segment being played

Returns ( [transfer: full]) –

the new segment start message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`format` (Gst.Format) –

The format of the position being played

`position` (Number) –

The position of the segment being played

Returns (Gst.Message) –

the new segment start message.

MT safe.

#### Gst.Message.new_segment_start

    def Gst.Message.new_segment_start (src, format, position):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`format` (Gst.Format) –

The format of the position being played

`position` (int) –

The position of the segment being played

Returns (Gst.Message) –

the new segment start message.

MT safe.

#### gst_message_new_state_changed

    GstMessage *
    gst_message_new_state_changed (GstObject * src,
                                   GstState oldstate,
                                   GstState newstate,
                                   GstState pending)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`oldstate` –

the previous state

`newstate` –

the new (current) state

`pending` –

the pending (target) state

Returns ( [transfer: full]) –

the new state change message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`oldstate` (Gst.State) –

the previous state

`newstate` (Gst.State) –

the new (current) state

`pending` (Gst.State) –

the pending (target) state

Returns (Gst.Message) –

the new state change message.

MT safe.

#### Gst.Message.new_state_changed

    def Gst.Message.new_state_changed (src, oldstate, newstate, pending):
        #python wrapper for 'gst_message_new_state_changed'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`oldstate` (Gst.State) –

the previous state

`newstate` (Gst.State) –

the new (current) state

`pending` (Gst.State) –

the pending (target) state

Returns (Gst.Message) –

the new state change message.

MT safe.

#### gst_message_new_state_dirty

    GstMessage *
    gst_message_new_state_dirty (GstObject * src)

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` ( [transfer: none][nullable]) –

The object originating the message

Returns ( [transfer: full]) –

the new state dirty message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message

Returns (Gst.Message) –

the new state dirty message.

MT safe.

#### Gst.Message.new_state_dirty

    def Gst.Message.new_state_dirty (src):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message

Returns (Gst.Message) –

the new state dirty message.

MT safe.

#### gst_message_new_step_done

    GstMessage *
    gst_message_new_step_done (GstObject * src,
                               GstFormat format,
                               guint64 amount,
                               gdouble rate,
                               gboolean flush,
                               gboolean intermediate,
                               guint64 duration,
                               gboolean eos)

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` ( [transfer: none][nullable]) –

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

Returns ( [transfer: full]) –

the new step_done message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`format` (Gst.Format) –

the format of amount

`amount` (Number) –

the amount of stepped data

`rate` (Number) –

the rate of the stepped amount

`flush` (Number) –

is this an flushing step

`intermediate` (Number) –

is this an intermediate step

`duration` (Number) –

the duration of the data

`eos` (Number) –

the step caused EOS

Returns (Gst.Message) –

the new step_done message.

MT safe.

#### Gst.Message.new_step_done

    def Gst.Message.new_step_done (src, format, amount, rate, flush, intermediate, duration, eos):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`format` (Gst.Format) –

the format of amount

`amount` (int) –

the amount of stepped data

`rate` (float) –

the rate of the stepped amount

`flush` (bool) –

is this an flushing step

`intermediate` (bool) –

is this an intermediate step

`duration` (int) –

the duration of the data

`eos` (bool) –

the step caused EOS

Returns (Gst.Message) –

the new step_done message.

MT safe.

#### gst_message_new_step_start

    GstMessage *
    gst_message_new_step_start (GstObject * src,
                                gboolean active,
                                GstFormat format,
                                guint64 amount,
                                gdouble rate,
                                gboolean flush,
                                gboolean intermediate)

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` ( [transfer: none][nullable]) –

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

Returns ( [transfer: full]) –

The new step_start message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`active` (Number) –

if the step is active or queued

`format` (Gst.Format) –

the format of amount

`amount` (Number) –

the amount of stepped data

`rate` (Number) –

the rate of the stepped amount

`flush` (Number) –

is this an flushing step

`intermediate` (Number) –

is this an intermediate step

Returns (Gst.Message) –

The new step_start message.

MT safe.

#### Gst.Message.new_step_start

    def Gst.Message.new_step_start (src, active, format, amount, rate, flush, intermediate):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`active` (bool) –

if the step is active or queued

`format` (Gst.Format) –

the format of amount

`amount` (int) –

the amount of stepped data

`rate` (float) –

the rate of the stepped amount

`flush` (bool) –

is this an flushing step

`intermediate` (bool) –

is this an intermediate step

Returns (Gst.Message) –

The new step_start message.

MT safe.

#### gst_message_new_stream_collection

    GstMessage *
    gst_message_new_stream_collection (GstObject * src,
                                       GstStreamCollection * collection)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that created the message

`collection` ( [transfer: none]) –

The GstStreamCollection

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.10

#### 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

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`collection` (Gst.StreamCollection) –

The Gst.StreamCollection

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### Gst.Message.new_stream_collection

    def Gst.Message.new_stream_collection (src, collection):
        #python wrapper for 'gst_message_new_stream_collection'

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

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`collection` (Gst.StreamCollection) –

The Gst.StreamCollection

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### gst_message_new_stream_start

    GstMessage *
    gst_message_new_stream_start (GstObject * src)

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` ( [transfer: none][nullable]) –

The object originating the message.

Returns ( [transfer: full]) –

The new stream_start message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new stream_start message.

MT safe.

#### Gst.Message.new_stream_start

    def Gst.Message.new_stream_start (src):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

Returns (Gst.Message) –

The new stream_start message.

MT safe.

#### gst_message_new_stream_status

    GstMessage *
    gst_message_new_stream_status (GstObject * src,
                                   GstStreamStatusType type,
                                   GstElement * owner)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`type` –

The stream status type.

`owner` ( [transfer: none]) –

the owner element of src.

Returns ( [transfer: full]) –

the new stream status message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`type` (Gst.StreamStatusType) –

The stream status type.

`owner` (Gst.Element) –

the owner element of src.

Returns (Gst.Message) –

the new stream status message.

MT safe.

#### Gst.Message.new_stream_status

    def Gst.Message.new_stream_status (src, type, owner):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`type` (Gst.StreamStatusType) –

The stream status type.

`owner` (Gst.Element) –

the owner element of src.

Returns (Gst.Message) –

the new stream status message.

MT safe.

#### gst_message_new_streams_selected

    GstMessage *
    gst_message_new_streams_selected (GstObject * src,
                                      GstStreamCollection * collection)

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 GstStreamCollection to which the various streams belong to.

Users of gst_message_new_streams_selected can add the selected streams with gst_message_streams_selected_add.

Parameters:

`src` ( [transfer: none][nullable]) –

The GstObject that created the message

`collection` ( [transfer: none]) –

The GstStreamCollection

Returns ( [transfer: full]) –

a newly allocated GstMessage

Since : 1.10

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

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`collection` (Gst.StreamCollection) –

The Gst.StreamCollection

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### Gst.Message.new_streams_selected

    def Gst.Message.new_streams_selected (src, collection):
        #python 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.new_streams_selected can add the selected streams with Gst.Message.streams_selected_add.

Parameters:

`src` (Gst.Object) –

The Gst.Object that created the message

`collection` (Gst.StreamCollection) –

The Gst.StreamCollection

Returns (Gst.Message) –

a newly allocated Gst.Message

Since : 1.10

#### gst_message_new_structure_change

    GstMessage *
    gst_message_new_structure_change (GstObject * src,
                                      GstStructureChangeType type,
                                      GstElement * owner,
                                      gboolean busy)

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` ( [transfer: none][nullable]) –

The object originating the message.

`type` –

The change type.

`owner` ( [transfer: none]) –

The owner element of src.

`busy` –

Whether the structure change is busy.

Returns ( [transfer: full]) –

the new structure change message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`type` (Gst.StructureChangeType) –

The change type.

`owner` (Gst.Element) –

The owner element of src.

`busy` (Number) –

Whether the structure change is busy.

Returns (Gst.Message) –

the new structure change message.

MT safe.

#### Gst.Message.new_structure_change

    def Gst.Message.new_structure_change (src, type, owner, busy):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`type` (Gst.StructureChangeType) –

The change type.

`owner` (Gst.Element) –

The owner element of src.

`busy` (bool) –

Whether the structure change is busy.

Returns (Gst.Message) –

the new structure change message.

MT safe.

#### gst_message_new_tag

    GstMessage *
    gst_message_new_tag (GstObject * src,
                         GstTagList * tag_list)

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` ( [transfer: none][nullable]) –

The object originating the message.

`tag_list` ( [transfer: full]) –

the tag list for the message.

Returns ( [transfer: full]) –

the new tag message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`tag_list` (Gst.TagList) –

the tag list for the message.

Returns (Gst.Message) –

the new tag message.

MT safe.

#### Gst.Message.new_tag

    def Gst.Message.new_tag (src, tag_list):
        #python 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.

Parameters:

`src` (Gst.Object) –

The object originating the message.

`tag_list` (Gst.TagList) –

the tag list for the message.

Returns (Gst.Message) –

the new tag message.

MT safe.

#### gst_message_new_warning

    GstMessage *
    gst_message_new_warning (GstObject * src,
                             GError * error,
                             const gchar * debug)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`error` ( [transfer: none]) –

The GError for this message.

`debug` ( [nullable]) –

A debugging string.

Returns ( [transfer: full]) –

the new warning message.

MT safe.

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (String) –

A debugging string.

Returns (Gst.Message) –

the new warning message.

MT safe.

#### Gst.Message.new_warning

    def Gst.Message.new_warning (src, error, debug):
        #python wrapper for 'gst_message_new_warning'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (str) –

A debugging string.

Returns (Gst.Message) –

the new warning message.

MT safe.

#### gst_message_new_warning_with_details

    GstMessage *
    gst_message_new_warning_with_details (GstObject * src,
                                          GError * error,
                                          const gchar * debug,
                                          GstStructure * details)

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

Parameters:

`src` ( [transfer: none][nullable]) –

The object originating the message.

`error` ( [transfer: none]) –

The GError for this message.

`debug` ( [nullable]) –

A debugging string.

`details` ( [transfer: full][nullable]) –

A GstStructure with details

Returns ( [transfer: full]) –

the new warning message.

Since : 1.10

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (String) –

A debugging string.

`details` (Gst.Structure) –

A GstStructure with details

Returns (Gst.Message) –

the new warning message.

Since : 1.10

#### Gst.Message.new_warning_with_details

    def Gst.Message.new_warning_with_details (src, error, debug, details):
        #python wrapper for 'gst_message_new_warning_with_details'

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

Parameters:

`src` (Gst.Object) –

The object originating the message.

`error` (GError (not introspectable)) –

The GError for this message.

`debug` (str) –

A debugging string.

`details` (Gst.Structure) –

A GstStructure with details

Returns (Gst.Message) –

the new warning message.

Since : 1.10

### Methods

#### gst_message_add_redirect_entry

    gst_message_add_redirect_entry (GstMessage * message,
                                    const gchar * location,
                                    GstTagList * tag_list,
                                    GstStructure * entry_struct)

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.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_REDIRECT

`location` ( [transfer: none]) –

location string for the new entry

`tag_list` ( [transfer: full][nullable]) –

tag list for the new entry

`entry_struct` ( [transfer: full][nullable]) –

structure for the new entry

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.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.REDIRECT

`location` (String) –

location string for the new entry

`tag_list` (Gst.TagList) –

tag list for the new entry

`entry_struct` (Gst.Structure) –

structure for the new entry

Since : 1.10

#### Gst.Message.add_redirect_entry

    def Gst.Message.add_redirect_entry (self, location, tag_list, entry_struct):
        #python 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.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.REDIRECT

`location` (str) –

location string for the new entry

`tag_list` (Gst.TagList) –

tag list for the new entry

`entry_struct` (Gst.Structure) –

structure for the new entry

Since : 1.10

#### gst_message_copy

    GstMessage *
    gst_message_copy (const GstMessage * msg)

Creates a copy of the message. Returns a copy of the message.

Parameters:

`msg` –

the message to copy

Returns ( [transfer: full]) –

a new copy of msg.

MT safe

#### gst_message_get_details

    const GstStructure *
    gst_message_get_details (GstMessage * message)

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

The returned structure must not be freed.

Parameters:

`message` –

A GstMessage

Returns ( [transfer: none][nullable]) –

The details, or NULL if none.

Since : 1.26

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

Parameters:

`message` (Gst.Message) –

A Gst.Message

Returns (Gst.Structure) –

The details, or NULL if none.

Since : 1.26

#### Gst.Message.get_details

    def Gst.Message.get_details (self):
        #python 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.

Parameters:

`message` (Gst.Message) –

A Gst.Message

Returns (Gst.Structure) –

The details, or NULL if none.

Since : 1.26

#### gst_message_get_num_redirect_entries

    gsize
    gst_message_get_num_redirect_entries (GstMessage * message)

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_REDIRECT

Returns –

the number of entries stored in the message

Since : 1.10

#### Gst.Message.prototype.get_num_redirect_entries

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

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.REDIRECT

Returns (Number) –

the number of entries stored in the message

Since : 1.10

#### Gst.Message.get_num_redirect_entries

    def Gst.Message.get_num_redirect_entries (self):
        #python wrapper for 'gst_message_get_num_redirect_entries'

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.REDIRECT

Returns (int) –

the number of entries stored in the message

Since : 1.10

#### gst_message_get_seqnum

    guint32
    gst_message_get_seqnum (GstMessage * message)

Retrieve the sequence number of a message.

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

Parameters:

`message` –

A GstMessage.

Returns –

The message's sequence number.

MT safe.

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

Parameters:

`message` (Gst.Message) –

A Gst.Message.

Returns (Number) –

The message's sequence number.

MT safe.

#### Gst.Message.get_seqnum

    def Gst.Message.get_seqnum (self):
        #python 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.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.

Parameters:

`message` (Gst.Message) –

A Gst.Message.

Returns (int) –

The message's sequence number.

MT safe.

#### gst_message_get_stream_status_object

    const GValue *
    gst_message_get_stream_status_object (GstMessage * message)

Extracts the object managing the streaming thread from message.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STREAM_STATUS.

Returns ( [nullable]) –

a GValue containing the object that manages the streaming thread. This object is usually of type GstTask but other types can be added in the future. The object remains valid as long as message is valid.

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_STATUS.

Returns (GObject.Value) –

a GValue containing the object that manages the streaming thread. This object is usually of type GstTask but other types can be added in the future. The object remains valid as long as message is valid.

#### Gst.Message.get_stream_status_object

    def Gst.Message.get_stream_status_object (self):
        #python wrapper for 'gst_message_get_stream_status_object'

Extracts the object managing the streaming thread from message.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_STATUS.

Returns (GObject.Value) –

a GValue containing the object that manages the streaming thread. This object is usually of type GstTask but other types can be added in the future. The object remains valid as long as message is valid.

#### gst_message_get_structure

    const GstStructure *
    gst_message_get_structure (GstMessage * message)

Access the structure of the message.

Parameters:

`message` –

The GstMessage.

Returns ( [transfer: none][nullable]) –

The structure of the message. The structure is still owned by the message, which means that you should not free it and that the pointer becomes invalid when you free the message.

MT safe.

#### Gst.Message.prototype.get_structure

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

Access the structure of the message.

Parameters:

`message` (Gst.Message) –

The Gst.Message.

Returns (Gst.Structure) –

The structure of the message. The structure is still owned by the message, which means that you should not free it and that the pointer becomes invalid when you free the message.

MT safe.

#### Gst.Message.get_structure

    def Gst.Message.get_structure (self):
        #python wrapper for 'gst_message_get_structure'

Access the structure of the message.

Parameters:

`message` (Gst.Message) –

The Gst.Message.

Returns (Gst.Structure) –

The structure of the message. The structure is still owned by the message, which means that you should not free it and that the pointer becomes invalid when you free the message.

MT safe.

#### gst_message_has_name

    gboolean
    gst_message_has_name (GstMessage * message,
                          const gchar * name)

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

Parameters:

`message` –

The GstMessage.

`name` –

name to check

Returns –

TRUE if name matches the name of the message structure.

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

Parameters:

`message` (Gst.Message) –

The Gst.Message.

`name` (String) –

name to check

Returns (Number) –

true if name matches the name of the message structure.

#### Gst.Message.has_name

    def Gst.Message.has_name (self, name):
        #python 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.

Parameters:

`message` (Gst.Message) –

The Gst.Message.

`name` (str) –

name to check

Returns (bool) –

True if name matches the name of the message structure.

#### gst_message_is_writable

    gboolean
    gst_message_is_writable (const GstMessage * message)

Tests if you can safely modify message. It is only safe to modify message when there is only one owner of the message - ie, the object is writable.

Parameters:

`message` –

a GstMessage

Returns –
No description available

#### Gst.Message.prototype.is_writable

    function Gst.Message.prototype.is_writable(): {
        // javascript wrapper for 'gst_message_is_writable'
    }

Tests if you can safely modify message. It is only safe to modify message when there is only one owner of the message - ie, the object is writable.

Parameters:

`message` (Gst.Message) –

a Gst.Message

Returns (Number) –
No description available

#### Gst.Message.is_writable

    def Gst.Message.is_writable (self):
        #python wrapper for 'gst_message_is_writable'

Tests if you can safely modify message. It is only safe to modify message when there is only one owner of the message - ie, the object is writable.

Parameters:

`message` (Gst.Message) –

a Gst.Message

Returns (bool) –
No description available

#### gst_message_make_writable

    GstMessage *
    gst_message_make_writable (GstMessage * message)

Returns a writable copy of message.

If there is only one reference count on message, the caller must be the owner, and so this function will return the message object unchanged. If on the other hand there is more than one reference on the object, a new message object will be returned. The caller's reference on message will be removed, and instead the caller will own a reference to the returned object.

In short, this function unrefs the message in the argument and refs the message that it returns. Don't access the argument after calling this function. See also: gst_message_ref.

Parameters:

`message` ( [transfer: full]) –

a GstMessage

Returns ( [transfer: full]) –

a writable message which may or may not be the same as message

#### Gst.Message.prototype.make_writable

    function Gst.Message.prototype.make_writable(): {
        // javascript wrapper for 'gst_message_make_writable'
    }

Returns a writable copy of message.

If there is only one reference count on message, the caller must be the owner, and so this function will return the message object unchanged. If on the other hand there is more than one reference on the object, a new message object will be returned. The caller's reference on message will be removed, and instead the caller will own a reference to the returned object.

In short, this function unrefs the message in the argument and refs the message that it returns. Don't access the argument after calling this function. See also: gst_message_ref (not introspectable).

Parameters:

`message` (Gst.Message) –

a Gst.Message

Returns (Gst.Message) –

a writable message which may or may not be the same as message

#### Gst.Message.make_writable

    def Gst.Message.make_writable (self):
        #python wrapper for 'gst_message_make_writable'

Returns a writable copy of message.

If there is only one reference count on message, the caller must be the owner, and so this function will return the message object unchanged. If on the other hand there is more than one reference on the object, a new message object will be returned. The caller's reference on message will be removed, and instead the caller will own a reference to the returned object.

In short, this function unrefs the message in the argument and refs the message that it returns. Don't access the argument after calling this function. See also: gst_message_ref (not introspectable).

Parameters:

`message` (Gst.Message) –

a Gst.Message

Returns (Gst.Message) –

a writable message which may or may not be the same as message

#### gst_message_parse_async_done

    gst_message_parse_async_done (GstMessage * message,
                                  GstClockTime * running_time)

Extract the running_time from the async_done message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_ASYNC_DONE.

`running_time` ( [out][optional]) –

Result location for the running_time or NULL

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_ASYNC_DONE.

#### Gst.Message.parse_async_done

    def Gst.Message.parse_async_done (self):
        #python wrapper for 'gst_message_parse_async_done'

Extract the running_time from the async_done message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_ASYNC_DONE.

#### gst_message_parse_buffering

    gst_message_parse_buffering (GstMessage * message,
                                 gint * percent)

Extracts the buffering percent from the GstMessage. see also gst_message_new_buffering.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_BUFFERING.

`percent` ( [out][optional]) –

Return location for the percent.

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_BUFFERING.

#### Gst.Message.parse_buffering

    def Gst.Message.parse_buffering (self):
        #python wrapper for 'gst_message_parse_buffering'

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_BUFFERING.

#### gst_message_parse_buffering_stats

    gst_message_parse_buffering_stats (GstMessage * message,
                                       GstBufferingMode * mode,
                                       gint * avg_in,
                                       gint * avg_out,
                                       gint64 * buffering_left)

Extracts the buffering stats values from message.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_BUFFERING.

`mode` ( [out][optional]) –

a buffering mode, or NULL

`avg_in` ( [out][optional]) –

the average input rate, or NULL

`avg_out` ( [out][optional]) –

the average output rate, or NULL

`buffering_left` ( [out][optional]) –

amount of buffering time left in milliseconds, or NULL

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_BUFFERING.

#### Gst.Message.parse_buffering_stats

    def Gst.Message.parse_buffering_stats (self):
        #python wrapper for 'gst_message_parse_buffering_stats'

Extracts the buffering stats values from message.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_BUFFERING.

#### gst_message_parse_clock_lost

    gst_message_parse_clock_lost (GstMessage * message,
                                  GstClock ** clock)

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

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_CLOCK_LOST.

`clock` ( [out][optional][transfer: none]) –

a pointer to hold the lost clock

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_CLOCK_LOST.

#### Gst.Message.parse_clock_lost

    def Gst.Message.parse_clock_lost (self):
        #python 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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_CLOCK_LOST.

#### gst_message_parse_clock_provide

    gst_message_parse_clock_provide (GstMessage * message,
                                     GstClock ** clock,
                                     gboolean * ready)

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

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_CLOCK_PROVIDE.

`clock` ( [out][optional][transfer: none]) –

a pointer to hold a clock object, or NULL

`ready` ( [out][optional]) –

a pointer to hold the ready flag, or NULL

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_CLOCK_PROVIDE.

#### Gst.Message.parse_clock_provide

    def Gst.Message.parse_clock_provide (self):
        #python 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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_CLOCK_PROVIDE.

#### gst_message_parse_context_type

    gboolean
    gst_message_parse_context_type (GstMessage * message,
                                    const gchar ** context_type)

Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.

Parameters:

`message` –

a GST_MESSAGE_NEED_CONTEXT type message

`context_type` ( [out][transfer: none][optional]) –

the context type, or NULL

Returns –

a gboolean indicating if the parsing succeeded.

Since : 1.2

#### Gst.Message.prototype.parse_context_type

    function Gst.Message.prototype.parse_context_type(): {
        // javascript wrapper for 'gst_message_parse_context_type'
    }

Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.

Parameters:

`message` (Gst.Message) –

a GST_MESSAGE_NEED_CONTEXT type message

Returns a tuple made of:

(Number ) –

a Number indicating if the parsing succeeded.

`context_type` (String ) –

a Number indicating if the parsing succeeded.

Since : 1.2

#### Gst.Message.parse_context_type

    def Gst.Message.parse_context_type (self):
        #python wrapper for 'gst_message_parse_context_type'

Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.

Parameters:

`message` (Gst.Message) –

a GST_MESSAGE_NEED_CONTEXT type message

Returns a tuple made of:

(bool ) –

a bool indicating if the parsing succeeded.

`context_type` (str ) –

a bool indicating if the parsing succeeded.

Since : 1.2

#### gst_message_parse_device_added

    gst_message_parse_device_added (GstMessage * message,
                                    GstDevice ** device)

Parses a device-added message. The device-added message is produced by GstDeviceProvider or a GstDeviceMonitor. It announces the appearance of monitored devices.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_DEVICE_ADDED

`device` ( [out][optional][transfer: full]) –

A location where to store a pointer to the new GstDevice, or NULL

Since : 1.4

#### Gst.Message.prototype.parse_device_added

    function Gst.Message.prototype.parse_device_added(): {
        // javascript wrapper for 'gst_message_parse_device_added'
    }

Parses a device-added message. The device-added message is produced by Gst.DeviceProvider or a Gst.DeviceMonitor. It announces the appearance of monitored devices.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_ADDED

Since : 1.4

#### Gst.Message.parse_device_added

    def Gst.Message.parse_device_added (self):
        #python wrapper for 'gst_message_parse_device_added'

Parses a device-added message. The device-added message is produced by Gst.DeviceProvider or a Gst.DeviceMonitor. It announces the appearance of monitored devices.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_ADDED

Since : 1.4

#### gst_message_parse_device_changed

    gst_message_parse_device_changed (GstMessage * message,
                                      GstDevice ** device,
                                      GstDevice ** changed_device)

Parses a device-changed message. The device-changed message is produced by GstDeviceProvider or a GstDeviceMonitor. 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.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_DEVICE_CHANGED

`device` ( [out][optional][transfer: full]) –

A location where to store a pointer to the updated version of the GstDevice, or NULL

`changed_device` ( [out][optional][transfer: full]) –

A location where to store a pointer to the old version of the GstDevice, or NULL

Since : 1.16

#### Gst.Message.prototype.parse_device_changed

    function Gst.Message.prototype.parse_device_changed(): {
        // javascript wrapper for 'gst_message_parse_device_changed'
    }

Parses a device-changed message. The device-changed message is produced by Gst.DeviceProvider or a Gst.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.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_CHANGED

Since : 1.16

#### Gst.Message.parse_device_changed

    def Gst.Message.parse_device_changed (self):
        #python wrapper for 'gst_message_parse_device_changed'

Parses a device-changed message. The device-changed message is produced by Gst.DeviceProvider or a Gst.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.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_CHANGED

Since : 1.16

#### gst_message_parse_device_monitor_started

    gst_message_parse_device_monitor_started (GstMessage * message,
                                              gboolean * success)

Parses a device-monitor-started message. The device-monitor-started message is produced by a GstDeviceMonitor once at least one GstDeviceProvider successfully starts probing.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_DEVICE_MONITOR_STARTED

`success` ( [out]) –

Result location for whether the GstDeviceMonitor was successfully started

Since : 1.28

#### Gst.Message.prototype.parse_device_monitor_started

    function Gst.Message.prototype.parse_device_monitor_started(): {
        // javascript wrapper for 'gst_message_parse_device_monitor_started'
    }

Parses a device-monitor-started message. The device-monitor-started message is produced by a Gst.DeviceMonitor once at least one Gst.DeviceProvider successfully starts probing.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_MONITOR_STARTED

Since : 1.28

#### Gst.Message.parse_device_monitor_started

    def Gst.Message.parse_device_monitor_started (self):
        #python wrapper for 'gst_message_parse_device_monitor_started'

Parses a device-monitor-started message. The device-monitor-started message is produced by a Gst.DeviceMonitor once at least one Gst.DeviceProvider successfully starts probing.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_MONITOR_STARTED

Since : 1.28

#### gst_message_parse_device_removed

    gst_message_parse_device_removed (GstMessage * message,
                                      GstDevice ** device)

Parses a device-removed message. The device-removed message is produced by GstDeviceProvider or a GstDeviceMonitor. It announces the disappearance of monitored devices.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_DEVICE_REMOVED

`device` ( [out][optional][transfer: full]) –

A location where to store a pointer to the removed GstDevice, or NULL

Since : 1.4

#### Gst.Message.prototype.parse_device_removed

    function Gst.Message.prototype.parse_device_removed(): {
        // javascript wrapper for 'gst_message_parse_device_removed'
    }

Parses a device-removed message. The device-removed message is produced by Gst.DeviceProvider or a Gst.DeviceMonitor. It announces the disappearance of monitored devices.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_REMOVED

Since : 1.4

#### Gst.Message.parse_device_removed

    def Gst.Message.parse_device_removed (self):
        #python wrapper for 'gst_message_parse_device_removed'

Parses a device-removed message. The device-removed message is produced by Gst.DeviceProvider or a Gst.DeviceMonitor. It announces the disappearance of monitored devices.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.DEVICE_REMOVED

Since : 1.4

#### gst_message_parse_error

    gst_message_parse_error (GstMessage * message,
                             GError ** gerror,
                             gchar ** debug)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_ERROR.

`gerror` ( [out][optional][transfer: full]) –

location for the GError

`debug` ( [out][optional][nullable][transfer: full]) –

location for the debug message, or NULL

#### Gst.Message.prototype.parse_error

    function Gst.Message.prototype.parse_error(): {
        // javascript wrapper for 'gst_message_parse_error'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_ERROR.

#### Gst.Message.parse_error

    def Gst.Message.parse_error (self):
        #python wrapper for 'gst_message_parse_error'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_ERROR.

#### gst_message_parse_error_details

    gst_message_parse_error_details (GstMessage * message,
                                     const GstStructure ** structure)

Returns the optional details structure, may be NULL if none. The returned structure must not be freed.

Parameters:

`message` –

The message object

`structure` ( [optional][nullable][transfer: none][out]) –

A pointer to the returned details

Since : 1.10

#### Gst.Message.prototype.parse_error_details

    function Gst.Message.prototype.parse_error_details(): {
        // javascript wrapper for 'gst_message_parse_error_details'
    }

Returns the optional details structure, may be NULL if none. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The message object

Since : 1.10

#### Gst.Message.parse_error_details

    def Gst.Message.parse_error_details (self):
        #python wrapper for 'gst_message_parse_error_details'

Returns the optional details structure, may be NULL if none. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The message object

Since : 1.10

#### gst_message_parse_error_writable_details

    gst_message_parse_error_writable_details (GstMessage * message,
                                              GstStructure ** structure)

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` –

The writable message object

`structure` ( [optional][nullable][transfer: none][out]) –

A pointer to the returned details

Since : 1.26

#### Gst.Message.prototype.parse_error_writable_details

    function Gst.Message.prototype.parse_error_writable_details(): {
        // javascript wrapper for 'gst_message_parse_error_writable_details'
    }

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The writable message object

Since : 1.26

#### Gst.Message.parse_error_writable_details

    def Gst.Message.parse_error_writable_details (self):
        #python wrapper for 'gst_message_parse_error_writable_details'

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The writable message object

Since : 1.26

#### gst_message_parse_group_id

    gboolean
    gst_message_parse_group_id (GstMessage * message,
                                guint * group_id)

Extract the group from the STREAM_START message.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STREAM_START.

`group_id` ( [out][optional]) –

Result location for the group id or NULL

Returns –

TRUE if the message had a group id set, FALSE otherwise

MT safe.

Since : 1.2

#### Gst.Message.prototype.parse_group_id

    function Gst.Message.prototype.parse_group_id(): {
        // javascript wrapper for 'gst_message_parse_group_id'
    }

Extract the group from the STREAM_START message.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_START.

Returns a tuple made of:

(Number ) –

true if the message had a group id set, false otherwise

MT safe.

`group_id` (Number ) –

true if the message had a group id set, false otherwise

MT safe.

Since : 1.2

#### Gst.Message.parse_group_id

    def Gst.Message.parse_group_id (self):
        #python wrapper for 'gst_message_parse_group_id'

Extract the group from the STREAM_START message.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_START.

Returns a tuple made of:

(bool ) –

True if the message had a group id set, False otherwise

MT safe.

`group_id` (int ) –

True if the message had a group id set, False otherwise

MT safe.

Since : 1.2

#### gst_message_parse_have_context

    gst_message_parse_have_context (GstMessage * message,
                                    GstContext ** context)

Extract the context from the HAVE_CONTEXT message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_HAVE_CONTEXT.

`context` ( [out][transfer: full][optional]) –

Result location for the context or NULL

Since : 1.2

#### Gst.Message.prototype.parse_have_context

    function Gst.Message.prototype.parse_have_context(): {
        // javascript wrapper for 'gst_message_parse_have_context'
    }

Extract the context from the HAVE_CONTEXT message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_HAVE_CONTEXT.

Since : 1.2

#### Gst.Message.parse_have_context

    def Gst.Message.parse_have_context (self):
        #python wrapper for 'gst_message_parse_have_context'

Extract the context from the HAVE_CONTEXT message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_HAVE_CONTEXT.

Since : 1.2

#### gst_message_parse_info

    gst_message_parse_info (GstMessage * message,
                            GError ** gerror,
                            gchar ** debug)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_INFO.

`gerror` ( [out][optional][transfer: full]) –

location for the GError

`debug` ( [out][optional][nullable][transfer: full]) –

location for the debug message, or NULL

#### Gst.Message.prototype.parse_info

    function Gst.Message.prototype.parse_info(): {
        // javascript wrapper for 'gst_message_parse_info'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_INFO.

#### Gst.Message.parse_info

    def Gst.Message.parse_info (self):
        #python wrapper for 'gst_message_parse_info'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_INFO.

#### gst_message_parse_info_details

    gst_message_parse_info_details (GstMessage * message,
                                    const GstStructure ** structure)

Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Parameters:

`message` –

The message object

`structure` ( [optional][nullable][transfer: none][out]) –

A pointer to the returned details

Since : 1.10

#### Gst.Message.prototype.parse_info_details

    function Gst.Message.prototype.parse_info_details(): {
        // javascript wrapper for 'gst_message_parse_info_details'
    }

Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The message object

Since : 1.10

#### Gst.Message.parse_info_details

    def Gst.Message.parse_info_details (self):
        #python wrapper for 'gst_message_parse_info_details'

Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The message object

Since : 1.10

#### gst_message_parse_info_writable_details

    gst_message_parse_info_writable_details (GstMessage * message,
                                             GstStructure ** structure)

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` –

The writable message object

`structure` ( [optional][nullable][transfer: none][out]) –

A pointer to the returned details

Since : 1.26

#### Gst.Message.prototype.parse_info_writable_details

    function Gst.Message.prototype.parse_info_writable_details(): {
        // javascript wrapper for 'gst_message_parse_info_writable_details'
    }

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The writable message object

Since : 1.26

#### Gst.Message.parse_info_writable_details

    def Gst.Message.parse_info_writable_details (self):
        #python wrapper for 'gst_message_parse_info_writable_details'

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The writable message object

Since : 1.26

#### gst_message_parse_instant_rate_request

    gst_message_parse_instant_rate_request (GstMessage * message,
                                            gdouble * rate_multiplier)

Parses the rate_multiplier from the instant-rate-request message.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_INSTANT_RATE_REQUEST

`rate_multiplier` ( [out][optional]) –

return location for the rate, or NULL

Since : 1.18

#### Gst.Message.prototype.parse_instant_rate_request

    function Gst.Message.prototype.parse_instant_rate_request(): {
        // javascript wrapper for 'gst_message_parse_instant_rate_request'
    }

Parses the rate_multiplier from the instant-rate-request message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.INSTANT_RATE_REQUEST

Since : 1.18

#### Gst.Message.parse_instant_rate_request

    def Gst.Message.parse_instant_rate_request (self):
        #python wrapper for 'gst_message_parse_instant_rate_request'

Parses the rate_multiplier from the instant-rate-request message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.INSTANT_RATE_REQUEST

Since : 1.18

#### gst_message_parse_new_clock

    gst_message_parse_new_clock (GstMessage * message,
                                 GstClock ** clock)

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

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_NEW_CLOCK.

`clock` ( [out][optional][transfer: none]) –

a pointer to hold the selected new clock

#### Gst.Message.prototype.parse_new_clock

    function Gst.Message.prototype.parse_new_clock(): {
        // javascript wrapper for 'gst_message_parse_new_clock'
    }

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_NEW_CLOCK.

#### Gst.Message.parse_new_clock

    def Gst.Message.parse_new_clock (self):
        #python wrapper for 'gst_message_parse_new_clock'

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_NEW_CLOCK.

#### gst_message_parse_progress

    gst_message_parse_progress (GstMessage * message,
                                GstProgressType * type,
                                gchar ** code,
                                gchar ** text)

Parses the progress type, code and text.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_PROGRESS.

`type` ( [out][optional]) –

location for the type

`code` ( [out][optional][transfer: full]) –

location for the code

`text` ( [out][optional][transfer: full]) –

location for the text

#### Gst.Message.prototype.parse_progress

    function Gst.Message.prototype.parse_progress(): {
        // javascript wrapper for 'gst_message_parse_progress'
    }

Parses the progress type, code and text.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_PROGRESS.

#### Gst.Message.parse_progress

    def Gst.Message.parse_progress (self):
        #python wrapper for 'gst_message_parse_progress'

Parses the progress type, code and text.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_PROGRESS.

#### gst_message_parse_property_notify

    gst_message_parse_property_notify (GstMessage * message,
                                       GstObject ** object,
                                       const gchar ** property_name,
                                       const GValue ** property_value)

Parses a property-notify message. These will be posted on the bus only when set up with gst_element_add_property_notify_watch or gst_element_add_property_deep_notify_watch.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_PROPERTY_NOTIFY

`object` ( [out][optional][transfer: none]) –

location where to store a pointer to the object whose property got changed, or NULL

`property_name` ( [out][transfer: none][optional]) –

return location for the name of the property that got changed, or NULL

`property_value` ( [out][transfer: none][optional][nullable]) –

return location for the new value of the property that got changed, or NULL. This will only be set if the property notify watch was told to include the value when it was set up

Since : 1.10

#### Gst.Message.prototype.parse_property_notify

    function Gst.Message.prototype.parse_property_notify(): {
        // javascript wrapper for 'gst_message_parse_property_notify'
    }

Parses a property-notify message. These will be posted on the bus only when set up with Gst.Element.prototype.add_property_notify_watch or Gst.Element.prototype.add_property_deep_notify_watch.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.PROPERTY_NOTIFY

Since : 1.10

#### Gst.Message.parse_property_notify

    def Gst.Message.parse_property_notify (self):
        #python wrapper for 'gst_message_parse_property_notify'

Parses a property-notify message. These will be posted on the bus only when set up with Gst.Element.add_property_notify_watch or Gst.Element.add_property_deep_notify_watch.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.PROPERTY_NOTIFY

Since : 1.10

#### gst_message_parse_qos

    gst_message_parse_qos (GstMessage * message,
                           gboolean * live,
                           guint64 * running_time,
                           guint64 * stream_time,
                           guint64 * timestamp,
                           guint64 * duration)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_QOS.

`live` ( [out][optional]) –

if the message was generated by a live element

`running_time` ( [out][optional]) –

the running time of the buffer that generated the message

`stream_time` ( [out][optional]) –

the stream time of the buffer that generated the message

`timestamp` ( [out][optional]) –

the timestamps of the buffer that generated the message

`duration` ( [out][optional]) –

the duration of the buffer that generated the message

#### Gst.Message.prototype.parse_qos

    function Gst.Message.prototype.parse_qos(): {
        // javascript wrapper for 'gst_message_parse_qos'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

#### Gst.Message.parse_qos

    def Gst.Message.parse_qos (self):
        #python wrapper for 'gst_message_parse_qos'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

#### gst_message_parse_qos_stats

    gst_message_parse_qos_stats (GstMessage * message,
                                 GstFormat * format,
                                 guint64 * processed,
                                 guint64 * dropped)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_QOS.

`format` ( [out][optional]) –

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` ( [out][optional]) –

Total number of units correctly processed since the last state change to READY or a flushing operation.

`dropped` ( [out][optional]) –

Total number of units dropped since the last state change to READY or a flushing operation.

#### Gst.Message.prototype.parse_qos_stats

    function Gst.Message.prototype.parse_qos_stats(): {
        // javascript wrapper for 'gst_message_parse_qos_stats'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

#### Gst.Message.parse_qos_stats

    def Gst.Message.parse_qos_stats (self):
        #python wrapper for 'gst_message_parse_qos_stats'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

#### gst_message_parse_qos_values

    gst_message_parse_qos_values (GstMessage * message,
                                  gint64 * jitter,
                                  gdouble * proportion,
                                  gint * quality)

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

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_QOS.

`jitter` ( [out][optional]) –

The difference of the running-time against the deadline.

`proportion` ( [out][optional]) –

Long term prediction of the ideal rate relative to normal rate to get optimal quality.

`quality` ( [out][optional]) –

An element dependent integer value that specifies the current quality level of the element. The default maximum quality is 1000000.

#### Gst.Message.prototype.parse_qos_values

    function Gst.Message.prototype.parse_qos_values(): {
        // javascript wrapper for 'gst_message_parse_qos_values'
    }

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

#### Gst.Message.parse_qos_values

    def Gst.Message.parse_qos_values (self):
        #python wrapper for 'gst_message_parse_qos_values'

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

#### gst_message_parse_redirect_entry

    gst_message_parse_redirect_entry (GstMessage * message,
                                      gsize entry_index,
                                      const gchar ** location,
                                      GstTagList ** tag_list,
                                      const GstStructure ** entry_struct)

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

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_REDIRECT

`entry_index` –

index of the entry to parse

`location` ( [out][transfer: none][optional]) –

return location for the pointer to the entry's location string, or NULL

`tag_list` ( [out][transfer: none][optional][nullable]) –

return location for the pointer to the entry's tag list, or NULL

`entry_struct` ( [out][transfer: none][optional][nullable]) –

return location for the pointer to the entry's structure, or NULL

Since : 1.10

#### Gst.Message.prototype.parse_redirect_entry

    function Gst.Message.prototype.parse_redirect_entry(entry_index: Number): {
        // javascript wrapper for 'gst_message_parse_redirect_entry'
    }

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

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.REDIRECT

`entry_index` (Number) –

index of the entry to parse

Since : 1.10

#### Gst.Message.parse_redirect_entry

    def Gst.Message.parse_redirect_entry (self, entry_index):
        #python wrapper for 'gst_message_parse_redirect_entry'

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

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.REDIRECT

`entry_index` (int) –

index of the entry to parse

Since : 1.10

#### gst_message_parse_request_state

    gst_message_parse_request_state (GstMessage * message,
                                     GstState * state)

Extract the requested state from the request_state message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_REQUEST_STATE.

`state` ( [out][optional]) –

Result location for the requested state or NULL

#### Gst.Message.prototype.parse_request_state

    function Gst.Message.prototype.parse_request_state(): {
        // javascript wrapper for 'gst_message_parse_request_state'
    }

Extract the requested state from the request_state message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_REQUEST_STATE.

#### Gst.Message.parse_request_state

    def Gst.Message.parse_request_state (self):
        #python wrapper for 'gst_message_parse_request_state'

Extract the requested state from the request_state message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_REQUEST_STATE.

#### gst_message_parse_reset_time

    gst_message_parse_reset_time (GstMessage * message,
                                  GstClockTime * running_time)

Extract the running-time from the RESET_TIME message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_RESET_TIME.

`running_time` ( [out][optional]) –

Result location for the running_time or NULL

#### Gst.Message.prototype.parse_reset_time

    function Gst.Message.prototype.parse_reset_time(): {
        // javascript wrapper for 'gst_message_parse_reset_time'
    }

Extract the running-time from the RESET_TIME message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_RESET_TIME.

#### Gst.Message.parse_reset_time

    def Gst.Message.parse_reset_time (self):
        #python wrapper for 'gst_message_parse_reset_time'

Extract the running-time from the RESET_TIME message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_RESET_TIME.

#### gst_message_parse_segment_done

    gst_message_parse_segment_done (GstMessage * message,
                                    GstFormat * format,
                                    gint64 * position)

Extracts the position and format from the segment done message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_SEGMENT_DONE.

`format` ( [out][optional]) –

Result location for the format, or NULL

`position` ( [out][optional]) –

Result location for the position, or NULL

#### Gst.Message.prototype.parse_segment_done

    function Gst.Message.prototype.parse_segment_done(): {
        // javascript wrapper for 'gst_message_parse_segment_done'
    }

Extracts the position and format from the segment done message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_SEGMENT_DONE.

#### Gst.Message.parse_segment_done

    def Gst.Message.parse_segment_done (self):
        #python wrapper for 'gst_message_parse_segment_done'

Extracts the position and format from the segment done message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_SEGMENT_DONE.

#### gst_message_parse_segment_start

    gst_message_parse_segment_start (GstMessage * message,
                                     GstFormat * format,
                                     gint64 * position)

Extracts the position and format from the segment start message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_SEGMENT_START.

`format` ( [out][optional]) –

Result location for the format, or NULL

`position` ( [out][optional]) –

Result location for the position, or NULL

#### Gst.Message.prototype.parse_segment_start

    function Gst.Message.prototype.parse_segment_start(): {
        // javascript wrapper for 'gst_message_parse_segment_start'
    }

Extracts the position and format from the segment start message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_SEGMENT_START.

#### Gst.Message.parse_segment_start

    def Gst.Message.parse_segment_start (self):
        #python wrapper for 'gst_message_parse_segment_start'

Extracts the position and format from the segment start message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_SEGMENT_START.

#### gst_message_parse_state_changed

    gst_message_parse_state_changed (GstMessage * message,
                                     GstState * oldstate,
                                     GstState * newstate,
                                     GstState * pending)

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_state_get_name (old_state),
               gst_state_get_name (new_state));
           break;
         }
         ...
       }
       ...

MT safe.

Parameters:

`message` –

a valid GstMessage of type GST_MESSAGE_STATE_CHANGED

`oldstate` ( [out][optional]) –

the previous state, or NULL

`newstate` ( [out][optional]) –

the new (current) state, or NULL

`pending` ( [out][optional]) –

the pending (target) state, or NULL

#### Gst.Message.prototype.parse_state_changed

    function Gst.Message.prototype.parse_state_changed(): {
        // javascript wrapper for 'gst_message_parse_state_changed'
    }

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_state_get_name (old_state),
               gst_state_get_name (new_state));
           break;
         }
         ...
       }
       ...

MT safe.

Parameters:

`message` (Gst.Message) –

a valid Gst.Message of type GST_MESSAGE_STATE_CHANGED

#### Gst.Message.parse_state_changed

    def Gst.Message.parse_state_changed (self):
        #python wrapper for 'gst_message_parse_state_changed'

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_state_get_name (old_state),
               gst_state_get_name (new_state));
           break;
         }
         ...
       }
       ...

MT safe.

Parameters:

`message` (Gst.Message) –

a valid Gst.Message of type GST_MESSAGE_STATE_CHANGED

#### gst_message_parse_step_done

    gst_message_parse_step_done (GstMessage * message,
                                 GstFormat * format,
                                 guint64 * amount,
                                 gdouble * rate,
                                 gboolean * flush,
                                 gboolean * intermediate,
                                 guint64 * duration,
                                 gboolean * eos)

Extract the values the step_done message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STEP_DONE.

`format` ( [out][optional]) –

result location for the format

`amount` ( [out][optional]) –

result location for the amount

`rate` ( [out][optional]) –

result location for the rate

`flush` ( [out][optional]) –

result location for the flush flag

`intermediate` ( [out][optional]) –

result location for the intermediate flag

`duration` ( [out][optional]) –

result location for the duration

`eos` ( [out][optional]) –

result location for the EOS flag

#### Gst.Message.prototype.parse_step_done

    function Gst.Message.prototype.parse_step_done(): {
        // javascript wrapper for 'gst_message_parse_step_done'
    }

Extract the values the step_done message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STEP_DONE.

#### Gst.Message.parse_step_done

    def Gst.Message.parse_step_done (self):
        #python wrapper for 'gst_message_parse_step_done'

Extract the values the step_done message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STEP_DONE.

#### gst_message_parse_step_start

    gst_message_parse_step_start (GstMessage * message,
                                  gboolean * active,
                                  GstFormat * format,
                                  guint64 * amount,
                                  gdouble * rate,
                                  gboolean * flush,
                                  gboolean * intermediate)

Extract the values from step_start message.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STEP_DONE.

`active` ( [out][optional]) –

result location for the active flag

`format` ( [out][optional]) –

result location for the format

`amount` ( [out][optional]) –

result location for the amount

`rate` ( [out][optional]) –

result location for the rate

`flush` ( [out][optional]) –

result location for the flush flag

`intermediate` ( [out][optional]) –

result location for the intermediate flag

#### Gst.Message.prototype.parse_step_start

    function Gst.Message.prototype.parse_step_start(): {
        // javascript wrapper for 'gst_message_parse_step_start'
    }

Extract the values from step_start message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STEP_DONE.

#### Gst.Message.parse_step_start

    def Gst.Message.parse_step_start (self):
        #python wrapper for 'gst_message_parse_step_start'

Extract the values from step_start message.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STEP_DONE.

#### gst_message_parse_stream_collection

    gst_message_parse_stream_collection (GstMessage * message,
                                         GstStreamCollection ** collection)

Parses a stream-collection message.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_STREAM_COLLECTION

`collection` ( [out][optional][transfer: full]) –

A location where to store a pointer to the GstStreamCollection, or NULL

Since : 1.10

#### Gst.Message.prototype.parse_stream_collection

    function Gst.Message.prototype.parse_stream_collection(): {
        // javascript wrapper for 'gst_message_parse_stream_collection'
    }

Parses a stream-collection message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAM_COLLECTION

Since : 1.10

#### Gst.Message.parse_stream_collection

    def Gst.Message.parse_stream_collection (self):
        #python wrapper for 'gst_message_parse_stream_collection'

Parses a stream-collection message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAM_COLLECTION

Since : 1.10

#### gst_message_parse_stream_status

    gst_message_parse_stream_status (GstMessage * message,
                                     GstStreamStatusType * type,
                                     GstElement ** owner)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STREAM_STATUS.

`type` ( [out]) –

A pointer to hold the status type

`owner` ( [out][transfer: none]) –

The owner element of the message source

#### Gst.Message.prototype.parse_stream_status

    function Gst.Message.prototype.parse_stream_status(): {
        // javascript wrapper for 'gst_message_parse_stream_status'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_STATUS.

#### Gst.Message.parse_stream_status

    def Gst.Message.parse_stream_status (self):
        #python wrapper for 'gst_message_parse_stream_status'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_STATUS.

#### gst_message_parse_streams_selected

    gst_message_parse_streams_selected (GstMessage * message,
                                        GstStreamCollection ** collection)

Parses a streams-selected message.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_STREAMS_SELECTED

`collection` ( [out][optional][transfer: full]) –

A location where to store a pointer to the GstStreamCollection, or NULL

Since : 1.10

#### Gst.Message.prototype.parse_streams_selected

    function Gst.Message.prototype.parse_streams_selected(): {
        // javascript wrapper for 'gst_message_parse_streams_selected'
    }

Parses a streams-selected message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

Since : 1.10

#### Gst.Message.parse_streams_selected

    def Gst.Message.parse_streams_selected (self):
        #python wrapper for 'gst_message_parse_streams_selected'

Parses a streams-selected message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

Since : 1.10

#### gst_message_parse_structure_change

    gst_message_parse_structure_change (GstMessage * message,
                                        GstStructureChangeType * type,
                                        GstElement ** owner,
                                        gboolean * busy)

Extracts the change type and completion status from the GstMessage.

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STRUCTURE_CHANGE.

`type` ( [out]) –

A pointer to hold the change type

`owner` ( [out][optional][transfer: none]) –

The owner element of the message source

`busy` ( [out][optional]) –

a pointer to hold whether the change is in progress or has been completed

#### Gst.Message.prototype.parse_structure_change

    function Gst.Message.prototype.parse_structure_change(): {
        // javascript wrapper for 'gst_message_parse_structure_change'
    }

Extracts the change type and completion status from the GstMessage.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STRUCTURE_CHANGE.

#### Gst.Message.parse_structure_change

    def Gst.Message.parse_structure_change (self):
        #python wrapper for 'gst_message_parse_structure_change'

Extracts the change type and completion status from the GstMessage.

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STRUCTURE_CHANGE.

#### gst_message_parse_tag

    gst_message_parse_tag (GstMessage * message,
                           GstTagList ** tag_list)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_TAG.

`tag_list` ( [out]) –

return location for the tag-list.

#### Gst.Message.prototype.parse_tag

    function Gst.Message.prototype.parse_tag(): {
        // javascript wrapper for 'gst_message_parse_tag'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_TAG.

#### Gst.Message.parse_tag

    def Gst.Message.parse_tag (self):
        #python wrapper for 'gst_message_parse_tag'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_TAG.

#### gst_message_parse_warning

    gst_message_parse_warning (GstMessage * message,
                               GError ** gerror,
                               gchar ** debug)

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.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_WARNING.

`gerror` ( [out][optional][transfer: full]) –

location for the GError

`debug` ( [out][optional][nullable][transfer: full]) –

location for the debug message, or NULL

#### Gst.Message.prototype.parse_warning

    function Gst.Message.prototype.parse_warning(): {
        // javascript wrapper for 'gst_message_parse_warning'
    }

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_WARNING.

#### Gst.Message.parse_warning

    def Gst.Message.parse_warning (self):
        #python wrapper for 'gst_message_parse_warning'

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.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_WARNING.

#### gst_message_parse_warning_details

    gst_message_parse_warning_details (GstMessage * message,
                                       const GstStructure ** structure)

Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Parameters:

`message` –

The message object

`structure` ( [optional][nullable][transfer: none][out]) –

A pointer to the returned details

Since : 1.10

#### Gst.Message.prototype.parse_warning_details

    function Gst.Message.prototype.parse_warning_details(): {
        // javascript wrapper for 'gst_message_parse_warning_details'
    }

Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The message object

Since : 1.10

#### Gst.Message.parse_warning_details

    def Gst.Message.parse_warning_details (self):
        #python wrapper for 'gst_message_parse_warning_details'

Returns the optional details structure, may be NULL if none The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The message object

Since : 1.10

#### gst_message_parse_warning_writable_details

    gst_message_parse_warning_writable_details (GstMessage * message,
                                                GstStructure ** structure)

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` –

The writable message object

`structure` ( [optional][nullable][transfer: none][out]) –

A pointer to the returned details

Since : 1.26

#### Gst.Message.prototype.parse_warning_writable_details

    function Gst.Message.prototype.parse_warning_writable_details(): {
        // javascript wrapper for 'gst_message_parse_warning_writable_details'
    }

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The writable message object

Since : 1.26

#### Gst.Message.parse_warning_writable_details

    def Gst.Message.parse_warning_writable_details (self):
        #python wrapper for 'gst_message_parse_warning_writable_details'

Returns the details structure if present or will create one if not present. The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

The writable message object

Since : 1.26

#### gst_message_ref

    GstMessage *
    gst_message_ref (GstMessage * msg)

Convenience macro to increase the reference count of the message.

Parameters:

`msg` –

the message to ref

Returns –

msg (for convenience when doing assignments)

#### gst_message_set_buffering_stats

    gst_message_set_buffering_stats (GstMessage * message,
                                     GstBufferingMode mode,
                                     gint avg_in,
                                     gint avg_out,
                                     gint64 buffering_left)

Configures the buffering stats values in message.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_BUFFERING.

`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

#### Gst.Message.prototype.set_buffering_stats

    function Gst.Message.prototype.set_buffering_stats(mode: Gst.BufferingMode, avg_in: Number, avg_out: Number, buffering_left: Number): {
        // javascript wrapper for 'gst_message_set_buffering_stats'
    }

Configures the buffering stats values in message.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_BUFFERING.

`mode` (Gst.BufferingMode) –

a buffering mode

`avg_in` (Number) –

the average input rate

`avg_out` (Number) –

the average output rate

`buffering_left` (Number) –

amount of buffering time left in milliseconds

#### Gst.Message.set_buffering_stats

    def Gst.Message.set_buffering_stats (self, mode, avg_in, avg_out, buffering_left):
        #python wrapper for 'gst_message_set_buffering_stats'

Configures the buffering stats values in message.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_BUFFERING.

`mode` (Gst.BufferingMode) –

a buffering mode

`avg_in` (int) –

the average input rate

`avg_out` (int) –

the average output rate

`buffering_left` (int) –

amount of buffering time left in milliseconds

#### gst_message_set_details

    gst_message_set_details (GstMessage * message,
                             GstStructure * details)

Add details to message. Will fail if the message already has details set on it or if it is not writable.

Parameters:

`message` –

A GstMessage

`details` ( [transfer: full][nullable]) –

A GstStructure with details

Since : 1.26

#### Gst.Message.prototype.set_details

    function Gst.Message.prototype.set_details(details: Gst.Structure): {
        // javascript wrapper for 'gst_message_set_details'
    }

Add details to message. Will fail if the message already has details set on it or if it is not writable.

Parameters:

`message` (Gst.Message) –

A Gst.Message

`details` (Gst.Structure) –

A GstStructure with details

Since : 1.26

#### Gst.Message.set_details

    def Gst.Message.set_details (self, details):
        #python wrapper for 'gst_message_set_details'

Add details to message. Will fail if the message already has details set on it or if it is not writable.

Parameters:

`message` (Gst.Message) –

A Gst.Message

`details` (Gst.Structure) –

A GstStructure with details

Since : 1.26

#### gst_message_set_group_id

    gst_message_set_group_id (GstMessage * message,
                              guint group_id)

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.

Parameters:

`message` –

the message

`group_id` –

the group id

Since : 1.2

#### Gst.Message.prototype.set_group_id

    function Gst.Message.prototype.set_group_id(group_id: Number): {
        // javascript wrapper for 'gst_message_set_group_id'
    }

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.

Parameters:

`message` (Gst.Message) –

the message

`group_id` (Number) –

the group id

Since : 1.2

#### Gst.Message.set_group_id

    def Gst.Message.set_group_id (self, group_id):
        #python wrapper for 'gst_message_set_group_id'

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.

Parameters:

`message` (Gst.Message) –

the message

`group_id` (int) –

the group id

Since : 1.2

#### gst_message_set_qos_stats

    gst_message_set_qos_stats (GstMessage * message,
                               GstFormat format,
                               guint64 processed,
                               guint64 dropped)

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:

`message` –

A valid GstMessage of type GST_MESSAGE_QOS.

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

#### Gst.Message.prototype.set_qos_stats

    function Gst.Message.prototype.set_qos_stats(format: Gst.Format, processed: Number, dropped: Number): {
        // javascript wrapper for 'gst_message_set_qos_stats'
    }

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:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

`format` (Gst.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` (Number) –

Total number of units correctly processed since the last state change to READY or a flushing operation.

`dropped` (Number) –

Total number of units dropped since the last state change to READY or a flushing operation.

#### Gst.Message.set_qos_stats

    def Gst.Message.set_qos_stats (self, format, processed, dropped):
        #python wrapper for 'gst_message_set_qos_stats'

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:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

`format` (Gst.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` (int) –

Total number of units correctly processed since the last state change to READY or a flushing operation.

`dropped` (int) –

Total number of units dropped since the last state change to READY or a flushing operation.

#### gst_message_set_qos_values

    gst_message_set_qos_values (GstMessage * message,
                                gint64 jitter,
                                gdouble proportion,
                                gint quality)

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

MT safe.

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_QOS.

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

#### Gst.Message.prototype.set_qos_values

    function Gst.Message.prototype.set_qos_values(jitter: Number, proportion: Number, quality: Number): {
        // javascript wrapper for 'gst_message_set_qos_values'
    }

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

`jitter` (Number) –

The difference of the running-time against the deadline.

`proportion` (Number) –

Long term prediction of the ideal rate relative to normal rate to get optimal quality.

`quality` (Number) –

An element dependent integer value that specifies the current quality level of the element. The default maximum quality is 1000000.

#### Gst.Message.set_qos_values

    def Gst.Message.set_qos_values (self, jitter, proportion, quality):
        #python wrapper for 'gst_message_set_qos_values'

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

MT safe.

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_QOS.

`jitter` (int) –

The difference of the running-time against the deadline.

`proportion` (float) –

Long term prediction of the ideal rate relative to normal rate to get optimal quality.

`quality` (int) –

An element dependent integer value that specifies the current quality level of the element. The default maximum quality is 1000000.

#### gst_message_set_seqnum

    gst_message_set_seqnum (GstMessage * message,
                            guint32 seqnum)

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 gst_message_get_seqnum for more information.

MT safe.

Parameters:

`message` –

A GstMessage.

`seqnum` –

A sequence number.

#### Gst.Message.prototype.set_seqnum

    function Gst.Message.prototype.set_seqnum(seqnum: Number): {
        // javascript wrapper for 'gst_message_set_seqnum'
    }

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 Gst.Message.prototype.get_seqnum for more information.

MT safe.

Parameters:

`message` (Gst.Message) –

A Gst.Message.

`seqnum` (Number) –

A sequence number.

#### Gst.Message.set_seqnum

    def Gst.Message.set_seqnum (self, seqnum):
        #python wrapper for 'gst_message_set_seqnum'

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 Gst.Message.get_seqnum for more information.

MT safe.

Parameters:

`message` (Gst.Message) –

A Gst.Message.

`seqnum` (int) –

A sequence number.

#### gst_message_set_stream_status_object

    gst_message_set_stream_status_object (GstMessage * message,
                                          const GValue * object)

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

Parameters:

`message` –

A valid GstMessage of type GST_MESSAGE_STREAM_STATUS.

`object` –

the object controlling the streaming

#### Gst.Message.prototype.set_stream_status_object

    function Gst.Message.prototype.set_stream_status_object(object: GObject.Value): {
        // javascript wrapper for 'gst_message_set_stream_status_object'
    }

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_STATUS.

`object` (GObject.Value) –

the object controlling the streaming

#### Gst.Message.set_stream_status_object

    def Gst.Message.set_stream_status_object (self, object):
        #python wrapper for 'gst_message_set_stream_status_object'

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

Parameters:

`message` (Gst.Message) –

A valid Gst.Message of type GST_MESSAGE_STREAM_STATUS.

`object` (GObject.Value) –

the object controlling the streaming

#### gst_message_streams_selected_add

    gst_message_streams_selected_add (GstMessage * message,
                                      GstStream * stream)

Adds the stream to the message.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_STREAMS_SELECTED

`stream` ( [transfer: none]) –

a GstStream to add to message

Since : 1.10

#### Gst.Message.prototype.streams_selected_add

    function Gst.Message.prototype.streams_selected_add(stream: Gst.Stream): {
        // javascript wrapper for 'gst_message_streams_selected_add'
    }

Adds the stream to the message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

`stream` (Gst.Stream) –

a Gst.Stream to add to message

Since : 1.10

#### Gst.Message.streams_selected_add

    def Gst.Message.streams_selected_add (self, stream):
        #python wrapper for 'gst_message_streams_selected_add'

Adds the stream to the message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

`stream` (Gst.Stream) –

a Gst.Stream to add to message

Since : 1.10

#### gst_message_streams_selected_get_size

    guint
    gst_message_streams_selected_get_size (GstMessage * message)

Returns the number of streams contained in the message.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_STREAMS_SELECTED

Returns –

The number of streams contained within.

Since : 1.10

#### Gst.Message.prototype.streams_selected_get_size

    function Gst.Message.prototype.streams_selected_get_size(): {
        // javascript wrapper for 'gst_message_streams_selected_get_size'
    }

Returns the number of streams contained in the message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

Returns (Number) –

The number of streams contained within.

Since : 1.10

#### Gst.Message.streams_selected_get_size

    def Gst.Message.streams_selected_get_size (self):
        #python wrapper for 'gst_message_streams_selected_get_size'

Returns the number of streams contained in the message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

Returns (int) –

The number of streams contained within.

Since : 1.10

#### gst_message_streams_selected_get_stream

    GstStream *
    gst_message_streams_selected_get_stream (GstMessage * message,
                                             guint idx)

Retrieves the GstStream with index index from the message.

Parameters:

`message` –

a GstMessage of type GST_MESSAGE_STREAMS_SELECTED

`idx` –

Index of the stream to retrieve

Returns ( [transfer: full][nullable]) –

A GstStream

Since : 1.10

#### Gst.Message.prototype.streams_selected_get_stream

    function Gst.Message.prototype.streams_selected_get_stream(idx: Number): {
        // javascript wrapper for 'gst_message_streams_selected_get_stream'
    }

Retrieves the Gst.Stream with index index from the message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

`idx` (Number) –

Index of the stream to retrieve

Returns (Gst.Stream) –

A Gst.Stream

Since : 1.10

#### Gst.Message.streams_selected_get_stream

    def Gst.Message.streams_selected_get_stream (self, idx):
        #python wrapper for 'gst_message_streams_selected_get_stream'

Retrieves the Gst.Stream with index index from the message.

Parameters:

`message` (Gst.Message) –

a Gst.Message of type Gst.MessageType.STREAMS_SELECTED

`idx` (int) –

Index of the stream to retrieve

Returns (Gst.Stream) –

A Gst.Stream

Since : 1.10

#### gst_message_unref

    gst_message_unref (GstMessage * msg)

Convenience macro to decrease the reference count of the message, possibly freeing it.

Parameters:

`msg` –

the message to unref

#### gst_message_writable_details

    GstStructure *
    gst_message_writable_details (GstMessage * message)

Returns the details structure of the message. If not present it will be created. Use this function (instead of gst_message_get_details) if you want to write to the details structure.

The returned structure must not be freed.

Parameters:

`message` –

A writable GstMessage

Returns ( [transfer: none]) –

The details

Since : 1.26

#### Gst.Message.prototype.writable_details

    function Gst.Message.prototype.writable_details(): {
        // javascript wrapper for 'gst_message_writable_details'
    }

Returns the details structure of the message. If not present it will be created. Use this function (instead of Gst.Message.prototype.get_details) if you want to write to the details structure.

The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

A writable Gst.Message

Returns (Gst.Structure) –

The details

Since : 1.26

#### Gst.Message.writable_details

    def Gst.Message.writable_details (self):
        #python wrapper for 'gst_message_writable_details'

Returns the details structure of the message. If not present it will be created. Use this function (instead of Gst.Message.get_details) if you want to write to the details structure.

The returned structure must not be freed.

Parameters:

`message` (Gst.Message) –

A writable Gst.Message

Returns (Gst.Structure) –

The details

Since : 1.26

#### gst_message_writable_structure

    GstStructure *
    gst_message_writable_structure (GstMessage * message)

Get a writable version of the structure.

Parameters:

`message` –

A writable GstMessage.

Returns ( [transfer: none]) –

The structure of the message. The structure is still owned by the message, which means that you should not free it and that the pointer becomes invalid when you free the message. This function ensures that message is writable, and if so, will never return NULL.

MT safe.

Since : 1.14

#### Gst.Message.prototype.writable_structure

    function Gst.Message.prototype.writable_structure(): {
        // javascript wrapper for 'gst_message_writable_structure'
    }

Get a writable version of the structure.

Parameters:

`message` (Gst.Message) –

A writable Gst.Message.

Returns (Gst.Structure) –

The structure of the message. The structure is still owned by the message, which means that you should not free it and that the pointer becomes invalid when you free the message. This function ensures that message is writable, and if so, will never return null.

MT safe.

Since : 1.14

#### Gst.Message.writable_structure

    def Gst.Message.writable_structure (self):
        #python wrapper for 'gst_message_writable_structure'

Get a writable version of the structure.

Parameters:

`message` (Gst.Message) –

A writable Gst.Message.

Returns (Gst.Structure) –

The structure of the message. The structure is still owned by the message, which means that you should not free it and that the pointer becomes invalid when you free the message. This function ensures that message is writable, and if so, will never return None.

MT safe.

Since : 1.14

### Functions

#### gst_message_replace

    gboolean
    gst_message_replace (GstMessage ** old_message,
                         GstMessage * new_message)

Modifies a pointer to a GstMessage to point to a different GstMessage. The modification is done atomically (so this is useful for ensuring thread safety in some cases), and the reference counts are updated appropriately (the old message is unreffed, the new one is reffed).

Either new_message or the GstMessage pointed to by old_message may be NULL.

Parameters:

`old_message` ( [inout][transfer: full][nullable]) –

pointer to a pointer to a GstMessage to be replaced.

`new_message` ( [nullable][transfer: none]) –

pointer to a GstMessage that will replace the message pointed to by old_message.

Returns –

TRUE if new_message was different from old_message

#### gst_message_steal

    GstMessage *
    gst_message_steal (GstMessage ** old_message)

Atomically replace the GstMessage pointed to by old_message with NULL and return the original message.

Parameters:

`old_message` ( [inout][transfer: full][nullable]) –

pointer to a pointer to a GstMessage to be stolen.

Returns –
No description available

Since : 1.28

#### gst_message_take

    gboolean
    gst_message_take (GstMessage ** old_message,
                      GstMessage * new_message)

Modifies a pointer to a GstMessage to point to a different GstMessage. This function is similar to gst_message_replace except that it takes ownership of new_message.

Parameters:

`old_message` ( [inout][transfer: full]) –

pointer to a pointer to a GstMessage to be replaced.

`new_message` ( [transfer: full][nullable]) –

pointer to a GstMessage that will replace the message pointed to by old_message.

Returns –

TRUE if new_message was different from old_message

Since : 1.16

#### Gst.prototype.message_take

    function Gst.prototype.message_take(old_message: Gst.Message, new_message: Gst.Message): {
        // javascript wrapper for 'gst_message_take'
    }

Modifies a pointer to a Gst.Message to point to a different Gst.Message. This function is similar to gst_message_replace (not introspectable) except that it takes ownership of new_message.

Parameters:

`old_message` (Gst.Message) –

pointer to a pointer to a Gst.Message to be replaced.

`new_message` (Gst.Message) –

pointer to a Gst.Message that will replace the message pointed to by old_message.

Returns a tuple made of:

(Number ) –

true if new_message was different from old_message

`old_message` (Gst.Message ) –

true if new_message was different from old_message

Since : 1.16

#### Gst.message_take

    def Gst.message_take (old_message, new_message):
        #python wrapper for 'gst_message_take'

Modifies a pointer to a Gst.Message to point to a different Gst.Message. This function is similar to gst_message_replace (not introspectable) except that it takes ownership of new_message.

Parameters:

`old_message` (Gst.Message) –

pointer to a pointer to a Gst.Message to be replaced.

`new_message` (Gst.Message) –

pointer to a Gst.Message that will replace the message pointed to by old_message.

Returns a tuple made of:

(bool ) –

True if new_message was different from old_message

`old_message` (Gst.Message ) –

True if new_message was different from old_message

Since : 1.16

## Functions

### gst_clear_message

    gst_clear_message (GstMessage ** msg_ptr)

Clears a reference to a GstMessage.

msg_ptr must not be NULL.

If the reference is NULL then this function does nothing. Otherwise, the reference count of the message is decreased and the pointer is set to NULL.

Parameters:

`msg_ptr` –

a pointer to a GstMessage reference

Since : 1.16

### gst_message_type_get_name

    const gchar *
    gst_message_type_get_name (GstMessageType type)

Get a printable name for the given message type. Do not modify or free.

Parameters:

`type` –

the message type

Returns –

a reference to the static name of the message.

### Gst.prototype.message_type_get_name

    function Gst.prototype.message_type_get_name(type: Gst.MessageType): {
        // javascript wrapper for 'gst_message_type_get_name'
    }

Get a printable name for the given message type. Do not modify or free.

Parameters:

`type` (Gst.MessageType) –

the message type

Returns (String) –

a reference to the static name of the message.

### Gst.message_type_get_name

    def Gst.message_type_get_name (type):
        #python wrapper for 'gst_message_type_get_name'

Get a printable name for the given message type. Do not modify or free.

Parameters:

`type` (Gst.MessageType) –

the message type

Returns (str) –

a reference to the static name of the message.

### gst_message_type_to_quark

    GQuark
    gst_message_type_to_quark (GstMessageType type)

Get the unique quark for the given message type.

Parameters:

`type` –

the message type

Returns –

the quark associated with the message type

### Gst.prototype.message_type_to_quark

    function Gst.prototype.message_type_to_quark(type: Gst.MessageType): {
        // javascript wrapper for 'gst_message_type_to_quark'
    }

Get the unique quark for the given message type.

Parameters:

`type` (Gst.MessageType) –

the message type

Returns (GLib.Quark) –

the quark associated with the message type

### Gst.message_type_to_quark

    def Gst.message_type_to_quark (type):
        #python wrapper for 'gst_message_type_to_quark'

Get the unique quark for the given message type.

Parameters:

`type` (Gst.MessageType) –

the message type

Returns (GLib.Quark) –

the quark associated with the message type

## Function Macros

### GST_MESSAGE_CAST

    #define GST_MESSAGE_CAST(obj)                    ((GstMessage*)(obj))

### GST_MESSAGE_GET_COND

    #define GST_MESSAGE_GET_COND(message)   (&GST_MESSAGE_CAST(message)->cond)

### GST_MESSAGE_GET_LOCK

    #define GST_MESSAGE_GET_LOCK(message)   (&GST_MESSAGE_CAST(message)->lock)

### GST_MESSAGE_LOCK

    #define GST_MESSAGE_LOCK(message)       g_mutex_lock(GST_MESSAGE_GET_LOCK(message))

### GST_MESSAGE_SEQNUM

    #define GST_MESSAGE_SEQNUM(message)     (GST_MESSAGE_CAST(message)->seqnum)

Get the sequence number of message.

Parameters:

`message` –

a GstMessage

### GST_MESSAGE_SIGNAL

    #define GST_MESSAGE_SIGNAL(message)     g_cond_signal(GST_MESSAGE_GET_COND(message))

### GST_MESSAGE_SRC

    #define GST_MESSAGE_SRC(message)        (GST_MESSAGE_CAST(message)->src)

Get the object that posted message.

Parameters:

`message` –

a GstMessage

### GST_MESSAGE_SRC_NAME

    #define GST_MESSAGE_SRC_NAME(message)   (GST_MESSAGE_SRC(message) ? \
        GST_OBJECT_NAME (GST_MESSAGE_SRC(message)) : "(NULL)")

Get the name of the object that posted message. Returns "(NULL)" if the message has no source object set.

Parameters:

`message` –

a GstMessage

### GST_MESSAGE_TIMESTAMP

    #define GST_MESSAGE_TIMESTAMP(message)  (GST_MESSAGE_CAST(message)->timestamp)

Get the timestamp of message. This is the timestamp when the message was created.

Parameters:

`message` –

a GstMessage

### GST_MESSAGE_TYPE

    #define GST_MESSAGE_TYPE(message)       (GST_MESSAGE_CAST(message)->type)

Get the GstMessageType of message.

Parameters:

`message` –

a GstMessage

### GST_MESSAGE_TYPE_IS_EXTENDED

    #define GST_MESSAGE_TYPE_IS_EXTENDED(message)       (!!(GST_MESSAGE_CAST(message)->type & GST_MESSAGE_EXTENDED))

Check if the message is in the extended message group

Parameters:

`message` –

a GstMessage

Since : 1.4

### GST_MESSAGE_TYPE_NAME

    #define GST_MESSAGE_TYPE_NAME(message)  gst_message_type_get_name(GST_MESSAGE_TYPE(message))

Get a constant string representation of the GstMessageType of message.

Parameters:

`message` –

a GstMessage

### GST_MESSAGE_UNLOCK

    #define GST_MESSAGE_UNLOCK(message)     g_mutex_unlock(GST_MESSAGE_GET_LOCK(message))

### GST_MESSAGE_WAIT

    #define GST_MESSAGE_WAIT(message)       g_cond_wait(GST_MESSAGE_GET_COND(message),GST_MESSAGE_GET_LOCK(message))

## Enumerations

### GstMessageType

The different message types that are available.

##### Members

`GST_MESSAGE_UNKNOWN` (0) –

an undefined message

`GST_MESSAGE_EOS` (1) –

end-of-stream reached in a pipeline. The application will only receive this message in the PLAYING state and every time it sets a pipeline to PLAYING that is in the EOS state. The application can perform a flushing seek in the pipeline, which will undo the EOS state again.

`GST_MESSAGE_ERROR` (2) –

an error occurred. When the application receives an error message it should stop playback of the pipeline and not assume that more data will be played. It is possible to specify a redirection url to the error messages by setting a `redirect-location` field into the error message, application or high level bins might use the information as required.

`GST_MESSAGE_WARNING` (4) –

a warning occurred.

`GST_MESSAGE_INFO` (8) –

an info message occurred

`GST_MESSAGE_TAG` (16) –

a tag was found.

`GST_MESSAGE_BUFFERING` (32) –

the pipeline is buffering. When the application receives a buffering message in the PLAYING state for a non-live pipeline it must PAUSE the pipeline until the buffering completes, when the percentage field in the message is 100%. For live pipelines, no action must be performed and the buffering percentage can be used to inform the user about the progress.

`GST_MESSAGE_STATE_CHANGED` (64) –

a state change happened

`GST_MESSAGE_STATE_DIRTY` (128) –

an element changed state in a streaming thread. This message is deprecated.

`GST_MESSAGE_STEP_DONE` (256) –

a stepping operation finished.

`GST_MESSAGE_CLOCK_PROVIDE` (512) –

an element notifies its capability of providing a clock. This message is used internally and never forwarded to the application.

`GST_MESSAGE_CLOCK_LOST` (1024) –

The current clock as selected by the pipeline became unusable. The pipeline will select a new clock on the next PLAYING state change. The application should set the pipeline to PAUSED and back to PLAYING when this message is received.

`GST_MESSAGE_NEW_CLOCK` (2048) –

a new clock was selected in the pipeline.

`GST_MESSAGE_STRUCTURE_CHANGE` (4096) –

the structure of the pipeline changed. This message is used internally and never forwarded to the application.

`GST_MESSAGE_STREAM_STATUS` (8192) –

status about a stream, emitted when it starts, stops, errors, etc..

`GST_MESSAGE_APPLICATION` (16384) –

message posted by the application, possibly via an application-specific element.

`GST_MESSAGE_ELEMENT` (32768) –

element-specific message, see the specific element's documentation

`GST_MESSAGE_SEGMENT_START` (65536) –

pipeline started playback of a segment. This message is used internally and never forwarded to the application.

`GST_MESSAGE_SEGMENT_DONE` (131072) –

pipeline completed playback of a segment. This message is forwarded to the application after all elements that posted GST_MESSAGE_SEGMENT_START posted a GST_MESSAGE_SEGMENT_DONE message.

`GST_MESSAGE_DURATION_CHANGED` (262144) –

The duration of a pipeline changed. The application can get the new duration with a duration query.

`GST_MESSAGE_LATENCY` (524288) –

Posted by elements when their latency changes. The application should recalculate and distribute a new latency.

`GST_MESSAGE_ASYNC_START` (1048576) –

Posted by elements when they start an ASYNC GstStateChange. This message is not forwarded to the application but is used internally.

`GST_MESSAGE_ASYNC_DONE` (2097152) –

Posted by elements when they complete an ASYNC GstStateChange. The application will only receive this message from the toplevel pipeline.

`GST_MESSAGE_REQUEST_STATE` (4194304) –

Posted by elements when they want the pipeline to change state. This message is a suggestion to the application which can decide to perform the state change on (part of) the pipeline.

`GST_MESSAGE_STEP_START` (8388608) –

A stepping operation was started.

`GST_MESSAGE_QOS` (16777216) –

A buffer was dropped or an element changed its processing strategy for Quality of Service reasons.

`GST_MESSAGE_PROGRESS` (33554432) –

A progress message.

`GST_MESSAGE_TOC` (67108864) –

A new table of contents (TOC) was found or previously found TOC was updated.

`GST_MESSAGE_RESET_TIME` (134217728) –

Message to request resetting the pipeline's running time from the pipeline. This is an internal message which applications will likely never receive.

`GST_MESSAGE_STREAM_START` (268435456) –

Message indicating start of a new stream. Useful e.g. when using playbin in gapless playback mode, to get notified when the next title actually starts playing (which will be some time after the URI for the next title has been set).

`GST_MESSAGE_NEED_CONTEXT` (536870912) –

Message indicating that an element wants a specific context (Since: 1.2)

`GST_MESSAGE_HAVE_CONTEXT` (1073741824) –

Message indicating that an element created a context (Since: 1.2)

`GST_MESSAGE_EXTENDED` (2147483648) –

Message is an extended message type (see below). These extended message IDs can't be used directly with mask-based API like gst_bus_poll or gst_bus_timed_pop_filtered, but you can still filter for GST_MESSAGE_EXTENDED and then check the result for the specific type. (Since: 1.4)

`GST_MESSAGE_DEVICE_ADDED` (2147483649) –

Message indicating a GstDevice was added to a GstDeviceProvider (Since: 1.4)

`GST_MESSAGE_DEVICE_REMOVED` (2147483650) –

Message indicating a GstDevice was removed from a GstDeviceProvider (Since: 1.4)

`GST_MESSAGE_PROPERTY_NOTIFY` (2147483651) –

Message indicating a GObject property has changed (Since: 1.10)

`GST_MESSAGE_STREAM_COLLECTION` (2147483652) –

Message indicating a new GstStreamCollection is available (Since: 1.10)

`GST_MESSAGE_STREAMS_SELECTED` (2147483653) –

Message indicating the active selection of GstStream has changed (Since: 1.10)

`GST_MESSAGE_REDIRECT` (2147483654) –

Message indicating to request the application to try to play the given URL(s). Useful if for example a HTTP 302/303 response is received with a non-HTTP URL inside. (Since: 1.10)

`GST_MESSAGE_DEVICE_CHANGED` (2147483655) –

Message indicating a GstDevice was changed a GstDeviceProvider (Since: 1.16)

`GST_MESSAGE_INSTANT_RATE_REQUEST` (2147483656) –

Message sent by elements to request the running time from the pipeline when an instant rate change should be applied (which may be in the past when the answer arrives). (Since: 1.18)

`GST_MESSAGE_DEVICE_MONITOR_STARTED` (2147483657) –

Message indicating the GstDeviceMonitor has completed async startup.

(Since: 1.28)
`GST_MESSAGE_ANY` (4294967295) –

mask for all of the above messages.

### Gst.MessageType

The different message types that are available.

##### Members

`Gst.MessageType.UNKNOWN` (0) –

an undefined message

`Gst.MessageType.EOS` (1) –

end-of-stream reached in a pipeline. The application will only receive this message in the PLAYING state and every time it sets a pipeline to PLAYING that is in the EOS state. The application can perform a flushing seek in the pipeline, which will undo the EOS state again.

`Gst.MessageType.ERROR` (2) –

an error occurred. When the application receives an error message it should stop playback of the pipeline and not assume that more data will be played. It is possible to specify a redirection url to the error messages by setting a `redirect-location` field into the error message, application or high level bins might use the information as required.

`Gst.MessageType.WARNING` (4) –

a warning occurred.

`Gst.MessageType.INFO` (8) –

an info message occurred

`Gst.MessageType.TAG` (16) –

a tag was found.

`Gst.MessageType.BUFFERING` (32) –

the pipeline is buffering. When the application receives a buffering message in the PLAYING state for a non-live pipeline it must PAUSE the pipeline until the buffering completes, when the percentage field in the message is 100%. For live pipelines, no action must be performed and the buffering percentage can be used to inform the user about the progress.

`Gst.MessageType.STATE_CHANGED` (64) –

a state change happened

`Gst.MessageType.STATE_DIRTY` (128) –

an element changed state in a streaming thread. This message is deprecated.

`Gst.MessageType.STEP_DONE` (256) –

a stepping operation finished.

`Gst.MessageType.CLOCK_PROVIDE` (512) –

an element notifies its capability of providing a clock. This message is used internally and never forwarded to the application.

`Gst.MessageType.CLOCK_LOST` (1024) –

The current clock as selected by the pipeline became unusable. The pipeline will select a new clock on the next PLAYING state change. The application should set the pipeline to PAUSED and back to PLAYING when this message is received.

`Gst.MessageType.NEW_CLOCK` (2048) –

a new clock was selected in the pipeline.

`Gst.MessageType.STRUCTURE_CHANGE` (4096) –

the structure of the pipeline changed. This message is used internally and never forwarded to the application.

`Gst.MessageType.STREAM_STATUS` (8192) –

status about a stream, emitted when it starts, stops, errors, etc..

`Gst.MessageType.APPLICATION` (16384) –

message posted by the application, possibly via an application-specific element.

`Gst.MessageType.ELEMENT` (32768) –

element-specific message, see the specific element's documentation

`Gst.MessageType.SEGMENT_START` (65536) –

pipeline started playback of a segment. This message is used internally and never forwarded to the application.

`Gst.MessageType.SEGMENT_DONE` (131072) –

pipeline completed playback of a segment. This message is forwarded to the application after all elements that posted GST_MESSAGE_SEGMENT_START posted a GST_MESSAGE_SEGMENT_DONE message.

`Gst.MessageType.DURATION_CHANGED` (262144) –

The duration of a pipeline changed. The application can get the new duration with a duration query.

`Gst.MessageType.LATENCY` (524288) –

Posted by elements when their latency changes. The application should recalculate and distribute a new latency.

`Gst.MessageType.ASYNC_START` (1048576) –

Posted by elements when they start an ASYNC Gst.StateChange. This message is not forwarded to the application but is used internally.

`Gst.MessageType.ASYNC_DONE` (2097152) –

Posted by elements when they complete an ASYNC Gst.StateChange. The application will only receive this message from the toplevel pipeline.

`Gst.MessageType.REQUEST_STATE` (4194304) –

Posted by elements when they want the pipeline to change state. This message is a suggestion to the application which can decide to perform the state change on (part of) the pipeline.

`Gst.MessageType.STEP_START` (8388608) –

A stepping operation was started.

`Gst.MessageType.QOS` (16777216) –

A buffer was dropped or an element changed its processing strategy for Quality of Service reasons.

`Gst.MessageType.PROGRESS` (33554432) –

A progress message.

`Gst.MessageType.TOC` (67108864) –

A new table of contents (TOC) was found or previously found TOC was updated.

`Gst.MessageType.RESET_TIME` (134217728) –

Message to request resetting the pipeline's running time from the pipeline. This is an internal message which applications will likely never receive.

`Gst.MessageType.STREAM_START` (268435456) –

Message indicating start of a new stream. Useful e.g. when using playbin in gapless playback mode, to get notified when the next title actually starts playing (which will be some time after the URI for the next title has been set).

`Gst.MessageType.NEED_CONTEXT` (536870912) –

Message indicating that an element wants a specific context (Since: 1.2)

`Gst.MessageType.HAVE_CONTEXT` (1073741824) –

Message indicating that an element created a context (Since: 1.2)

`Gst.MessageType.EXTENDED` (2147483648) –

Message is an extended message type (see below). These extended message IDs can't be used directly with mask-based API like Gst.Bus.prototype.poll or Gst.Bus.prototype.timed_pop_filtered, but you can still filter for GST_MESSAGE_EXTENDED and then check the result for the specific type. (Since: 1.4)

`Gst.MessageType.DEVICE_ADDED` (2147483649) –

Message indicating a Gst.Device was added to a Gst.DeviceProvider (Since: 1.4)

`Gst.MessageType.DEVICE_REMOVED` (2147483650) –

Message indicating a Gst.Device was removed from a Gst.DeviceProvider (Since: 1.4)

`Gst.MessageType.PROPERTY_NOTIFY` (2147483651) –

Message indicating a GObject.Object property has changed (Since: 1.10)

`Gst.MessageType.STREAM_COLLECTION` (2147483652) –

Message indicating a new Gst.StreamCollection is available (Since: 1.10)

`Gst.MessageType.STREAMS_SELECTED` (2147483653) –

Message indicating the active selection of Gst.Stream has changed (Since: 1.10)

`Gst.MessageType.REDIRECT` (2147483654) –

Message indicating to request the application to try to play the given URL(s). Useful if for example a HTTP 302/303 response is received with a non-HTTP URL inside. (Since: 1.10)

`Gst.MessageType.DEVICE_CHANGED` (2147483655) –

Message indicating a Gst.Device was changed a Gst.DeviceProvider (Since: 1.16)

`Gst.MessageType.INSTANT_RATE_REQUEST` (2147483656) –

Message sent by elements to request the running time from the pipeline when an instant rate change should be applied (which may be in the past when the answer arrives). (Since: 1.18)

`Gst.MessageType.DEVICE_MONITOR_STARTED` (2147483657) –

Message indicating the Gst.DeviceMonitor has completed async startup.

(Since: 1.28)
`Gst.MessageType.ANY` (4294967295) –

mask for all of the above messages.

### Gst.MessageType

The different message types that are available.

##### Members

`Gst.MessageType.UNKNOWN` (0) –

an undefined message

`Gst.MessageType.EOS` (1) –

end-of-stream reached in a pipeline. The application will only receive this message in the PLAYING state and every time it sets a pipeline to PLAYING that is in the EOS state. The application can perform a flushing seek in the pipeline, which will undo the EOS state again.

`Gst.MessageType.ERROR` (2) –

an error occurred. When the application receives an error message it should stop playback of the pipeline and not assume that more data will be played. It is possible to specify a redirection url to the error messages by setting a `redirect-location` field into the error message, application or high level bins might use the information as required.

`Gst.MessageType.WARNING` (4) –

a warning occurred.

`Gst.MessageType.INFO` (8) –

an info message occurred

`Gst.MessageType.TAG` (16) –

a tag was found.

`Gst.MessageType.BUFFERING` (32) –

the pipeline is buffering. When the application receives a buffering message in the PLAYING state for a non-live pipeline it must PAUSE the pipeline until the buffering completes, when the percentage field in the message is 100%. For live pipelines, no action must be performed and the buffering percentage can be used to inform the user about the progress.

`Gst.MessageType.STATE_CHANGED` (64) –

a state change happened

`Gst.MessageType.STATE_DIRTY` (128) –

an element changed state in a streaming thread. This message is deprecated.

`Gst.MessageType.STEP_DONE` (256) –

a stepping operation finished.

`Gst.MessageType.CLOCK_PROVIDE` (512) –

an element notifies its capability of providing a clock. This message is used internally and never forwarded to the application.

`Gst.MessageType.CLOCK_LOST` (1024) –

The current clock as selected by the pipeline became unusable. The pipeline will select a new clock on the next PLAYING state change. The application should set the pipeline to PAUSED and back to PLAYING when this message is received.

`Gst.MessageType.NEW_CLOCK` (2048) –

a new clock was selected in the pipeline.

`Gst.MessageType.STRUCTURE_CHANGE` (4096) –

the structure of the pipeline changed. This message is used internally and never forwarded to the application.

`Gst.MessageType.STREAM_STATUS` (8192) –

status about a stream, emitted when it starts, stops, errors, etc..

`Gst.MessageType.APPLICATION` (16384) –

message posted by the application, possibly via an application-specific element.

`Gst.MessageType.ELEMENT` (32768) –

element-specific message, see the specific element's documentation

`Gst.MessageType.SEGMENT_START` (65536) –

pipeline started playback of a segment. This message is used internally and never forwarded to the application.

`Gst.MessageType.SEGMENT_DONE` (131072) –

pipeline completed playback of a segment. This message is forwarded to the application after all elements that posted GST_MESSAGE_SEGMENT_START posted a GST_MESSAGE_SEGMENT_DONE message.

`Gst.MessageType.DURATION_CHANGED` (262144) –

The duration of a pipeline changed. The application can get the new duration with a duration query.

`Gst.MessageType.LATENCY` (524288) –

Posted by elements when their latency changes. The application should recalculate and distribute a new latency.

`Gst.MessageType.ASYNC_START` (1048576) –

Posted by elements when they start an ASYNC Gst.StateChange. This message is not forwarded to the application but is used internally.

`Gst.MessageType.ASYNC_DONE` (2097152) –

Posted by elements when they complete an ASYNC Gst.StateChange. The application will only receive this message from the toplevel pipeline.

`Gst.MessageType.REQUEST_STATE` (4194304) –

Posted by elements when they want the pipeline to change state. This message is a suggestion to the application which can decide to perform the state change on (part of) the pipeline.

`Gst.MessageType.STEP_START` (8388608) –

A stepping operation was started.

`Gst.MessageType.QOS` (16777216) –

A buffer was dropped or an element changed its processing strategy for Quality of Service reasons.

`Gst.MessageType.PROGRESS` (33554432) –

A progress message.

`Gst.MessageType.TOC` (67108864) –

A new table of contents (TOC) was found or previously found TOC was updated.

`Gst.MessageType.RESET_TIME` (134217728) –

Message to request resetting the pipeline's running time from the pipeline. This is an internal message which applications will likely never receive.

`Gst.MessageType.STREAM_START` (268435456) –

Message indicating start of a new stream. Useful e.g. when using playbin in gapless playback mode, to get notified when the next title actually starts playing (which will be some time after the URI for the next title has been set).

`Gst.MessageType.NEED_CONTEXT` (536870912) –

Message indicating that an element wants a specific context (Since: 1.2)

`Gst.MessageType.HAVE_CONTEXT` (1073741824) –

Message indicating that an element created a context (Since: 1.2)

`Gst.MessageType.EXTENDED` (2147483648) –

Message is an extended message type (see below). These extended message IDs can't be used directly with mask-based API like Gst.Bus.poll or Gst.Bus.timed_pop_filtered, but you can still filter for GST_MESSAGE_EXTENDED and then check the result for the specific type. (Since: 1.4)

`Gst.MessageType.DEVICE_ADDED` (2147483649) –

Message indicating a Gst.Device was added to a Gst.DeviceProvider (Since: 1.4)

`Gst.MessageType.DEVICE_REMOVED` (2147483650) –

Message indicating a Gst.Device was removed from a Gst.DeviceProvider (Since: 1.4)

`Gst.MessageType.PROPERTY_NOTIFY` (2147483651) –

Message indicating a GObject.Object property has changed (Since: 1.10)

`Gst.MessageType.STREAM_COLLECTION` (2147483652) –

Message indicating a new Gst.StreamCollection is available (Since: 1.10)

`Gst.MessageType.STREAMS_SELECTED` (2147483653) –

Message indicating the active selection of Gst.Stream has changed (Since: 1.10)

`Gst.MessageType.REDIRECT` (2147483654) –

Message indicating to request the application to try to play the given URL(s). Useful if for example a HTTP 302/303 response is received with a non-HTTP URL inside. (Since: 1.10)

`Gst.MessageType.DEVICE_CHANGED` (2147483655) –

Message indicating a Gst.Device was changed a Gst.DeviceProvider (Since: 1.16)

`Gst.MessageType.INSTANT_RATE_REQUEST` (2147483656) –

Message sent by elements to request the running time from the pipeline when an instant rate change should be applied (which may be in the past when the answer arrives). (Since: 1.18)

`Gst.MessageType.DEVICE_MONITOR_STARTED` (2147483657) –

Message indicating the Gst.DeviceMonitor has completed async startup.

(Since: 1.28)
`Gst.MessageType.ANY` (4294967295) –

mask for all of the above messages.

### GstProgressType

The type of a GST_MESSAGE_PROGRESS. The progress messages inform the application of the status of asynchronous tasks.

##### Members

`GST_PROGRESS_TYPE_START` (0) –

A new task started.

`GST_PROGRESS_TYPE_CONTINUE` (1) –

A task completed and a new one continues.

`GST_PROGRESS_TYPE_COMPLETE` (2) –

A task completed.

`GST_PROGRESS_TYPE_CANCELED` (3) –

A task was canceled.

`GST_PROGRESS_TYPE_ERROR` (4) –

A task caused an error. An error message is also posted on the bus.

### Gst.ProgressType

The type of a Gst.MessageType.PROGRESS. The progress messages inform the application of the status of asynchronous tasks.

##### Members

`Gst.ProgressType.START` (0) –

A new task started.

`Gst.ProgressType.CONTINUE` (1) –

A task completed and a new one continues.

`Gst.ProgressType.COMPLETE` (2) –

A task completed.

`Gst.ProgressType.CANCELED` (3) –

A task was canceled.

`Gst.ProgressType.ERROR` (4) –

A task caused an error. An error message is also posted on the bus.

### Gst.ProgressType

The type of a Gst.MessageType.PROGRESS. The progress messages inform the application of the status of asynchronous tasks.

##### Members

`Gst.ProgressType.START` (0) –

A new task started.

`Gst.ProgressType.CONTINUE` (1) –

A task completed and a new one continues.

`Gst.ProgressType.COMPLETE` (2) –

A task completed.

`Gst.ProgressType.CANCELED` (3) –

A task was canceled.

`Gst.ProgressType.ERROR` (4) –

A task caused an error. An error message is also posted on the bus.

### GstStreamStatusType

The type of a GST_MESSAGE_STREAM_STATUS. The stream status messages inform the application of new streaming threads and their status.

##### Members

`GST_STREAM_STATUS_TYPE_CREATE` (0) –

A new thread need to be created.

`GST_STREAM_STATUS_TYPE_ENTER` (1) –

a thread entered its loop function

`GST_STREAM_STATUS_TYPE_LEAVE` (2) –

a thread left its loop function

`GST_STREAM_STATUS_TYPE_DESTROY` (3) –

a thread is destroyed

`GST_STREAM_STATUS_TYPE_START` (8) –

a thread is started

`GST_STREAM_STATUS_TYPE_PAUSE` (9) –

a thread is paused

`GST_STREAM_STATUS_TYPE_STOP` (10) –

a thread is stopped

### Gst.StreamStatusType

The type of a Gst.MessageType.STREAM_STATUS. The stream status messages inform the application of new streaming threads and their status.

##### Members

`Gst.StreamStatusType.CREATE` (0) –

A new thread need to be created.

`Gst.StreamStatusType.ENTER` (1) –

a thread entered its loop function

`Gst.StreamStatusType.LEAVE` (2) –

a thread left its loop function

`Gst.StreamStatusType.DESTROY` (3) –

a thread is destroyed

`Gst.StreamStatusType.START` (8) –

a thread is started

`Gst.StreamStatusType.PAUSE` (9) –

a thread is paused

`Gst.StreamStatusType.STOP` (10) –

a thread is stopped

### Gst.StreamStatusType

The type of a Gst.MessageType.STREAM_STATUS. The stream status messages inform the application of new streaming threads and their status.

##### Members

`Gst.StreamStatusType.CREATE` (0) –

A new thread need to be created.

`Gst.StreamStatusType.ENTER` (1) –

a thread entered its loop function

`Gst.StreamStatusType.LEAVE` (2) –

a thread left its loop function

`Gst.StreamStatusType.DESTROY` (3) –

a thread is destroyed

`Gst.StreamStatusType.START` (8) –

a thread is started

`Gst.StreamStatusType.PAUSE` (9) –

a thread is paused

`Gst.StreamStatusType.STOP` (10) –

a thread is stopped

### GstStructureChangeType

The type of a GST_MESSAGE_STRUCTURE_CHANGE.

##### Members

`GST_STRUCTURE_CHANGE_TYPE_PAD_LINK` (0) –

Pad linking is starting or done.

`GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK` (1) –

Pad unlinking is starting or done.

### Gst.StructureChangeType

The type of a Gst.MessageType.STRUCTURE_CHANGE.

##### Members

`Gst.StructureChangeType.LINK` (0) –

Pad linking is starting or done.

`Gst.StructureChangeType.UNLINK` (1) –

Pad unlinking is starting or done.

### Gst.StructureChangeType

The type of a Gst.MessageType.STRUCTURE_CHANGE.

##### Members

`Gst.StructureChangeType.LINK` (0) –

Pad linking is starting or done.

`Gst.StructureChangeType.UNLINK` (1) –

Pad unlinking is starting or done.

The results of the search are