Gst Namespace Reference


Classes

class  Bin
class  Bus
class  Caps
class  ClockID
class  Clock
class  Element
class  CoreError
class  LibraryError
class  ResourceError
class  StreamError
class  Event
class  EventBufferSize
class  EventCustom
class  EventEos
class  EventFlushStart
class  EventFlushStop
class  EventLatency
class  EventNavigation
class  EventNewSegment
class  EventQos
class  EventSeek
class  EventTag
struct  FormatDefinition
class  Iterator
class  Message
class  MessageApplication
class  MessageClockProvide
class  MessageClockLost
class  MessageCustom
class  MessageElement
class  MessageEos
class  MessageError
class  MessageInfo
class  MessageNewClock
class  MessageSegmentDone
class  MessageSegmentStart
class  MessageStateChanged
class  MessageBuffering
class  MessageWarning
class  MessageDuration
class  MessageStateDirty
class  MessageAsyncStart
class  MessageAsyncDone
class  MessageLatency
class  MiniObject
class  Object
class  Pad
class  PadTemplate
class  Pipeline
struct  QueryTypeDefinition
class  Query
class  QueryConvert
class  QueryPosition
class  QueryDuration
class  QueryLatency
class  QuerySeeking
class  QueryFormats
class  QuerySegment
class  Fraction
class  StructureValueProxy
class  Structure
class  SystemClock
class  XML

Typedefs

typedef GstClockTime ClockTime
typedef GstClockTimeDiff ClockTimeDiff
typedef Gst::MiniObject *(*) WrapNewFunction (GstMiniObject *)

Enumerations

enum  BusSyncReply { BUS_DROP, BUS_PASS, BUS_ASYNC }
enum  ClockEntryType { CLOCK_ENTRY_SINGLE, CLOCK_ENTRY_PERIODIC }
enum  ClockReturn {
  CLOCK_OK, CLOCK_EARLY, CLOCK_UNSCHEDULED, CLOCK_BUSY,
  CLOCK_BADTIME, CLOCK_ERROR, CLOCK_UNSUPPORTED
}
enum  EventType {
  EVENT_UNKNOWN = GST_EVENT_UNKNOWN, EVENT_FLUSH_START = GST_EVENT_FLUSH_START, EVENT_FLUSH_STOP = GST_EVENT_FLUSH_STOP, EVENT_EOS = GST_EVENT_EOS,
  EVENT_NEWSEGMENT = GST_EVENT_NEWSEGMENT, EVENT_TAG = GST_EVENT_TAG, EVENT_BUFFERSIZE = GST_EVENT_BUFFERSIZE, EVENT_QOS = GST_EVENT_QOS,
  EVENT_SEEK = GST_EVENT_SEEK, EVENT_NAVIGATION = GST_EVENT_NAVIGATION, EVENT_LATENCY = GST_EVENT_LATENCY, EVENT_CUSTOM_UPSTREAM = GST_EVENT_CUSTOM_UPSTREAM,
  EVENT_CUSTOM_DOWNSTREAM = GST_EVENT_CUSTOM_DOWNSTREAM, EVENT_CUSTOM_DOWNSTREAM_OOB = GST_EVENT_CUSTOM_DOWNSTREAM_OOB, EVENT_CUSTOM_BOTH = GST_EVENT_CUSTOM_BOTH, EVENT_CUSTOM_BOTH_OOB = GST_EVENT_CUSTOM_BOTH_OOB
}
enum  Format {
  FORMAT_UNDEFINED, FORMAT_DEFAULT, FORMAT_BYTES, FORMAT_TIME,
  FORMAT_BUFFERS, FORMAT_PERCENT
}
enum  IteratorItem { ITERATOR_ITEM_SKIP, ITERATOR_ITEM_PASS, ITERATOR_ITEM_END }
enum  IteratorResult { ITERATOR_DONE, ITERATOR_OK, ITERATOR_RESYNC, ITERATOR_ERROR }
enum  MessageType {
  MESSAGE_UNKNOWN = 0, MESSAGE_EOS = (1 << 0), MESSAGE_ERROR = (1 << 1), MESSAGE_WARNING = (1 << 2),
  MESSAGE_INFO = (1 << 3), MESSAGE_TAG = (1 << 4), MESSAGE_BUFFERING = (1 << 5), MESSAGE_STATE_CHANGED = (1 << 6),
  MESSAGE_STATE_DIRTY = (1 << 7), MESSAGE_STEP_DONE = (1 << 8), MESSAGE_CLOCK_PROVIDE = (1 << 9), MESSAGE_CLOCK_LOST = (1 << 10),
  MESSAGE_NEW_CLOCK = (1 << 11), MESSAGE_STRUCTURE_CHANGE = (1 << 12), MESSAGE_STREAM_STATUS = (1 << 13), MESSAGE_APPLICATION = (1 << 14),
  MESSAGE_ELEMENT = (1 << 15), MESSAGE_SEGMENT_START = (1 << 16), MESSAGE_SEGMENT_DONE = (1 << 17), MESSAGE_DURATION = (1 << 18),
  MESSAGE_LATENCY = (1 << 19), MESSAGE_ASYNC_START = (1 << 20), MESSAGE_ASYNC_DONE = (1 << 21), MESSAGE_ANY = ~0
}
enum  MessageTypeApplication { DUMMY_MESSAGE_APPLICATION = (1 << 14) }
enum  MessageTypeAsyncDone { DUMMY_MESSAGE_ASYNC_DONE = (1 << 21) }
enum  MessageTypeAsyncStart { DUMMY_MESSAGE_ASYNC_START = (1 << 20) }
enum  MessageTypeBuffering { DUMMY_MESSAGE_BUFFERING = (1 << 5) }
enum  MessageTypeClockLost { DUMMY_MESSAGE_CLOCK_LOST = (1 << 10) }
enum  MessageTypeClockProvide { DUMMY_MESSAGE_CLOCK_PROVIDE = (1 << 9) }
enum  MessageTypeDuration { DUMMY_MESSAGE_DURATION = (1 << 18) }
enum  MessageTypeElement { DUMMY_MESSAGE_ELEMENT = (1 << 15) }
enum  MessageTypeEos { DUMMY_MESSAGE_EOS = (1 << 0) }
enum  MessageTypeError { DUMMY_MESSAGE_ERROR = (1 << 1) }
enum  MessageTypeInfo { DUMMY_MESSAGE_INFO = (1 << 3) }
enum  MessageTypeLatency { DUMMY_MESSAGE_LATENCY = (1 << 19) }
enum  MessageTypeNewClock { DUMMY_MESSAGE_NEW_CLOCK = (1 << 11) }
enum  MessageTypeTag { DUMMY_MESSAGE_TAG = (1 << 4) }
enum  MessageTypeStateChanged { DUMMY_MESSAGE_STATE_CHANGED = (1 << 6) }
enum  MessageTypeStateDirty { DUMMY_MESSAGE_STATE_DIRTY = (1 << 7) }
enum  MessageTypeSegmentDone { DUMMY_MESSAGE_SEGMENT_DONE = (1 << 17) }
enum  MessageTypeSegmentStart { DUMMY_MESSAGE_SEGMENT_START = (1 << 16) }
enum  MessageTypeWarning { DUMMY_MESSAGE_WARNING = (1 << 2) }
enum  PadDirection { PAD_UNKNOWN, PAD_SRC, PAD_SINK }
enum  PadLinkReturn {
  PAD_LINK_OK = 0, PAD_LINK_WRONG_HIERARCHY = -1, PAD_LINK_WAS_LINKED = -2, PAD_LINK_WRONG_DIRECTION = -3,
  PAD_LINK_NOFORMAT = -4, PAD_LINK_NOSCHED = -5, PAD_LINK_REFUSED = -6
}
enum  PadPresence { PAD_ALWAYS, PAD_SOMETIMES, PAD_REQUEST }
enum  QueryType {
  QUERY_NONE, QUERY_POSITION, QUERY_DURATION, QUERY_LATENCY,
  QUERY_JITTER, QUERY_RATE, QUERY_SEEKING, QUERY_SEGMENT,
  QUERY_CONVERT, QUERY_FORMATS
}
enum  SeekFlags {
  SEEK_FLAG_NONE = 0, SEEK_FLAG_FLUSH = (1 << 0), SEEK_FLAG_ACCURATE = (1 << 1), SEEK_FLAG_KEY_UNIT = (1 << 2),
  SEEK_FLAG_SEGMENT = (1 << 3)
}
enum  SeekType { SEEK_TYPE_NONE, SEEK_TYPE_CUR, SEEK_TYPE_SET, SEEK_TYPE_END }
enum  State {
  STATE_VOID_PENDING, STATE_NULL, STATE_READY, STATE_PAUSED,
  STATE_PLAYING
}
enum  StateChange {
  STATE_CHANGE_NULL_TO_READY = GST_STATE_CHANGE_NULL_TO_READY, STATE_CHANGE_READY_TO_PAUSED = GST_STATE_CHANGE_READY_TO_PAUSED, STATE_CHANGE_PAUSED_TO_PLAYING = GST_STATE_CHANGE_PAUSED_TO_PLAYING, STATE_CHANGE_PLAYING_TO_PAUSED = GST_STATE_CHANGE_PLAYING_TO_PAUSED,
  STATE_CHANGE_PAUSED_TO_READY = GST_STATE_CHANGE_PAUSED_TO_READY, STATE_CHANGE_READY_TO_NULL = GST_STATE_CHANGE_READY_TO_NULL
}
enum  StateChangeReturn { STATE_CHANGE_FAILURE, STATE_CHANGE_SUCCESS, STATE_CHANGE_ASYNC, STATE_CHANGE_NO_PREROLL }
enum  TagMergeMode {
  TAG_MERGE_UNDEFINED, TAG_MERGE_REPLACE_ALL, TAG_MERGE_REPLACE, TAG_MERGE_APPEND,
  TAG_MERGE_PREPEND, TAG_MERGE_KEEP, TAG_MERGE_KEEP_ALL, TAG_MERGE_COUNT
}
enum  TagFlag {
  TAG_FLAG_UNDEFINED, TAG_FLAG_META, TAG_FLAG_ENCODED, TAG_FLAG_DECODED,
  TAG_FLAG_COUNT
}

Functions

guint get_hours (ClockTime time)
guint get_minutes (ClockTime time)
guint get_seconds (ClockTime time)
guint get_milliseconds (ClockTime time)
guint get_microseconds (ClockTime time)
guint get_nanoseconds (ClockTime time)
guint get_fractional_seconds (ClockTime time)
Glib::ustring get_name (EventType t)
Glib::ustring get_name (Format f)
Glib::ustring get_name (MessageType t)
Glib::ustring get_name (QueryType t)
Glib::ustring get_name (State s)
Glib::ustring get_name (StateChangeReturn s)
Glib::QueryQuark get_quark (EventType t)
Glib::QueryQuark get_quark (Format f)
Glib::QueryQuark get_quark (MessageType t)
Glib::QueryQuark get_quark (QueryType t)
Format register_format (const Glib::ustring &nick, const Glib::ustring &description)
Format get_format (const Glib::ustring &nick)
bool get_details (Format format, FormatDefinition &def)
void gst_wrap_init ()
void init (int &argc, char **&argv)
bool init_check (int &argc, char **&argv, Glib::Error &error)
Glib::OptionGroup init_get_option_group ()
void version (guint &major, guint &minor, guint &micro)
void wrap_register_init ()
void wrap_register_cleanup ()
void wrap_register (GType type, WrapNewFunction func)
Gst::MiniObjectwrap_auto (GstMiniObject *object, bool take_copy=false)
Gst::MiniObjectwrap_create_new_wrapper_for_interface (GstMiniObject *object, GType interface_gtype)
template<class TInterface>
TInterface * wrap_auto_interface (GstMiniObject *object, bool take_copy=false)
template<class T>
T::BaseObjectType * unwrap (T *ptr)
template<class T>
const T::BaseObjectType * unwrap (const T *ptr)
template<class T>
T::BaseObjectType * unwrap (const Glib::RefPtr< T > &ptr)
template<class T>
const T::BaseObjectType * unwrap (const Glib::RefPtr< const T > &ptr)
template<class T>
T::BaseObjectType * unwrap_copy (const Glib::RefPtr< T > &ptr)
template<class T>
const T::BaseObjectType * unwrap_copy (const Glib::RefPtr< const T > &ptr)
void wrap_init ()
xmlDocPtr write_xml (const Glib::RefPtr< Element > &element)
int write_xml_file (const Glib::RefPtr< Element > &element, const std::string &filename)
Glib::RefPtr< Elementmake_element (const xmlNodePtr &xml_node, const Glib::RefPtr< Object > &parent)

Variables

const ClockTime CLOCK_TIME_NONE = GST_CLOCK_TIME_NONE
GLIBMM_API GQuark quark_
GLIBMM_API GQuark quark_cpp_wrapper_deleted_


Typedef Documentation

typedef GstClockTime Gst::ClockTime

typedef GstClockTimeDiff Gst::ClockTimeDiff

typedef Gst::MiniObject*(*) Gst::WrapNewFunction(GstMiniObject *)


Enumeration Type Documentation

enum Gst::EventType

Enumerator:
EVENT_UNKNOWN 
EVENT_FLUSH_START 
EVENT_FLUSH_STOP 
EVENT_EOS 
EVENT_NEWSEGMENT 
EVENT_TAG 
EVENT_BUFFERSIZE 
EVENT_QOS 
EVENT_SEEK 
EVENT_NAVIGATION 
EVENT_LATENCY 
EVENT_CUSTOM_UPSTREAM 
EVENT_CUSTOM_DOWNSTREAM 
EVENT_CUSTOM_DOWNSTREAM_OOB 
EVENT_CUSTOM_BOTH 
EVENT_CUSTOM_BOTH_OOB 

enum Gst::MessageType

Enumerator:
MESSAGE_UNKNOWN 
MESSAGE_EOS 
MESSAGE_ERROR 
MESSAGE_WARNING 
MESSAGE_INFO 
MESSAGE_TAG 
MESSAGE_BUFFERING 
MESSAGE_STATE_CHANGED 
MESSAGE_STATE_DIRTY 
MESSAGE_STEP_DONE 
MESSAGE_CLOCK_PROVIDE 
MESSAGE_CLOCK_LOST 
MESSAGE_NEW_CLOCK 
MESSAGE_STRUCTURE_CHANGE 
MESSAGE_STREAM_STATUS 
MESSAGE_APPLICATION 
MESSAGE_ELEMENT 
MESSAGE_SEGMENT_START 
MESSAGE_SEGMENT_DONE 
MESSAGE_DURATION 
MESSAGE_LATENCY 
MESSAGE_ASYNC_START 
MESSAGE_ASYNC_DONE 
MESSAGE_ANY 

enum Gst::MessageTypeApplication

Enumerator:
DUMMY_MESSAGE_APPLICATION 

enum Gst::MessageTypeAsyncDone

Enumerator:
DUMMY_MESSAGE_ASYNC_DONE 

enum Gst::MessageTypeAsyncStart

Enumerator:
DUMMY_MESSAGE_ASYNC_START 

enum Gst::MessageTypeBuffering

Enumerator:
DUMMY_MESSAGE_BUFFERING 

enum Gst::MessageTypeClockLost

Enumerator:
DUMMY_MESSAGE_CLOCK_LOST 

enum Gst::MessageTypeClockProvide

Enumerator:
DUMMY_MESSAGE_CLOCK_PROVIDE 

enum Gst::MessageTypeDuration

Enumerator:
DUMMY_MESSAGE_DURATION 

enum Gst::MessageTypeElement

Enumerator:
DUMMY_MESSAGE_ELEMENT 

enum Gst::MessageTypeEos

Enumerator:
DUMMY_MESSAGE_EOS 

enum Gst::MessageTypeError

Enumerator:
DUMMY_MESSAGE_ERROR 

enum Gst::MessageTypeInfo

Enumerator:
DUMMY_MESSAGE_INFO 

enum Gst::MessageTypeLatency

Enumerator:
DUMMY_MESSAGE_LATENCY 

enum Gst::MessageTypeNewClock

Enumerator:
DUMMY_MESSAGE_NEW_CLOCK 

enum Gst::MessageTypeSegmentDone

Enumerator:
DUMMY_MESSAGE_SEGMENT_DONE 

enum Gst::MessageTypeSegmentStart

Enumerator:
DUMMY_MESSAGE_SEGMENT_START 

enum Gst::MessageTypeStateChanged

Enumerator:
DUMMY_MESSAGE_STATE_CHANGED 

enum Gst::MessageTypeStateDirty

Enumerator:
DUMMY_MESSAGE_STATE_DIRTY 

enum Gst::MessageTypeTag

Enumerator:
DUMMY_MESSAGE_TAG 

enum Gst::MessageTypeWarning

Enumerator:
DUMMY_MESSAGE_WARNING 

enum Gst::SeekFlags

Enumerator:
SEEK_FLAG_NONE 
SEEK_FLAG_FLUSH 
SEEK_FLAG_ACCURATE 
SEEK_FLAG_KEY_UNIT 
SEEK_FLAG_SEGMENT 

enum Gst::StateChange

Enumerator:
STATE_CHANGE_NULL_TO_READY 
STATE_CHANGE_READY_TO_PAUSED 
STATE_CHANGE_PAUSED_TO_PLAYING 
STATE_CHANGE_PLAYING_TO_PAUSED 
STATE_CHANGE_PAUSED_TO_READY 
STATE_CHANGE_READY_TO_NULL 


Function Documentation

bool Gst::get_details ( Format  format,
FormatDefinition &  def 
)

Format Gst::get_format ( const Glib::ustring &  nick  ) 

guint Gst::get_fractional_seconds ( ClockTime  time  ) 

guint Gst::get_hours ( ClockTime  time  ) 

guint Gst::get_microseconds ( ClockTime  time  ) 

guint Gst::get_milliseconds ( ClockTime  time  ) 

guint Gst::get_minutes ( ClockTime  time  ) 

Glib::ustring Gst::get_name ( StateChangeReturn  s  ) 

Glib::ustring Gst::get_name ( State  s  ) 

Glib::ustring Gst::get_name ( QueryType  t  ) 

Glib::ustring Gst::get_name ( MessageType  t  ) 

Glib::ustring Gst::get_name ( Format  f  ) 

Glib::ustring Gst::get_name ( EventType  t  ) 

guint Gst::get_nanoseconds ( ClockTime  time  ) 

Glib::QueryQuark Gst::get_quark ( QueryType  t  ) 

Glib::QueryQuark Gst::get_quark ( MessageType  t  ) 

Glib::QueryQuark Gst::get_quark ( Format  f  ) 

Glib::QueryQuark Gst::get_quark ( EventType  t  ) 

guint Gst::get_seconds ( ClockTime  time  ) 

void Gst::gst_wrap_init (  ) 

void Gst::init ( int &  argc,
char **&  argv 
)

bool Gst::init_check ( int &  argc,
char **&  argv,
Glib::Error &  error 
)

Glib::OptionGroup Gst::init_get_option_group (  ) 

Glib::RefPtr<Element> Gst::make_element ( const xmlNodePtr &  xml_node,
const Glib::RefPtr< Object > &  parent 
)

Format Gst::register_format ( const Glib::ustring &  nick,
const Glib::ustring &  description 
)

template<class T>
const T::BaseObjectType* Gst::unwrap ( const Glib::RefPtr< const T > &  ptr  )  [inline]

Get the underlying C instance from the C++ instance. This is just like calling gobj(), but it does its own check for a NULL pointer.

template<class T>
T::BaseObjectType* Gst::unwrap ( const Glib::RefPtr< T > &  ptr  )  [inline]

Get the underlying C instance from the C++ instance. This is just like calling gobj(), but it does its own check for a NULL pointer.

template<class T>
const T::BaseObjectType* Gst::unwrap ( const T *  ptr  )  [inline]

Get the underlying C instance from the C++ instance. This is just like calling gobj(), but it does its own check for a NULL pointer.

template<class T>
T::BaseObjectType* Gst::unwrap ( T *  ptr  )  [inline]

Get the underlying C instance from the C++ instance. This is just like calling gobj(), but it does its own check for a NULL pointer.

template<class T>
const T::BaseObjectType* Gst::unwrap_copy ( const Glib::RefPtr< const T > &  ptr  )  [inline]

Get the underlying C instance from the C++ instance and acquire a reference. This is just like calling gobj_copy(), but it does its own check for a NULL pointer.

template<class T>
T::BaseObjectType* Gst::unwrap_copy ( const Glib::RefPtr< T > &  ptr  )  [inline]

Get the underlying C instance from the C++ instance and acquire a reference. This is just like calling gobj_copy(), but it does its own check for a NULL pointer.

void Gst::version ( guint &  major,
guint &  minor,
guint &  micro 
)

Gst::MiniObject* Gst::wrap_auto ( GstMiniObject *  object,
bool  take_copy = false 
)

template<class TInterface>
TInterface* Gst::wrap_auto_interface ( GstMiniObject *  object,
bool  take_copy = false 
)

Gst::MiniObject* Gst::wrap_create_new_wrapper_for_interface ( GstMiniObject *  object,
GType  interface_gtype 
)

Create a C++ instance of a known C++ type that is mostly closely associated with the GType of the C object.

Parameters:
object The C object which should be placed in a new C++ instance.
interface_gtype The returned instance will implement this interface. Otherwise it will be NULL.

void Gst::wrap_init (  ) 

void Gst::wrap_register ( GType  type,
WrapNewFunction  func 
)

void Gst::wrap_register_cleanup (  ) 

void Gst::wrap_register_init (  ) 

xmlDocPtr Gst::write_xml ( const Glib::RefPtr< Element > &  element  ) 

int Gst::write_xml_file ( const Glib::RefPtr< Element > &  element,
const std::string &  filename 
)


Variable Documentation

const ClockTime Gst::CLOCK_TIME_NONE = GST_CLOCK_TIME_NONE

GLIBMM_API GQuark Gst::quark_

GLIBMM_API GQuark Gst::quark_cpp_wrapper_deleted_


Generated on Sat Jan 26 11:53:53 2008 for gstreamermm by  doxygen 1.5.1