Message

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

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

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

gst_bus_post (bus, [gstreamer.Message.Message.newEos|Message.newEos]);

A gstreamer.Element usually posts messages on the bus provided by the parent container using Element.postMessage.

class Message {

GstMessage* gstMessage;

protected

bool ownedRef;

GstMessage* getMessageStruct(bool transferOwnership);

void* getStruct();

this(GstMessage* gstMessage, bool ownedRef);

GstMessageType type();

ObjectGst src();

static Message newElement(ObjectGst src, Structure structure);

static Message newNewClock(ObjectGst src, Clock clock);

static Message newSegmentDone(ObjectGst src, GstFormat format, long position);

static Message newSegmentStart(ObjectGst src, GstFormat format, long position);

static Message newWarning(ObjectGst src, ErrorG error, string dbug);

static Message newStateDirty(ObjectGst src);

static Message newEOS(ObjectGst src);

static Message newError(ObjectGst src, ErrorG error, string dbug);

static Message newInfo(ObjectGst src, ErrorG error, string dbug);

static Message newLatency(ObjectGst src);

static Message newDurationChanged(ObjectGst src);

static Message newAsyncStart(ObjectGst src);

static Message newAsyncDone(ObjectGst src, GstClockTime runningTime);

static Message newDeviceAdded(ObjectGst src, Device device);

static Message newDeviceRemoved(ObjectGst src, Device device);

static Message newErrorWithDetails(ObjectGst src, ErrorG error, string dbg, Structure details);

static Message newInfoWithDetails(ObjectGst src, ErrorG error, string dbg, Structure details);

static Message newWarningWithDetails(ObjectGst src, ErrorG error, string dbg, Structure details);

static Message newStreamCollection(ObjectGst src, StreamCollection collection);

static Message newStreamsSelected(ObjectGst src, StreamCollection collection);

static GType getType();

this(ObjectGst src, Structure structure);

this(ObjectGst src, GstClockTime runningTime);

this(ObjectGst src, int percent);

this(ObjectGst src, Clock clock);

this(ObjectGst src, Clock clock, bool ready);

this(GstMessageType type, ObjectGst src, Structure structure);

this(ObjectGst src, Device device, Device changedDevice);

this(ObjectGst src, Context context);

this(ObjectGst src, string contextType);

this(ObjectGst src, GstProgressType type, string code, string text);

this(ObjectGst src, string propertyName, Value val);

this(ObjectGst src, bool live, ulong runningTime, ulong streamTime, ulong timestamp, ulong duration);

this(ObjectGst src, string location, TagList tagList, Structure entryStruct);

this(ObjectGst src, GstState state);

this(ObjectGst src, GstState oldstate, GstState newstate, GstState pending);

this(ObjectGst src, GstFormat format, ulong amount, double rate, bool flush, bool intermediate, ulong duration, bool eos);

this(ObjectGst src, bool active, GstFormat format, ulong amount, double rate, bool flush, bool intermediate);

this(ObjectGst src);

this(ObjectGst src, GstStreamStatusType type, Element owner);

this(ObjectGst src, GstStructureChangeType type, Element owner, bool busy);

this(ObjectGst src, TagList tagList);

this(ObjectGst src, Toc toc, bool updated);

void addRedirectEntry(string location, TagList tagList, Structure entryStruct);

size_t getNumRedirectEntries();

uint getSeqnum();

Value getStreamStatusObject();

Structure getStructure();

bool hasName(string name);

void parseAsyncDone(GstClockTime runningTime);

void parseBuffering(int percent);

void parseBufferingStats(GstBufferingMode mode, int avgIn, int avgOut, long bufferingLeft);

void parseClockLost(Clock clock);

void parseClockProvide(Clock clock, bool ready);

bool parseContextType(string contextType);

void parseDeviceAdded(Device device);

void parseDeviceChanged(Device device, Device changedDevice);

void parseDeviceRemoved(Device device);

void parseError(ErrorG gerror, string debug_);

void parseErrorDetails(Structure structure);

bool parseGroupId(uint groupId);

void parseHaveContext(Context context);

void parseInfo(ErrorG gerror, string debug_);

void parseInfoDetails(Structure structure);

void parseNewClock(Clock clock);

void parseProgress(GstProgressType type, string code, string text);

void parsePropertyNotify(ObjectGst object, string propertyName, Value propertyValue);

void parseQos(bool live, ulong runningTime, ulong streamTime, ulong timestamp, ulong duration);

void parseQosStats(GstFormat format, ulong processed, ulong dropped);

void parseQosValues(long jitter, double proportion, int quality);

void parseRedirectEntry(size_t entryIndex, string location, TagList tagList, Structure entryStruct);

void parseRequestState(GstState state);

void parseResetTime(GstClockTime runningTime);

void parseSegmentDone(GstFormat format, long position);

void parseSegmentStart(GstFormat format, long position);

void parseStateChanged(GstState oldstate, GstState newstate, GstState pending);

void parseStepDone(GstFormat format, ulong amount, double rate, bool flush, bool intermediate, ulong duration, bool eos);

void parseStepStart(bool active, GstFormat format, ulong amount, double rate, bool flush, bool intermediate);

void parseStreamCollection(StreamCollection collection);

void parseStreamStatus(GstStreamStatusType type, Element owner);

void parseStreamsSelected(StreamCollection collection);

void parseStructureChange(GstStructureChangeType type, Element owner, bool busy);

void parseTag(TagList tagList);

void parseToc(Toc toc, bool updated);

void parseWarning(ErrorG gerror, string debug_);

void parseWarningDetails(Structure structure);

void setBufferingStats(GstBufferingMode mode, int avgIn, int avgOut, long bufferingLeft);

void setGroupId(uint groupId);

void setQosStats(GstFormat format, ulong processed, ulong dropped);

void setQosValues(long jitter, double proportion, int quality);

void setSeqnum(uint seqnum);

void setStreamStatusObject(Value object);

void streamsSelectedAdd(Stream stream);

uint streamsSelectedGetSize();

Stream streamsSelectedGetStream(uint idx);

Structure writableStructure();

static string typeGetName(GstMessageType type);

static GQuark typeToQuark(GstMessageType type);

}

Constructors

this this(GstMessage* gstMessage, bool ownedRef): Sets our main struct and passes it to the parent class.
this this(ObjectGst src, Structure structure): Create a new application-typed message. GStreamer will never create these messages; they are a gift from us to you. Enjoy.
this this(ObjectGst src, GstClockTime runningTime): 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.
this this(ObjectGst src, int 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.
this this(ObjectGst src, Clock clock): Create a clock lost message. This message is posted whenever the clock is not valid anymore.
this this(ObjectGst src, Clock clock, bool 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 this(GstMessageType type, ObjectGst src, Structure 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.
this this(ObjectGst src, Device device, Device changedDevice): Creates a new device-changed message. The device-changed message is produced by gstreamer.DeviceProvider or a gstreamer.DeviceMonitor They announce that a device properties has changed and device represent the new modified version of changed_device.
this this(ObjectGst src, Context context): This message is posted when an element has a new local gstreamer.Context
this this(ObjectGst src, string contextType): This message is posted when an element needs a specific gstreamer.Context
this this(ObjectGst src, GstProgressType type, string code, string text): Progress messages are posted by elements when they use an asynchronous task to perform actions triggered by a state change.
this this(ObjectGst src, string propertyName, Value val)
this this(ObjectGst src, bool live, ulong runningTime, ulong streamTime, ulong timestamp, ulong 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 this(ObjectGst src, string location, TagList tagList, Structure entryStruct): 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.
this this(ObjectGst 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.
this this(ObjectGst src, GstState oldstate, GstState newstate, GstState pending): Create a state change message. This message is posted whenever an element changed its state.
this this(ObjectGst src, GstFormat format, ulong amount, double rate, bool flush, bool intermediate, ulong duration, bool eos): This message is posted by elements when they complete a part, when intermediate set to TRUE, or a complete step operation.
this this(ObjectGst src, bool active, GstFormat format, ulong amount, double rate, bool flush, bool intermediate): This message is posted by elements when they accept or activate a new step event for amount in format.
this this(ObjectGst 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.
this this(ObjectGst src, GstStreamStatusType type, Element owner): Create a new stream status message. This message is posted when a streaming thread is created/destroyed or when the state changed.
this this(ObjectGst src, GstStructureChangeType type, Element owner, bool 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.
this this(ObjectGst src, TagList tagList): 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.
this this(ObjectGst src, Toc toc, bool updated): Create a new TOC message. The message is posted by elements that discovered or updated a TOC.

Members

Functions

addRedirectEntry void addRedirectEntry(string location, TagList tagList, Structure entryStruct): Creates and appends a new entry.
getMessageStruct GstMessage* getMessageStruct(bool transferOwnership): Get the main Gtk struct
getNumRedirectEntries size_t getNumRedirectEntries()
getSeqnum uint getSeqnum(): Retrieve the sequence number of a message.
getStreamStatusObject Value getStreamStatusObject(): Extracts the object managing the streaming thread from message.
getStruct void* getStruct(): the main Gtk struct as a void*
getStructure Structure getStructure(): Access the structure of the message.
hasName bool hasName(string name): Checks if message has the given name. This function is usually used to check the name of a custom message.
parseAsyncDone void parseAsyncDone(GstClockTime runningTime): Extract the running_time from the async_done message.
parseBuffering void parseBuffering(int percent): Extracts the buffering percent from the GstMessage. see also Message.newBuffering.
parseBufferingStats void parseBufferingStats(GstBufferingMode mode, int avgIn, int avgOut, long bufferingLeft): Extracts the buffering stats values from message.
parseClockLost void parseClockLost(Clock clock): Extracts the lost clock from the GstMessage. The clock object returned remains valid until the message is freed.
parseClockProvide void parseClockProvide(Clock clock, bool ready): Extracts the clock and ready flag from the GstMessage. The clock object returned remains valid until the message is freed.
parseContextType bool parseContextType(string contextType): Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.
parseDeviceAdded void parseDeviceAdded(Device device): Parses a device-added message. The device-added message is produced by gstreamer.DeviceProvider or a gstreamer.DeviceMonitor It announces the appearance of monitored devices.
parseDeviceChanged void parseDeviceChanged(Device device, Device changedDevice): Parses a device-changed message. The device-changed message is produced by gstreamer.DeviceProvider or a gstreamer.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.
parseDeviceRemoved void parseDeviceRemoved(Device device): Parses a device-removed message. The device-removed message is produced by gstreamer.DeviceProvider or a gstreamer.DeviceMonitor It announces the disappearance of monitored devices.
parseError void parseError(ErrorG gerror, string 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.
parseErrorDetails void parseErrorDetails(Structure structure): Returns the optional details structure, may be NULL if none. The returned structure must not be freed.
parseGroupId bool parseGroupId(uint groupId): Extract the group from the STREAM_START message.
parseHaveContext void parseHaveContext(Context context): Extract the context from the HAVE_CONTEXT message.
parseInfo void parseInfo(ErrorG gerror, string 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.
parseInfoDetails void parseInfoDetails(Structure structure): Returns the optional details structure, may be NULL if none The returned structure must not be freed.
parseNewClock void parseNewClock(Clock clock): Extracts the new clock from the GstMessage. The clock object returned remains valid until the message is freed.
parseProgress void parseProgress(GstProgressType type, string code, string text): Parses the progress type, code and text.
parsePropertyNotify void parsePropertyNotify(ObjectGst object, string propertyName, Value propertyValue): Parses a property-notify message. These will be posted on the bus only when set up with Element.addPropertyNotifyWatch or Element.addPropertyDeepNotifyWatch.
parseQos void parseQos(bool live, ulong runningTime, ulong streamTime, ulong timestamp, ulong duration): Extract the timestamps and live status from the QoS message.
parseQosStats void parseQosStats(GstFormat format, ulong processed, ulong dropped): Extract the QoS stats representing the history of the current continuous pipeline playback period.
parseQosValues void parseQosValues(long jitter, double proportion, int quality): Extract the QoS values that have been calculated/analysed from the QoS data
parseRedirectEntry void parseRedirectEntry(size_t entryIndex, string location, TagList tagList, Structure entryStruct): Parses the location and/or structure from the entry with the given index. The index must be between 0 and Message.getNumRedirectEntries - 1. Returned pointers are valid for as long as this message exists.
parseRequestState void parseRequestState(GstState state): Extract the requested state from the request_state message.
parseResetTime void parseResetTime(GstClockTime runningTime): Extract the running-time from the RESET_TIME message.
parseSegmentDone void parseSegmentDone(GstFormat format, long position): Extracts the position and format from the segment done message.
parseSegmentStart void parseSegmentStart(GstFormat format, long position): Extracts the position and format from the segment start message.
parseStateChanged void parseStateChanged(GstState oldstate, GstState newstate, GstState pending): Extracts the old and new states from the GstMessage.
parseStepDone void parseStepDone(GstFormat format, ulong amount, double rate, bool flush, bool intermediate, ulong duration, bool eos): Extract the values the step_done message.
parseStepStart void parseStepStart(bool active, GstFormat format, ulong amount, double rate, bool flush, bool intermediate): Extract the values from step_start message.
parseStreamCollection void parseStreamCollection(StreamCollection collection): Parses a stream-collection message.
parseStreamStatus void parseStreamStatus(GstStreamStatusType type, Element 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.
parseStreamsSelected void parseStreamsSelected(StreamCollection collection): Parses a streams-selected message.
parseStructureChange void parseStructureChange(GstStructureChangeType type, Element owner, bool busy): Extracts the change type and completion status from the GstMessage.
parseTag void parseTag(TagList tagList): Extracts the tag list from the GstMessage. The tag list returned in the output argument is a copy; the caller must free it when done.
parseToc void parseToc(Toc toc, bool updated): Extract the TOC from the gstreamer.Message The TOC returned in the output argument is a copy; the caller must free it with Toc.unref when done.
parseWarning void parseWarning(ErrorG gerror, string 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.
parseWarningDetails void parseWarningDetails(Structure structure): Returns the optional details structure, may be NULL if none The returned structure must not be freed.
setBufferingStats void setBufferingStats(GstBufferingMode mode, int avgIn, int avgOut, long bufferingLeft): Configures the buffering stats values in message.
setGroupId void setGroupId(uint groupId): Sets the group id on the stream-start message.
setQosStats void setQosStats(GstFormat format, ulong processed, ulong dropped): Set the QoS stats representing the history of the current continuous pipeline playback period.
setQosValues void setQosValues(long jitter, double proportion, int quality): Set the QoS values that have been calculated/analysed from the QoS data
setSeqnum void setSeqnum(uint seqnum): Set the sequence number of a message.
setStreamStatusObject void setStreamStatusObject(Value object): Configures the object handling the streaming thread. This is usually a GstTask object but other objects might be added in the future.
src ObjectGst src(): Get the src (the element that originated the message) of the message.
streamsSelectedAdd void streamsSelectedAdd(Stream stream): Adds the stream to the message.
streamsSelectedGetSize uint streamsSelectedGetSize(): Returns the number of streams contained in the message.
streamsSelectedGetStream Stream streamsSelectedGetStream(uint idx): Retrieves the gstreamer.Stream with index index from the message.
type GstMessageType type(): Get the type of the message.
writableStructure Structure writableStructure(): Get a writable version of the structure.

Static functions

getType GType getType()
newAsyncDone Message newAsyncDone(ObjectGst src, GstClockTime runningTime): 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.
newAsyncStart Message newAsyncStart(ObjectGst src): This message is posted by elements when they start an ASYNC state change.
newDeviceAdded Message newDeviceAdded(ObjectGst src, Device device): Creates a new device-added message. The device-added message is produced by gstreamer.DeviceProvider or a gstreamer.DeviceMonitor They announce the appearance of monitored devices.
newDeviceRemoved Message newDeviceRemoved(ObjectGst src, Device device): Creates a new device-removed message. The device-removed message is produced by gstreamer.DeviceProvider or a gstreamer.DeviceMonitor They announce the disappearance of monitored devices.
newDurationChanged Message newDurationChanged(ObjectGst 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. Elements may post a duration message with a duration of GST_CLOCK_TIME_NONE to indicate that the duration has changed and the cached duration should be discarded. The new duration can then be retrieved via a query.
newEOS Message newEOS(ObjectGst 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. MT safe.
newElement Message newElement(ObjectGst src, Structure 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. MT safe.
newError Message newError(ObjectGst src, ErrorG error, string dbug): Create a new error message. The message will copy error and debug. This message is posted by element when a fatal event occured. The pipeline will probably (partially) stop. The application receiving this message should stop the pipeline. MT safe.
newErrorWithDetails Message newErrorWithDetails(ObjectGst src, ErrorG error, string dbg, Structure 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.
newInfo Message newInfo(ObjectGst src, ErrorG error, string dbug): Create a new info message. The message will make copies of error and debug. MT safe. Since 0.10.12
newInfoWithDetails Message newInfoWithDetails(ObjectGst src, ErrorG error, string dbg, Structure details): Create a new info message. The message will make copies of error and debug.
newLatency Message newLatency(ObjectGst src): This message can be posted by elements when their latency requirements have changed.
newNewClock Message newNewClock(ObjectGst src, Clock clock): Create a new clock message. This message is posted whenever the pipeline selectes a new clock for the pipeline. MT safe.
newSegmentDone Message newSegmentDone(ObjectGst src, GstFormat format, long 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. MT safe.
newSegmentStart Message newSegmentStart(ObjectGst src, GstFormat format, long 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. MT safe.
newStateDirty Message newStateDirty(ObjectGst 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. MT safe.
newStreamCollection Message newStreamCollection(ObjectGst src, StreamCollection collection): Creates a new stream-collection message. The message is used to announce new gstreamer.StreamCollection
newStreamsSelected Message newStreamsSelected(ObjectGst src, StreamCollection 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.
newWarning Message newWarning(ObjectGst src, ErrorG error, string dbug): Create a new warning message. The message will make copies of error and debug. MT safe.
newWarningWithDetails Message newWarningWithDetails(ObjectGst src, ErrorG error, string dbg, Structure details): Create a new warning message. The message will make copies of error and debug.
typeGetName string typeGetName(GstMessageType type): Get a printable name for the given message type. Do not modify or free.
typeToQuark GQuark typeToQuark(GstMessageType type): Get the unique quark for the given message type.

Variables

gstMessage GstMessage* gstMessage;: the main Gtk struct

gstreamer Message classes

Message