gnomemm r1467 - in gstreamermm/trunk: . gstreamer/src tools/m4
- From: jaalburqu svn gnome org
- To: svn-commits-list gnome org
- Subject: gnomemm r1467 - in gstreamermm/trunk: . gstreamer/src tools/m4
- Date: Thu, 17 Apr 2008 22:30:24 +0100 (BST)
Author: jaalburqu
Date: Thu Apr 17 22:30:24 2008
New Revision: 1467
URL: http://svn.gnome.org/viewvc/gnomemm?rev=1467&view=rev
Log:
2008-04-17 Josà Alburquerque <jaalburqu svn gnome org>
Fully qualified Gst classes in doc blocks of following (and all *.hg
in this commit):
* gstreamer/src/bin.hg:
* gstreamer/src/buffer.hg:
* gstreamer/src/bus.hg:
* gstreamer/src/caps.hg:
* gstreamer/src/element.hg:
* gstreamer/src/elementfactory.hg:
* gstreamer/src/index.hg:
* gstreamer/src/indexfactory.hg:
* gstreamer/src/interface.hg:
* gstreamer/src/pad.hg:
* gstreamer/src/parse.hg:
* gstreamer/src/pipeline.hg:
* gstreamer/src/plugin.hg:
* gstreamer/src/pluginfeature.hg:
* gstreamer/src/ghostpad.hg: Fixed parameter name typo
* gstreamer/src/childproxy.ccg:
* gstreamer/src/childproxy.hg: Modified {set,get}_proxy_property()
methods to return RefPtr to ChildProxy; Added signal docs
* gstreamer/src/clock.hg:
* tools/m4/convert_gst.m4: Wrapped {get,set}_calibration() methods
* gstreamer/src/event.hg:
* gstreamer/src/message.hg: Added class docs
* gstreamer/src/padtemplate.ccg:
* gstreamer/src/padtemplate.hg:
* gstreamer/src/gst_enums.defs: Added class docs; Wrapped
PadTemplateFlags enum; Used _WRAP_CREATE() for create() method;
Wrapped members name_template, direction, and presence; Added signal
and create() docs
* gstreamer/src/filter.hg: Fixed whitespace
Modified:
gstreamermm/trunk/ChangeLog
gstreamermm/trunk/gstreamer/src/bin.hg
gstreamermm/trunk/gstreamer/src/buffer.hg
gstreamermm/trunk/gstreamer/src/bus.hg
gstreamermm/trunk/gstreamer/src/caps.hg
gstreamermm/trunk/gstreamer/src/childproxy.ccg
gstreamermm/trunk/gstreamer/src/childproxy.hg
gstreamermm/trunk/gstreamer/src/clock.hg
gstreamermm/trunk/gstreamer/src/element.hg
gstreamermm/trunk/gstreamer/src/elementfactory.hg
gstreamermm/trunk/gstreamer/src/event.hg
gstreamermm/trunk/gstreamer/src/filter.hg
gstreamermm/trunk/gstreamer/src/ghostpad.hg
gstreamermm/trunk/gstreamer/src/gst_enums.defs
gstreamermm/trunk/gstreamer/src/index.hg
gstreamermm/trunk/gstreamer/src/indexfactory.hg
gstreamermm/trunk/gstreamer/src/interface.hg
gstreamermm/trunk/gstreamer/src/message.hg
gstreamermm/trunk/gstreamer/src/pad.hg
gstreamermm/trunk/gstreamer/src/padtemplate.ccg
gstreamermm/trunk/gstreamer/src/padtemplate.hg
gstreamermm/trunk/gstreamer/src/parse.hg
gstreamermm/trunk/gstreamer/src/pipeline.hg
gstreamermm/trunk/gstreamer/src/plugin.hg
gstreamermm/trunk/gstreamer/src/pluginfeature.hg
gstreamermm/trunk/tools/m4/convert_gst.m4
Modified: gstreamermm/trunk/gstreamer/src/bin.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/bin.hg (original)
+++ gstreamermm/trunk/gstreamer/src/bin.hg Thu Apr 17 22:30:24 2008
@@ -32,15 +32,15 @@
//TODO: Correct statements about iterators in class docs below:
-/** Bin â Base class and element that can contain other elements.
- * Bin is an element that can contain other Element, allowing them to be
- * managed as a group. Pads from the child elements can be ghosted to the bin,
- * see GstGhostPad. This makes the bin look like any other elements and enables
- * creation of higher-level abstraction elements.
- *
- * A new Bin is created with create(). Use a Pipeline instead if you want to
- * create a toplevel bin because a normal bin doesn't have a bus or handle
- * clock distribution of its own.
+/** Gst::Bin â Base class and element that can contain other elements.
+ * Gst::Bin is an element that can contain other Gst::Element, allowing them to
+ * be managed as a group. Pads from the child elements can be ghosted to the
+ * bin, see Gst::GhostPad. This makes the bin look like any other elements and
+ * enables creation of higher-level abstraction elements.
+ *
+ * A new Gst::Bin is created with create(). Use a Gst::Pipeline instead if you
+ * want to create a toplevel bin because a normal bin doesn't have a bus or
+ * handle clock distribution of its own.
*
* After the bin has been created you will typically add elements to it with
* add(). You can remove elements with remove().
@@ -59,35 +59,35 @@
*
* Notes:
*
- * A Bin internally intercepts every Message posted by its children and
- * implements the following default behaviour for each of them:
+ * A Gst::Bin internally intercepts every Gst::Message posted by its children
+ * and implements the following default behaviour for each of them:
*
- * MESSAGE_EOS - This message is only posted by sinks in the PLAYING state. If
- * all sinks posted the EOS message, this bin will post and EOS message
- * upwards.
+ * Gst::MESSAGE_EOS - This message is only posted by sinks in the PLAYING
+ * state. If all sinks posted the EOS message, this bin will post and EOS
+ * message upwards.
*
- * MESSAGE_SEGMENT_START - just collected and never forwarded upwards. The
+ * Gst::MESSAGE_SEGMENT_START - just collected and never forwarded upwards. The
* messages are used to decide when all elements have completed playback of
* their segment.
*
- * MESSAGE_SEGMENT_DONE - Is posted by Bin when all elements that posted a
- * SEGMENT_START have posted a SEGMENT_DONE.
+ * Gst::MESSAGE_SEGMENT_DONE - Is posted by Gst::Bin when all elements that
+ * posted a SEGMENT_START have posted a SEGMENT_DONE.
*
- * MESSAGE_DURATION - Is posted by an element that detected a change in the
- * stream duration. The default bin behaviour is to clear any cached duration
- * values so that the next duration query will perform a full duration
+ * Gst::MESSAGE_DURATION - Is posted by an element that detected a change in
+ * the stream duration. The default bin behaviour is to clear any cached
+ * duration values so that the next duration query will perform a full duration
* recalculation. The duration change is posted to the application so that it
* can refetch the new duration with a duration query.
*
- * MESSAGE_CLOCK_LOST - This message is posted by an element when it can no
- * longer provide a clock. The default bin behaviour is to check if the lost
+ * Gst::MESSAGE_CLOCK_LOST - This message is posted by an element when it can
+ * no longer provide a clock. The default bin behaviour is to check if the lost
* clock was the one provided by the bin. If so and the bin is currently in the
* PLAYING state, the message is forwarded to the bin parent. This message is
* also generated when a clock provider is removed from the bin. If this
* message is received by the application, it should PAUSE the pipeline and set
* it back to PLAYING to force a new clock distribution.
*
- * MESSAGE_CLOCK_PROVIDE - This message is generated when an element can
+ * Gst::MESSAGE_CLOCK_PROVIDE - This message is generated when an element can
* provide a clock. This mostly happens when a new clock provider is added to
* the bin. The default behaviour of the bin is to mark the currently selected
* clock as dirty, which will perform a clock recalculation the next time the
@@ -96,26 +96,28 @@
*
* OTHERS - posted upwards.
- * A Bin implements the following default behaviour for answering to a Query:
+ * A Gst::Bin implements the following default behaviour for answering to a
+ * Gst::Query:
*
- * QUERY_DURATION - If the query has been asked before with the same format and
- * the bin is a toplevel bin (ie. has no parent), use the cached previous
- * value. If no previous value was cached, the query is sent to all sink
- * elements in the bin and the MAXIMUM of all values is returned. If the bin is
- * a toplevel bin the value is cached. If no sinks are available in the bin,
- * the query fails.
+ * Gst::QUERY_DURATION - If the query has been asked before with the same
+ * format and the bin is a toplevel bin (ie. has no parent), use the cached
+ * previous value. If no previous value was cached, the query is sent to all
+ * sink elements in the bin and the MAXIMUM of all values is returned. If the
+ * bin is a toplevel bin the value is cached. If no sinks are available in the
+ * bin, the query fails.
*
- * QUERY_POSITION - The query is sent to all sink elements in the bin and the
- * MAXIMUM of all values is returned. If no sinks are available in the bin, the
- * query fails.
+ * Gst::QUERY_POSITION - The query is sent to all sink elements in the bin and
+ * the MAXIMUM of all values is returned. If no sinks are available in the bin,
+ * the query fails.
*
* OTHERS - the query is forwarded to all sink elements, the result of the
* first sink that answers the query successfully is returned. If no sink is in
* the bin, the query fails.
*
- * A Bin will by default forward any event sent to it to all sink elements. If
- * all the sinks return TRUE, the bin will also return TRUE, else FALSE is
- * returned. If no sinks are in the bin, the event handler will return TRUE.
+ * A Gst::Bin will by default forward any event sent to it to all sink
+ * elements. If all the sinks return TRUE, the bin will also return TRUE, else
+ * FALSE is returned. If no sinks are in the bin, the event handler will return
+ * TRUE.
*
* Last reviewed on 2006-04-28 (0.10.6)
*/
@@ -146,7 +148,7 @@
* MT safe.
*
* @param element the Gst::Element to add
- * @return this Gst::Bin (for further adding if wanted) if successful, NULL
+ * @return this Gst::Bin if successful (for further adding if wanted), NULL
* otherwise
*/
Glib::RefPtr<Bin> add(const Glib::RefPtr<Element>& element);
@@ -162,7 +164,7 @@
* MT safe.
*
* element the Gst::Element to remove
- * Returns this Gst::Bin (for further removing if wanted) if successful, NULL
+ * Returns this Gst::Bin if successful (for further removing if wanted), NULL
* otherwise
*/
Glib::RefPtr<Bin> remove(const Glib::RefPtr<Element>& element);
Modified: gstreamermm/trunk/gstreamer/src/buffer.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/buffer.hg (original)
+++ gstreamermm/trunk/gstreamer/src/buffer.hg Thu Apr 17 22:30:24 2008
@@ -32,10 +32,10 @@
_WRAP_ENUM(BufferFlag, GstBufferFlag)
_WRAP_ENUM(BufferCopyFlags, GstBufferCopyFlags)
-/** Buffer â Data-passing buffer type, supporting sub-buffers.
- * Buffers are the basic unit of data transfer in GStreamer. The Buffer type
- * provides all the state necessary to define a region of memory as part of a
- * stream. Sub-buffers are also supported, allowing a smaller region of a
+/** Gst::Buffer â Data-passing buffer type, supporting sub-buffers.
+ * Buffers are the basic unit of data transfer in GStreamer. The Gst::Buffer
+ * type provides all the state necessary to define a region of memory as part
+ * of a stream. Sub-buffers are also supported, allowing a smaller region of a
* buffer to become its own buffer, with mechanisms in place to ensure that
* neither memory space goes away prematurely.
*
@@ -104,14 +104,15 @@
_MEMBER_GET(size, size, guint, guint)
/** Get the timestamp of this buffer.
- * @return The timestamp in nanoseconds (as a GstClockTime) of the data in
- * the buffer. Value will be CLOCK_TIME_NONE if the timestamp is unknown.
+ * @return The timestamp in nanoseconds (as a Gst::ClockTime) of the data in
+ * the buffer. Value will be Gst::CLOCK_TIME_NONE if the timestamp is
+ * unknown.
*/
_MEMBER_GET(timestamp, timestamp, ClockTime, GstClockTime)
/** Get duration of this buffer.
- * @return he duration in nanoseconds (as a GstClockTime) of the data in the
- * buffer. Value will be CLOCK_TIME_NONE if the duration is unknown.
+ * @return he duration in nanoseconds (as a Gst::ClockTime) of the data in
+ * the buffer. Value will be Gst::CLOCK_TIME_NONE if the duration is unknown.
*/
_MEMBER_GET(duration, duration, ClockTime, GstClockTime)
Modified: gstreamermm/trunk/gstreamer/src/bus.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/bus.hg (original)
+++ gstreamermm/trunk/gstreamer/src/bus.hg Thu Apr 17 22:30:24 2008
@@ -36,16 +36,16 @@
//TODO: Correct C API reference in class docs below:
-/** Bus â Asynchronous message bus subsystem.
- * The Bus is an object responsible for delivering Messages in a first-in
+/** Gst::Bus â Asynchronous message bus subsystem.
+ * The Gst::Bus is an object responsible for delivering Messages in a first-in
* first-out way from the streaming threads to the application.
*
* Since the application typically only wants to deal with delivery of these
- * messages from one thread, the Bus will marshall the messages between
+ * messages from one thread, the Gst::Bus will marshall the messages between
* different threads. This is important since the actual streaming of media is
* done in another thread than the application.
*
- * The Bus provides support for GSource based notifications. This makes it
+ * The Gst::Bus provides support for GSource based notifications. This makes it
* possible to handle the delivery in the glib mainloop.
*
* The GSource callback function gst_bus_async_signal_func() can be used to
@@ -69,10 +69,10 @@
* This should only be used if the application is able to deal with messages
* from different threads.
*
- * Every Pipeline has one bus.
+ * Every Gst::Pipeline has one bus.
*
- * Note that a Pipeline will set its bus into flushing state when changing from
- * READY to NULL state.
+ * Note that a Gst::Pipeline will set its bus into flushing state when changing
+ * from READY to NULL state.
*
* Last reviewed on 2006-03-12 (0.10.5)
*/
@@ -85,16 +85,16 @@
public:
/** For example,
- * bool on_bus_message(const Glib::RefPtr<Bus>& bus, const
- * Glib::RefPtr<Message>& message);
+ * bool on_bus_message(const Glib::RefPtr<Gst::Bus>& bus, const
+ * Glib::RefPtr<Gst::Message>& message);
* The message function should return true if it wants to continue to receive
* messages, false otherwise.
*/
typedef sigc::slot< bool, const Glib::RefPtr<Bus>&, const Glib::RefPtr<Message>& > SlotMessage;
/** For example,
- * BusSyncReply on_bus_sync_message(const Glib::RefPtr<Bus>& bus, const
- * Glib::RefPtr<Message>& message);
+ * BusSyncReply on_bus_sync_message(const Glib::RefPtr<Gst::Bus>& bus, const
+ * Glib::RefPtr<Gst::Message>& message);
*/
typedef sigc::slot< BusSyncReply, const Glib::RefPtr<Bus>&, const Glib::RefPtr<Message>& > SlotMessageSync;
@@ -138,7 +138,8 @@
* called in the same thread context as the posting object (synchronously).
* This function is usually only called by the creator of the bus.
* Applications should handle messages asynchronously using the watch and
- * poll functions.
+ * poll functions or enable the "sync-message" signal emission with
+ * enable_sync_message_emission().
*
* @param slot The handler slot to install
*/
Modified: gstreamermm/trunk/gstreamer/src/caps.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/caps.hg (original)
+++ gstreamermm/trunk/gstreamer/src/caps.hg Thu Apr 17 22:30:24 2008
@@ -29,23 +29,23 @@
struct Structure;
-/** Caps â A structure describing sets of media formats.
- * Caps (capabilities) are lighweight refcounted objects describing media
- * types. They are composed of an array of Structure.
+/** Gst::Caps â A structure describing sets of media formats.
+ * Gst::Caps (capabilities) are lighweight refcounted objects describing media
+ * types. They are composed of an array of Gst::Structure.
*
- * Caps are exposed on PadTemplate to describe all possible types a given pad
- * can handle. They are also stored in the Registry along with a description of
- * the Element.
+ * Gst::Caps are exposed on Gst::PadTemplate to describe all possible types a
+ * given pad can handle. They are also stored in the Gst::Registry along with a
+ * description of the Gst::Element.
*
- * Caps are exposed on the element pads using the Gst::Pad::get_caps() method.
- * This method describes the possible types that the pad can handle or produce
- * at runtime.
+ * Gst::Caps are exposed on the element pads using the Gst::Pad::get_caps()
+ * method. This method describes the possible types that the pad can handle or
+ * produce at runtime.
*
- * Caps are also attached to buffers to describe to content of the data pointed
- * to by the buffer with Gst::Buffer:set_caps(). Caps attached to a Buffer
- * allow for format negotiation upstream and downstream.
+ * Gst::Caps are also attached to buffers to describe to content of the data
+ * pointed to by the buffer with Gst::Buffer::set_caps(). Gst::Caps attached to
+ * a Gst::Buffer allow for format negotiation upstream and downstream.
*
- * A Caps can be constructed with the following code fragment:
+ * A Gst::Caps can be constructed with the following code fragment:
*
* TODO: Insert C++ translated code fragment from C API docs
*/
@@ -55,26 +55,25 @@
_IGNORE(gst_caps_ref, gst_caps_unref)
public:
- /** Creates a new Caps that indicates that it is compatible with any media
- * format.
+ /** Creates a new Gst::Caps that indicates that it is compatible with any
+ * media format.
*
- * @return the new Caps
+ * @return the new Gst::Caps
*/
static Glib::RefPtr<Caps> create_any();
- /** Creates a new Caps that contains one Structure. Caller is responsible for
- * unreffing the returned caps.
+ /** Creates a new Gst::Caps that contains one Gst::Structure.
*
* @param media_type the media type of the structure
- * @return the new GstCaps
+ * @return the new Gst::Caps
*/
static Glib::RefPtr<Caps> create_simple(const Glib::ustring& media_type);
- /** Creates a new GstCaps and adds the first Structure given. The structure
- * is not copied; the returned Caps owns the structure.
+ /** Creates a new Gst::Caps and adds the first Gst::Structure given. The
+ * structure is not copied; the returned Gst::Caps owns the structure.
*
* @param first_struct the first structure to add
- * @return Returns the new GstCaps
+ * @return Returns the new Gst::Caps
*/
static Glib::RefPtr<Caps> create(Structure& first_struct);
@@ -86,29 +85,29 @@
/** Appends structure to caps. The structure is not copied; caps becomes the
* owner of structure.
*
- * @param structure the Structure to append
+ * @param structure the Gst::Structure to append
*/
void append_structure(Structure& structure);
/** Appends structure to caps if its not already expressed by caps. The
* structure is not copied; caps becomes the owner of structure.
*
- * @param structure the Structure to merge
+ * @param structure the Gst::Structure to merge
*/
void merge_structure(Structure& structure);
/** Finds the structure in caps that has the index idx, and returns it.
*
* @param index the index of the structure
- * @return the Structure corresponding to index
+ * @return the Gst::Structure corresponding to index
*/
const Structure* get_structure(guint idx) const;
_WRAP_METHOD(void remove_structure(guint idx), gst_caps_remove_structure)
_WRAP_METHOD(guint size() const, gst_caps_get_size)
- /** Sets a fields in a simple Caps. A simple Caps is one that only has one
- * structure.
+ /** Sets a fields in a simple Gst::Caps. A simple Gst::Caps is one that only
+ * has one structure.
*
* @param field field to set
* @param value the value which the field should be set to
Modified: gstreamermm/trunk/gstreamer/src/childproxy.ccg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/childproxy.ccg (original)
+++ gstreamermm/trunk/gstreamer/src/childproxy.ccg Thu Apr 17 22:30:24 2008
@@ -22,9 +22,10 @@
namespace Gst
{
-void ChildProxy::get_proxy_property(const Glib::ustring& name, Glib::ValueBase& value)
+Glib::RefPtr<ChildProxy> ChildProxy::get_proxy_property(const Glib::ustring& name, Glib::ValueBase& value)
{
gst_child_proxy_get_property(GST_OBJECT(gobj()), name.c_str(), value.gobj());
+ return Glib::wrap(gobj(), true);
}
void ChildProxy::get_proxy_valist(const Glib::ustring& first_prop_name, va_list& var_args)
@@ -32,9 +33,10 @@
gst_child_proxy_get_valist(GST_OBJECT(gobj()), first_prop_name.c_str(), var_args);
}
-void ChildProxy::set_proxy_property(const Glib::ustring& name, const Glib::ValueBase& value)
+Glib::RefPtr<ChildProxy> ChildProxy::set_proxy_property(const Glib::ustring& name, const Glib::ValueBase& value)
{
gst_child_proxy_set_property(GST_OBJECT(gobj()), name.c_str(), value.gobj());
+ return Glib::wrap(gobj(), true);
}
void ChildProxy::set_proxy_valist(const Glib::ustring& first_prop_name, const va_list& var_args)
Modified: gstreamermm/trunk/gstreamer/src/childproxy.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/childproxy.hg (original)
+++ gstreamermm/trunk/gstreamer/src/childproxy.hg Thu Apr 17 22:30:24 2008
@@ -28,18 +28,18 @@
namespace Gst
{
-/** ChildProxy â Interface for multi child elements.
+/** Gst::ChildProxy â An interface for multi child elements.
* This interface abstracts handling of property sets for child elements.
* Imagine elements such as mixers or polyphonic generators. They all have
- * multiple Pad or some kind of voice objects. The element acts as a parent
- * for those child objects. Each child has the same properties.
+ * multiple Gst::Pad or some kind of voice objects. The element acts as a
+ * parent for those child objects. Each child has the same properties.
*
* By implementing this interface the child properties can be accessed from
- * the parent element by using child_proxy_get() and child_proxy_set().
+ * the parent element by using get_proxy_property() and set_proxy_property().
*
* Property names are written as "child-name::property-name". The whole naming
* scheme is recursive. Thus "child1::child2::property" is valid too, if
- * "child1" also implements the ChildProxy interface.
+ * "child1" also implements the Gst::ChildProxy interface.
*/
class ChildProxy : public Glib::Interface
{
@@ -52,11 +52,42 @@
//TODO: should gst_child_proxy_lookup() be wrapped?
- void get_proxy_property(const Glib::ustring& name, Glib::ValueBase& value);
+ /** Gets a single property using the Gst::ChildProxy mechanism.
+ * @param name the property to get
+ * @param value an empty Glib::ValueBase in which to store the property
+ * @return this Gst::ChildProxy so more properties can be gotten if needed
+ */
+ Glib::RefPtr<ChildProxy> get_proxy_property(const Glib::ustring& name, Glib::ValueBase& value);
+
+ /** Gets properties of the parent object and its children.
+ * @param first_prop_name name of the first property to get
+ * @param var_args return location for the first property, followed
+ * optionally by more name/return location pairs, followed by NULL
+ */
void get_proxy_valist(const Glib::ustring& first_prop_name, va_list& var_args);
- void set_proxy_property(const Glib::ustring& name, const Glib::ValueBase& value);
+
+ /** Sets a single property using the Gst::ChildProxy mechanism.
+ * @param name the property to get
+ * @param value the Glib::ValueBase to set the property to (non-empty)
+ * @return this Gst::ChildProxy so more properties can be set
+ */
+ Glib::RefPtr<ChildProxy> set_proxy_property(const Glib::ustring& name, const Glib::ValueBase& value);
+
+ /** Sets properties of the parent object and its children.
+ * @param first_prop_name name of the first property to set
+ * @param var_args alue for the first property, followed optionally by more
+ * name/value pairs, followed by NULL
+ */
void set_proxy_valist(const Glib::ustring& first_prop_name, const va_list& var_args);
+
+ /** Emits the "child-added" signal.
+ * @param child the newly added child
+ */
void child_added(const Glib::RefPtr<Gst::Object>& child);
+
+ /** Emits the "child-removed" signal.
+ * @param child the newly added child
+ */
void child_removed(const Glib::RefPtr<Gst::Object>& child);
#m4 _CONVERSION(`GstObject*',`const Glib::RefPtr<Gst::Object>&',`Glib::wrap($3)')
Modified: gstreamermm/trunk/gstreamer/src/clock.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/clock.hg (original)
+++ gstreamermm/trunk/gstreamer/src/clock.hg Thu Apr 17 22:30:24 2008
@@ -47,8 +47,8 @@
public:
/** For example,
- * bool on_clock(const Glib::RefPtr<Clock>& clock, ClockTime time, const
- * Glib::RefPtr<ClockID>& id);
+ * bool on_clock(const Glib::RefPtr<Gst::Clock>& clock, ClockTime time, const
+ * Glib::RefPtr<Gst::ClockID>& id);
* The clock function return value is currently unused (see GstClockCallback)
*/
typedef sigc::slot< bool, const Glib::RefPtr<Clock>&, ClockTime, const Glib::RefPtr<ClockID>& > SlotClock;
@@ -56,10 +56,10 @@
_WRAP_METHOD(ClockTime get_time(), gst_clock_id_get_time)
_WRAP_METHOD(ClockReturn wait(ClockTimeDiff& jitter), gst_clock_id_wait)
- /** Register a slot on the given GstClockID id with the given slot. When
- * passing a GstClockID with an invalid time to this function, the slot will
- * be called immediatly with a time set to CLOCK_TIME_NONE. The slot will be
- * called when the time of id has been reached.
+ /** Register a slot on the given Gst::ClockID id with the given slot. When
+ * passing a Gst::ClockID with an invalid time to this function, the slot
+ * will be called immediatly with a time set to Gst::CLOCK_TIME_NONE. The
+ * slot will be called when the time of id has been reached.
*
* @param slot The slot to callback
* @return the result of the non blocking wait. MT safe.
@@ -79,12 +79,12 @@
guint get_nanoseconds(ClockTime time);
guint get_fractional_seconds(ClockTime time);
-/** Clock â Abstract class for global clocks.
+/** Gst::Clock â Abstract class for global clocks.
* GStreamer uses a global clock to synchronize the plugins in a pipeline.
* Different clock implementations are possible by implementing this abstract
* base class.
*
- * The Clock returns a monotonically increasing time with the method
+ * The Gst::Clock returns a monotonically increasing time with the method
* get_time(). Its accuracy and base time depend on the specific clock
* implementation but time is always expressed in nanoseconds. Since the
* baseline of the clock is undefined, the clock time returned is not
@@ -93,55 +93,56 @@
*
* The pipeline uses the clock to calculate the stream time. Usually all
* renderers synchronize to the global clock using the buffer timestamps, the
- * newsegment events and the element's base time, see Pipeline.
+ * newsegment events and the element's base time, see Gst::Pipeline.
*
* A clock implementation can support periodic and single shot clock
* notifications both synchronous and asynchronous.
*
- * One first needs to create a ClockID for the periodic or single shot
+ * One first needs to create a Gst::ClockID for the periodic or single shot
* notification using create_single_shot_id() or create_periodic_id().
*
- * To perform a blocking wait for the specific time of the ClockID use the
- * ClockID::wait() method. To receive a callback when the specific time is
- * reached in the clock use ClockID::wait_async(). Both these calls can be
- * interrupted with the ClockID::unschedule() call. If the blocking wait is
- * unscheduled a return value of CLOCK_UNSCHEDULED is returned.
+ * To perform a blocking wait for the specific time of the Gst::ClockID use the
+ * Gst::ClockID::wait() method. To receive a callback when the specific time is
+ * reached in the clock use Gst::ClockID::wait_async(). Both these calls can be
+ * interrupted with the Gst::ClockID::unschedule() call. If the blocking wait
+ * is unscheduled a return value of Gst::CLOCK_UNSCHEDULED is returned.
*
* Periodic callbacks scheduled async will be repeadedly called automatically
- * until it is unscheduled. To schedule a sync periodic callback, wait() should
- * be called repeadedly.
+ * until it is unscheduled. To schedule a sync periodic callback,
+ * Gst::ClockID::wait() should be called repeadedly.
*
* The async callbacks can happen from any thread, either provided by the core or from a streaming thread. The application should be prepared for this.
*
- * A ClockID that has been unscheduled cannot be used again for any wait
- * operation, a new ClockID should be created.
+ * A Gst::ClockID that has been unscheduled cannot be used again for any wait
+ * operation, a new Gst::ClockID should be created.
*
* It is possible to perform a blocking wait on the same ClockID from multiple
* threads. However, registering the same ClockID for multiple async
* notifications is not possible, the slot will only be called for the thread
* registering the entry last.
*
- * None of the wait operations unref the ClockID, the owner is responsible for
- * unreffing the ids itself. This holds for both periodic and single shot
- * notifications. The reason being that the owner of the ClockID has to keep a
- * handle to the ClockID to unblock the wait on FLUSHING events or state
- * changes and if the entry would be unreffed automatically, the handle might
- * become invalid without any notification. (The RefPtr takes care of unreffing
- * in this case)
+ * None of the wait operations unref the Gst::ClockID, the owner is responsible
+ * for unreffing the ids itself. This holds for both periodic and single shot
+ * notifications. The reason being that the owner of the Gst::ClockID has to
+ * keep a handle to the Gst::ClockID to unblock the wait on FLUSHING events or
+ * state changes and if the entry would be unreffed automatically, the handle
+ * might become invalid without any notification. (The RefPtr takes care of
+ * unreffing in this case)
*
* These clock operations do not operate on the stream time, so the callbacks
* will also occur when not in PLAYING state as if the clock just keeps on
* running. Some clocks however do not progress when the element that provided
* the clock is not PLAYING.
*
- * When a clock has the CLOCK_FLAG_CAN_SET_MASTER flag set, it can be slaved to
- * another Clock with the set_master() method. The clock will then
- * automatically be synchronized to this master clock by repeadedly sampling
- * the master clock and the slave clock and recalibrating the slave clock with
- * set_calibration(). This feature is mostly useful for plugins that have an
- * internal clock but must operate with another clock selected by the Pipeline.
- * They can track the offset and rate difference of their internal clock
- * relative to the master clock by using the get_calibration() method.
+ * When a clock has the Gst::CLOCK_FLAG_CAN_SET_MASTER flag set, it can be
+ * slaved to another Gst::Clock with the set_master() method. The clock will
+ * then automatically be synchronized to this master clock by repeadedly
+ * sampling the master clock and the slave clock and recalibrating the slave
+ * clock with set_calibration(). This feature is mostly useful for plugins that
+ * have an internal clock but must operate with another clock selected by the
+ * Gst::Pipeline. They can track the offset and rate difference of their
+ * internal clock relative to the master clock by using the get_calibration()
+ * method.
*
* The master/slave synchronisation can be tuned with the "timeout",
* "window-size" and "window-threshold" properties. The "timeout" property
@@ -168,6 +169,9 @@
_WRAP_METHOD(ClockTime get_internal_time() const, gst_clock_get_internal_time)
_WRAP_METHOD(ClockTime adjust_unlocked(ClockTime internal_time), gst_clock_adjust_unlocked)
_WRAP_METHOD(ClockTime unadjust_unlocked(ClockTime external_time), gst_clock_unadjust_unlocked)
+ _WRAP_METHOD(void get_calibration(ClockTime& internal, ClockTime& external, ClockTime& rate_num, ClockTime& rate_denom), gst_clock_get_calibration)
+ _WRAP_METHOD(void set_calibration(ClockTime internal, ClockTime external, ClockTime rate_num, ClockTime rate_denom), gst_clock_set_calibration)
+
_WRAP_PROPERTY("stats", bool)
_WRAP_PROPERTY("timeout", guint64)
@@ -187,7 +191,7 @@
*/
_WRAP_VFUNC(ClockTime get_internal_time(), "get_internal_time")
- /** perform an asynchronous wait for the given GstClockEntry.
+ /** perform an asynchronous wait for the given Gst::ClockID.
*/
_WRAP_VFUNC(ClockReturn wait_async(const Glib::RefPtr<ClockID>& id), "wait_async")
@@ -195,7 +199,7 @@
*/
_WRAP_VFUNC(void unschedule(const Glib::RefPtr<ClockID>& id), "unschedule")
- /** perform a blocking wait on the given GstClockEntry and return the jitter.
+ /** perform a blocking wait on the given Gst::ClockID and return the jitter.
* (Since: 0.10.10)
*/
_WRAP_VFUNC(ClockReturn wait_jitter(const Glib::RefPtr<ClockID>& id, ClockTimeDiff& jitter), "wait_jitter")
Modified: gstreamermm/trunk/gstreamer/src/element.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/element.hg (original)
+++ gstreamermm/trunk/gstreamer/src/element.hg Thu Apr 17 22:30:24 2008
@@ -72,25 +72,26 @@
*/
Glib::ustring get_name(StateChangeReturn s);
-/** Element â Abstract base class for all pipeline elements.
- * Element is the abstract base class needed to construct an element that can
- * be used in a GStreamer pipeline. Please refer to the plugin writers guide
- * for more information on creating Element subclasses.
+/** Gst::Element â Abstract base class for all pipeline elements.
+ * Gst::Element is the abstract base class needed to construct an element that
+ * can be used in a GStreamer pipeline. Please refer to the plugin writers
+ * guide for more information on creating Gst::Element subclasses.
*
- * The name of an Element can be get with get_name() and set with set_name().
+ * The name of a Gst::Element can be get with get_name() and set with
+ * set_name().
*
- * All elements have pads (of the type Pad). These pads link to pads on other
- * elements. Buffer flow between these linked pads. An Element has a GList of
- * Pad structures for all their input (or sink) and output (or source) pads.
- * Core and plug-in writers can add and remove pads with add_pad() and
- * remove_pad().
+ * All elements have pads (of the type Gst::Pad). These pads link to pads on
+ * other elements. Gst::Buffer flow between these linked pads. An Element has a
+ * GList of Gst::Pad structures for all their input (or sink) and output (or
+ * source) pads. Core and plug-in writers can add and remove pads with
+ * add_pad() and remove_pad().
*
* A pad of an element can be retrieved by name with get_pad(). An iterator of
* all pads can be retrieved with gst_element_iterate_pads().
*
- * Elements can be linked through their pads. Use the link() function to link
- * elements. Use link_filtered() to link two elements constrained by a
- * specified set of Caps. For finer control, use link_pads() and
+ * Gst::Elements can be linked through their pads. Use the link() function to
+ * link elements. Use link_filtered() to link two elements constrained by a
+ * specified set of Gst::Caps. For finer control, use link_pads() and
* link_pads_filtered() to specify the pads to link on each element by name.
*
* Each element has a state (see State). You can get and set the state of an
@@ -105,7 +106,7 @@
* element with set_clock().
*
* Note that clock slection and distribution is normally handled by the
- * toplevel Pipeline so the clock functions are only to be used in very
+ * toplevel Gst::Pipeline so the clock functions are only to be used in very
* specific situations.
*
* Last reviewed on 2006-03-12 (0.10.5)
Modified: gstreamermm/trunk/gstreamer/src/elementfactory.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/elementfactory.hg (original)
+++ gstreamermm/trunk/gstreamer/src/elementfactory.hg Thu Apr 17 22:30:24 2008
@@ -32,11 +32,11 @@
class PadTemplate;
class Plugin;
-/** ElementFactory â Create Elements from a factory.
- * ElementFactory is used to create instances of elements. An Elementfactory
- * can be added to a Plugin as it is also a PluginFeature. Use the find() and
- * create() functions to create element instances. or use the static create()
- * as a convenient shortcut.
+/** Gst::ElementFactory â Create Gst::Element from a factory.
+ * Gst::ElementFactory is used to create instances of elements. A
+ * Gst::ElementFactory can be added to a Gst::Plugin as it is also a
+ * Gst::PluginFeature. Use the find() and create() functions to create element
+ * instances. or use the static create() as a convenient shortcut.
*
* The following code example shows you how to create a GstFileSrc element.
*
Modified: gstreamermm/trunk/gstreamer/src/event.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/event.hg (original)
+++ gstreamermm/trunk/gstreamer/src/event.hg Thu Apr 17 22:30:24 2008
@@ -62,6 +62,36 @@
Glib::ustring get_name(EventType t);
Glib::QueryQuark get_quark(EventType t);
+/** Gst::Event â A structure describing events that are passed up and down a
+ * pipeline.
+ * The event class provides factory methods to construct and functions query
+ * (parse) events.
+ *
+ * Events are usually created by using the Gst::Event derrived classes'
+ * create() methods. To send an event application will usually use
+ * Gst::Element::send_event() and elements will use Gst::Pad::send_event() or
+ * Gst::Pad::push_event().
+ *
+ * Events that have been received can be parsed with their respective parse()
+ * functions.
+ *
+ * Events are passed between elements in parallel to the data stream. Some
+ * events are serialized with buffers, others are not. Some events only travel
+ * downstream, others only upstream. Some events can travel both upstream and
+ * downstream.
+ *
+ * The events are used to signal special conditions in the datastream such as
+ * EOS (end of stream) or the start of a new stream-segment. Events are also
+ * used to flush the pipeline of any pending data.
+ *
+ * Most of the event API is used inside plugins. Applications usually only
+ * construct and use seek events. To do that Gst::EventSeek::create() is used
+ * to create a seek event. It takes the needed parameters to specity seeking
+ * time and mode. The event is then sent to the element like so:
+ * @code
+ * pipeline->send_event(event);
+ * @endcode
+ */
class Event : public MiniObject
{
protected:
@@ -69,7 +99,7 @@
public:
/** Get the structure of an event.
- * @return The Structure of the event (unmodifiable)
+ * @return The Gst::Structure of the event (unmodifiable)
*/
const Structure* get_structure();
Modified: gstreamermm/trunk/gstreamer/src/filter.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/filter.hg (original)
+++ gstreamermm/trunk/gstreamer/src/filter.hg Thu Apr 17 22:30:24 2008
@@ -36,18 +36,18 @@
*/
typedef sigc::slot<bool, const Glib::RefPtr<Glib::Object>& > SlotFilter;
-/**
- * Iterates over the elements in the list, calling the slot with each
- * object. If the slot returns TRUE, the object is
- * prepended to the list of results returned. If first is true,
- * the search is halted after the first result is found.
- *
- * @param list a list of objects
- * @param slot the slot to execute for each item
- * @param first flag to stop execution after a successful item
- *
- * @return the list of results
- */
+ /**
+ * Iterates over the elements in the list, calling the slot with each
+ * object. If the slot returns TRUE, the object is
+ * prepended to the list of results returned. If first is true,
+ * the search is halted after the first result is found.
+ *
+ * @param list a list of objects
+ * @param slot the slot to execute for each item
+ * @param first flag to stop execution after a successful item
+ *
+ * @return the list of results
+ */
static Glib::ListHandle< Glib::RefPtr<Glib::Object> > run(const Glib::ListHandle<Glib::RefPtr<Glib::Object> >& list, const SlotFilter& slot, bool first);
};
Modified: gstreamermm/trunk/gstreamer/src/ghostpad.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/ghostpad.hg (original)
+++ gstreamermm/trunk/gstreamer/src/ghostpad.hg Thu Apr 17 22:30:24 2008
@@ -26,20 +26,21 @@
namespace Gst
{
-/** GhostPad â Pseudo link pads.
- * GhostPads are useful when organizing pipelines with Bin like elements. The
- * idea here is to create hierarchical element graphs. The bin element contains
- * a sub-graph. Now one would like to treat the bin-element like other
- * Elements. This is where GhostPads come into play. A GhostPad acts as a proxy
- * for another pad. Thus the bin can have sink and source ghost-pads that are
- * associated with sink and source pads of the child elements.
+/** Gst::GhostPad â Pseudo link pads.
+ * Gst::GhostPad are useful when organizing pipelines with Gst::Bin like elements.
+ * The idea here is to create hierarchical element graphs. The bin element
+ * contains a sub-graph. Now one would like to treat the bin-element like
+ * another Gst::Element. This is where Gst::GhostPad come into play. A
+ * Gst::GhostPad acts as a proxy for another pad. Thus the bin can have sink
+ * and source ghost-pads that are associated with sink and source pads of the
+ * child elements.
*
- * If the target pad is known at creation time, create() with a Pad argument is
- * the method to use to get a ghost-pad. Otherwise one can use create() with a
- * PadDirection argument to create the ghost-pad and use set_target() to
- * establish the association later on.
+ * If the target pad is known at creation time, create() with a Gst::Pad
+ * argument is the method to use to get a ghost-pad. Otherwise one can use
+ * create() with a Gst::PadDirection argument to create the ghost-pad and use
+ * set_target() to establish the association later on.
*
- * Note that GhostPads add overhead to the data processing of a pipeline.
+ * Note that Gst::GhostPad add overhead to the data processing of a pipeline.
*
* Last reviewed on 2005-11-18 (0.9.5)
*/
@@ -61,7 +62,7 @@
*
* @param name the name of the new pad.
* @param target the pad to ghost.
- * @returns a new GhostPad, or NULL in case of an error.
+ * @returns a new Gst::GhostPad, or NULL in case of an error.
*/
_WRAP_CREATE(const Glib::ustring& name, const Glib::RefPtr<Pad>& target)
@@ -72,7 +73,7 @@
*
* @param name the name of the new pad.
* @param dir the direction of the ghostpad
- * @return a new GhostPad, or NULL in case of an error.
+ * @return a new Gst::GhostPad, or NULL in case of an error.
*/
_WRAP_CREATE(const Glib::ustring& name, PadDirection dir)
@@ -84,8 +85,8 @@
*
* @param name the name of the new pad.
* @param target the pad to ghost.
- * @param templ the PadTemplate to use on the ghostpad.
- * @return Returns a new GhostPad, or NULL in case of an error.
+ * @param templ the Gst::PadTemplate to use on the ghostpad.
+ * @return a new Gst::GhostPad, or NULL in case of an error.
*/
_WRAP_CREATE(const Glib::ustring& name, const Glib::RefPtr<Pad>& target, const Glib::RefPtr<PadTemplate>& templ)
@@ -93,12 +94,12 @@
* direction will be taken from the templ.
*
* @param name the name of the new pad.
- * @param templ the PadTemplate to create the ghostpad from.
- * @return a new GhostPad, or NULL in case of an error.
+ * @param templ the Gst::PadTemplate to create the ghostpad from.
+ * @return a new Gst::GhostPad, or NULL in case of an error.
*/
_WRAP_CREATE(const Glib::ustring& name, const Glib::RefPtr<PadTemplate>& templ)
- _WRAP_METHOD(bool set_target(const Glib::RefPtr<Pad>& new_target), gst_ghost_pad_set_target)
+ _WRAP_METHOD(bool set_target(const Glib::RefPtr<Pad>& newtarget), gst_ghost_pad_set_target)
_WRAP_METHOD(Glib::RefPtr<Pad> get_target(), gst_ghost_pad_get_target)
};
Modified: gstreamermm/trunk/gstreamer/src/gst_enums.defs
==============================================================================
--- gstreamermm/trunk/gstreamer/src/gst_enums.defs (original)
+++ gstreamermm/trunk/gstreamer/src/gst_enums.defs Thu Apr 17 22:30:24 2008
@@ -565,6 +565,8 @@
(in-module "Gst")
(c-name "GstPadTemplateFlags")
(values
+ '("fixed" "GST_PAD_TEMPLATE_FIXED" "GST_OBJECT_FLAG_LAST << 0")
+ '("last" "GST_PAD_TEMPLATE_LAST" "GST_OBJECT_FLAG_LAST << 4")
)
)
Modified: gstreamermm/trunk/gstreamer/src/index.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/index.hg (original)
+++ gstreamermm/trunk/gstreamer/src/index.hg Thu Apr 17 22:30:24 2008
@@ -87,7 +87,7 @@
_WRAP_METHOD(IndexEntry get_assoc_entry(int id, IndexLookupMethod method, AssocFlags flags, Format format, gint64 value) const, gst_index_get_assoc_entry)
/** For example,
- * bool on_filter(const Glib::RefPtr<Index>& index, IndexEntry entry);
+ * bool on_filter(const Glib::RefPtr<Gst::Index>& index, IndexEntry entry);
* The filter function should return true if the entry is to be added to the
* index, false otherwise.
*/
Modified: gstreamermm/trunk/gstreamer/src/indexfactory.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/indexfactory.hg (original)
+++ gstreamermm/trunk/gstreamer/src/indexfactory.hg Thu Apr 17 22:30:24 2008
@@ -29,8 +29,8 @@
class Index;
-/** IndexFactory â Create Indexes from a factory.
- * IndexFactory is used to dynamically create Index implementations.
+/** Gst::IndexFactory â Create Indexes from a factory.
+ * Gst::IndexFactory is used to dynamically create Gst::Index implementations.
*/
class IndexFactory : public PluginFeature
{
Modified: gstreamermm/trunk/gstreamer/src/interface.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/interface.hg (original)
+++ gstreamermm/trunk/gstreamer/src/interface.hg Thu Apr 17 22:30:24 2008
@@ -27,8 +27,8 @@
namespace Gst
{
-/** Interface â Core interface implemented by Element instances
- * that allows runtime querying of interface availabillity.
+/** Gst::Interface â Core interface implemented by Gst::Element instances that
+ * allows runtime querying of interface availabillity.
* Provides interface functionality on per instance basis and not per class
* basis, which is the case for gobject.
*/
Modified: gstreamermm/trunk/gstreamer/src/message.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/message.hg (original)
+++ gstreamermm/trunk/gstreamer/src/message.hg Thu Apr 17 22:30:24 2008
@@ -36,6 +36,21 @@
Glib::ustring get_name(MessageType t);
Glib::QueryQuark get_quark(MessageType t);
+/** Gst::Message â Lightweight objects to signal the application of pipeline
+ * events.
+ * Messages are implemented as a subclass of Gst::MiniObject with a generic
+ * Gst::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 Gst::Bus.
+ *
+ * The basic use pattern of posting a message on a Gst::Bus is as follows:
+ * @code
+ * bus->post(Gst::MessageEos::create(my_element));
+ * @endcode
+ */
class Message : public Gst::MiniObject
{
protected:
@@ -43,7 +58,7 @@
_IGNORE(gst_message_ref, gst_message_unref)
public:
/** Get the structure of a message.
- * @return The Structure of the message (unmodifiable)
+ * @return The Gst::Structure of the message (unmodifiable)
*/
const Structure* get_structure();
Modified: gstreamermm/trunk/gstreamer/src/pad.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/pad.hg (original)
+++ gstreamermm/trunk/gstreamer/src/pad.hg Thu Apr 17 22:30:24 2008
@@ -43,32 +43,33 @@
_WRAP_ENUM(FlowReturn, GstFlowReturn)
_WRAP_ENUM(ActivateMode, GstActivateMode)
-/** Pad â Object contained by elements that allows links to other elements.
- * An Element is linked to other elements via "pads", which are extremely
+/** Gst::Pad â Object contained by elements that allows links to other
+ * elements.
+ * A Gst::Element is linked to other elements via "pads", which are extremely
* light-weight generic link points. After two pads are retrieved from an
* element with Element::get_pad(), the pads can be link with link(). (For
* quick links, you can also use Element::link(), which will make the obvious
* link for you if it's straightforward.)
*
- * Pads are typically created from a PadTemplate with the create() method that
- * takes a PadTemplate.
+ * Pads are typically created from a Gst::PadTemplate with the create() method
+ * that takes a Gst::PadTemplate.
*
- * Pads have Caps attached to it to describe the media type they are capable of
- * dealing with. get_caps() and set_caps() are used to manipulate the caps of
- * the pads. Pads created from a pad template cannot set capabilities that are
- * incompatible with the pad template capabilities.
+ * Pads have Gst::Caps attached to it to describe the media type they are
+ * capable of dealing with. get_caps() and set_caps() are used to manipulate
+ * the caps of the pads. Pads created from a pad template cannot set
+ * capabilities that are incompatible with the pad template capabilities.
*
* Pads without pad templates can be created with create(), which takes a
* direction and a name as an argument.
*
- * get_parent_element() will retrieve the Element that owns the pad.
+ * get_parent_element() will retrieve the Gst::Element that owns the pad.
*
- * An Element creating a pad will typically use the underlying C API to
+ * A Gst::Element creating a pad will typically use the underlying C API to
* register callbacks for various events on the pads.
*
* Elements will use push() and pull_range() to push out or pull in a buffer.
*
- * To send an Event on a pad, use send_event() and push_event().
+ * To send a Gst::Event on a pad, use send_event() and push_event().
*
* Last reviewed on 2006-07-06 (0.10.9)
*/
@@ -82,13 +83,13 @@
public:
/** For example,
- * void on_block(const Glib::RefPtr<Pad>& pad, bool blocked);
+ * void on_block(const Glib::RefPtr<Gst::Pad>& pad, bool blocked);
*/
typedef sigc::slot<void, const Glib::RefPtr<Pad>&, bool> SlotBlock;
/** For example,
- * bool on_have_data(const Glib::RefPtr<Pad>& pad, const
- * Glib::RefPtr<MiniObjec>& data);
+ * bool on_have_data(const Glib::RefPtr<Gst::Pad>& pad, const
+ * Glib::RefPtr<Gst::MiniObjec>& data);
* The on_have_data method should return TRUE to keep the data in the
* pipeline, FALSE to drop it (throw it away)
*/
Modified: gstreamermm/trunk/gstreamer/src/padtemplate.ccg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/padtemplate.ccg (original)
+++ gstreamermm/trunk/gstreamer/src/padtemplate.ccg Thu Apr 17 22:30:24 2008
@@ -25,13 +25,3 @@
_PINCLUDE(glibmm/private/object_p.h)
_PINCLUDE(gstreamermm/private/object_p.h)
-
-namespace Gst
-{
-
-Glib::RefPtr<PadTemplate> PadTemplate::create(const Glib::ustring& name_template, PadDirection direction, PadPresence presence, const Glib::RefPtr<Caps>& caps)
-{
- return Glib::wrap(gst_pad_template_new(name_template.c_str(), GstPadDirection(direction), GstPadPresence(presence), caps->gobj()));
-}
-
-} //namespace Gst
Modified: gstreamermm/trunk/gstreamer/src/padtemplate.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/padtemplate.hg (original)
+++ gstreamermm/trunk/gstreamer/src/padtemplate.hg Thu Apr 17 22:30:24 2008
@@ -29,28 +29,79 @@
namespace Gst
{
+_WRAP_ENUM(PadTemplateFlags, GstPadTemplateFlags)
_WRAP_ENUM(PadPresence, GstPadPresence)
class Caps;
class Pad;
+/** Gst::PadTemplate â Describe the media type of a pad.
+ * Padtemplates describe the possible media types a pad or an elementfactory
+ * can handle. This allows for both inspection of handled types before loading
+ * the element plugin as well as identifying pads on elements that are not yet
+ * created (request or sometimes pads).
+ *
+ * Gst::Pad and PadTemplates have Gst::Caps attached to it to describe the
+ * media type they are capable of dealing with. get_caps() is used to get the
+ * caps of a padtemplate. It's not possible to modify the caps of a padtemplate
+ * after creation.
+ *
+ * PadTemplates have a Gst::PadPresence property which identifies the lifetime
+ * of the pad and that can be retrieved with get_presence(). Also the direction
+ * of the pad can be retrieved from the GstPadTemplate with get_direction().
+ *
+ * The get_name_template() method is important for Gst::PAD_REQUEST pads
+ * because it has to be used as the name in the
+ * Gst::Element::get_request_pad() call to instantiate a pad from this
+ * template.
+ *
+ * Padtemplates can be created with create().
+
+ * A padtemplate can be used to create a pad (see Gst::Pad::create() methods).
+ */
class PadTemplate : public Object
{
_CLASS_GOBJECT(PadTemplate, GstPadTemplate, GST_PAD_TEMPLATE, Object, GstObject)
protected:
- _CTOR_DEFAULT
+ _WRAP_CTOR(PadTemplate(const Glib::ustring& name_template, PadDirection direction, PadPresence presence, const Glib::RefPtr<Caps>& caps), gst_pad_template_new)
public:
- Glib::RefPtr<PadTemplate> create(const Glib::ustring& name_template, PadDirection direction, PadPresence presence, const Glib::RefPtr<Caps>& caps);
+ /** Creates a new pad template with a name according to the given template
+ * and with the given arguments. This functions takes ownership of the
+ * provided caps, so be sure to not use them afterwards.
+ *
+ * @param name_template the name template.
+ * @param direction the Gst::PadDirection of the template.
+ * @param presence the Gst::PadPresence of the pad.
+ * @param caps a Gst::Caps set for the template. The caps are taken ownership
+ * of.
+ * @return a new Gst::PadTemplate.
+ */
+ _WRAP_CREATE(const Glib::ustring& name_template, PadDirection direction, PadPresence presence, const Glib::RefPtr<Caps>& caps)
+
_WRAP_METHOD(Glib::RefPtr<Caps> get_caps(), gst_pad_template_get_caps)
_WRAP_METHOD(Glib::RefPtr<const Caps> get_caps() const, gst_pad_template_get_caps, constversion)
+ /** Get the nametemplate of the padtemplate.
+ */
+ _MEMBER_GET(name_template, name_template, Glib::ustring, gchar*)
+
+ /** Get the Gst::PadDirection of the padtemplate.
+ */
+ _MEMBER_GET(direction, direction, PadDirection, GstPadDirection)
+
+ /** Get the Gst::PadPresence of the padtemplate.
+ */
+ _MEMBER_GET(presence, presence, PadPresence, GstPadPresence)
+
#m4 _CONVERSION(`GstPad*',`const Glib::RefPtr<Pad>&',`Glib::wrap($3, true)')
+
+ /** This signal is fired when an element creates a pad from this template.
+ */
_WRAP_SIGNAL(void pad_created(const Glib::RefPtr<Pad>& pad), "pad-created")
_IGNORE(gst_pad_template_pad_created)
-
};
} //namespace Gst
Modified: gstreamermm/trunk/gstreamer/src/parse.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/parse.hg (original)
+++ gstreamermm/trunk/gstreamer/src/parse.hg Thu Apr 17 22:30:24 2008
@@ -30,7 +30,7 @@
_WRAP_ENUM(ParseError, GstParseError)
-/** Parse â Get a pipeline from a text pipeline description.
+/** Gst::Parse â Get a pipeline from a text pipeline description.
* The methods in this class allow to create a pipeline based on the syntax
* used in the gst-launch utillity.
*/
@@ -51,7 +51,7 @@
* @param error the error message in case of an erroneous pipeline.
* @return a new element on success, NULL on failure. If more than one
* toplevel element is specified by the pipeline_description, all elements
- * are put into a Pipeline, which than is returned.
+ * are put into a Gst::Pipeline, which than is returned.
*/
#ifdef GLIBMM_EXCEPTIONS_ENABLED
@@ -73,7 +73,7 @@
static Glib::RefPtr<Element> launchv(const gchar *argv[], std::auto_ptr<Glib::Error>& error);
#endif //GLIBMM_EXCEPTIONS_ENABLED
- /** This is a convenience wrapper around launch() to create a Bin from a
+ /** This is a convenience wrapper around launch() to create a Gst::Bin from a
* gst-launch-style pipeline description. See launch() and the gst-launch man
* page for details about the syntax. Ghost pads on the bin for unconnected
* source or sink pads within the bin can automatically be created (but only
Modified: gstreamermm/trunk/gstreamer/src/pipeline.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/pipeline.hg (original)
+++ gstreamermm/trunk/gstreamer/src/pipeline.hg Thu Apr 17 22:30:24 2008
@@ -32,38 +32,42 @@
class Bus;
-/** A Pipeline is a special Bin used as the toplevel container for the filter
- * graph. The Pipeline will manage the selection and distribution of a global
- * Clock as well as provide a Bus to the application. It will also implement a
- * default behavour for managing seek events (see Element::seek()).
+/** A Gst::Pipeline is a special Gst::Bin used as the toplevel container for
+ * the filter graph.
+ * The Gst::Pipeline will manage the selection and distribution of a global
+ * Gst::Clock as well as provide a Gst::Bus to the application. It will also
+ * implement a default behavour for managing seek events (see
+ * Gst::Element::seek()).
*
* create() is used to create a pipeline. when the pipeline is destroyed all
- * its resources including all added Element objects are destroyed.
+ * its resources including all added Gst::Element objects are destroyed.
*
- * Elements are added and removed from the pipeline using the Bin methods like
- * Bin::add() and Bin::remove() (see Bin).
+ * Elements are added and removed from the pipeline using the Gst::Bin methods
+ * like Gst::Bin::add() and Gst::Bin::remove() (see Gst::Bin).
*
- * Before changing the state of the Pipeline (see Element) a Bus can be
- * retrieved with get_bus(). This bus can then be used to receive Message from
- * the elements in the pipeline.
- *
- * By default, a Pipeline will automatically flush the pending Bus messages
- * when going to the NULL state to ensure that no circular references exist
- * when no messages are read from the Bus. This behaviour can be changed with
- * set_auto_flush_bus().
- *
- * When the Pipeline performs the PAUSED to PLAYING state change it will select
- * a clock for the elements. The clock selection algorithm will by default
- * select a clock provided by an element that is most upstream (closest to the
- * source). For live pipelines (ones that return STATE_CHANGE_NO_PREROLL from
- * the Element::set_state() call) this will select the clock provided by the
- * live source. For normal pipelines this will select a clock provided by the
- * sinks (most likely the audio sink). If no element provides a clock, a
- * default SystemClock is used.
+ * Before changing the state of the Gst::Pipeline (see Gst::Element) a Gst::Bus
+ * can be retrieved with get_bus(). This bus can then be used to receive
+ * Gst::Message from the elements in the pipeline.
+ *
+ * By default, a Gst::Pipeline will automatically flush the pending Gst::Bus
+ * messages when going to the NULL state to ensure that no circular references
+ * exist when no messages are read from the Gst::Bus. This behaviour can be
+ * changed with set_auto_flush_bus().
+ *
+ * When the Gst::Pipeline performs the PAUSED to PLAYING state change it will
+ * select a clock for the elements. The clock selection algorithm will by
+ * default select a clock provided by an element that is most upstream (closest
+ * to the source). For live pipelines (ones that return
+ * Gst::STATE_CHANGE_NO_PREROLL from the Gst::Element::set_state() call) this
+ * will select the clock provided by the live source. For normal pipelines this
+ * will select a clock provided by the sinks (most likely the audio sink). If
+ * no element provides a clock, a default Gst::SystemClock is used.
+ *
+ * The clock selection can be controlled with the use_clock() method, which
+ * will enforce a given clock on the pipeline. With auto_clock() the default
+ * clock selection algorithm can be restored.
*
- * The clock selection can be controlled with the use_clock() method, which will enforce a given clock on the pipeline. With auto_clock() the default clock selection algorithm can be restored.
- *
- * A Pipeline maintains a stream time for the elements. The stream time is
+ * A Gst::Pipeline maintains a stream time for the elements. The stream time is
* defined as the difference between the current clock time and the base time.
* When the pipeline goes to READY or a flushing seek is performed on it, the
* stream time is reset to 0. When the pipeline is set from PLAYING to PAUSED,
@@ -71,9 +75,10 @@
* the elements when the pipeline is set to PLAYING again. This default
* behaviour can be changed with the set_new_stream_time() method.
*
- * When sending a flushing seek event to a Pipeline (see Element::seek()), it
- * will make sure that the pipeline is properly PAUSED and resumed as well as
- * set the new stream time to 0 when the seek succeeded.
+ * When sending a flushing seek event to a Gst::Pipeline (see
+ * Gst::Element::seek()), it will make sure that the pipeline is properly
+ * PAUSED and resumed as well as set the new stream time to 0 when the seek
+ * succeeded.
*
* Last reviewed on 2006-03-12 (0.10.5)
*/
@@ -85,6 +90,11 @@
_WRAP_CTOR(Pipeline(const Glib::ustring& name), gst_pipeline_new)
public:
+ /** Create a new pipeline with the given name.
+ *
+ * @param name name of new pipeline
+ * @return newly created Gst::Pipeline MT safe.
+ */
_WRAP_CREATE(const Glib::ustring& name)
_WRAP_METHOD(Glib::RefPtr<Bus> get_bus(), gst_pipeline_get_bus)
Modified: gstreamermm/trunk/gstreamer/src/plugin.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/plugin.hg (original)
+++ gstreamermm/trunk/gstreamer/src/plugin.hg Thu Apr 17 22:30:24 2008
@@ -31,25 +31,26 @@
//TODO: Edit references below to use gstreamermm classes/methods
-/** Plugin â Container for features loaded from a shared object module.
- * GStreamer is extensible, so Element instances can be loaded at runtime. A
- * plugin system can provide one or more of the basic GStreamer
- * PluginFeature subclasses.
+/** Gst::Plugin â Container for features loaded from a shared object module.
+ * GStreamer is extensible, so Gst::Element instances can be loaded at runtime.
+ * A plugin system can provide one or more of the basic GStreamer
+ * Gst::PluginFeature subclasses.
*
* A plugin should export a symbol gst_plugin_desc that is a struct of type
* PluginDesc. the plugin loader will check the version of the core library
- * the plugin was linked against and will create a new Plugin. It will then
- * call the PluginInitFunc function that was provided in the gst_plugin_desc.
+ * the plugin was linked against and will create a new Gst::Plugin. It will
+ * then call the PluginInitFunc function that was provided in the
+ * gst_plugin_desc.
*
- * Once you have a handle to a Plugin (e.g. from the RegistryPool), you can add
- * any object that subclasses PluginFeature.
+ * Once you have a handle to a Gst::Plugin (e.g. from the RegistryPool), you
+ * can add any object that subclasses Gst::PluginFeature.
*
* Use find_feature() and feature_list() to find features in a plugin.
*
* Usually plugins are always automaticlly loaded so you don't need to call
* gst_plugin_load() explicitly to bring it into memory. There are options to
* statically link plugins to an app or even use GStreamer without a plugin
- * repository in which case gst_plugin_load() can be needed to bring the plugin
+ * repository in which case load() can be needed to bring the plugin
* into memory.
*/
class Plugin : public Object
@@ -58,7 +59,7 @@
public:
/** For example,
- * bool on_plugin_filter(const Glib::RefPtr<Plugin>& plugin);
+ * bool on_plugin_filter(const Glib::RefPtr<Gst::Plugin>& plugin);
* The filter function should return true if plugin is a match, false
* otherwise.
*/
Modified: gstreamermm/trunk/gstreamer/src/pluginfeature.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/pluginfeature.hg (original)
+++ gstreamermm/trunk/gstreamer/src/pluginfeature.hg Thu Apr 17 22:30:24 2008
@@ -29,7 +29,7 @@
_WRAP_ENUM(Rank, GstRank)
-/** This is a base class for anything that can be added to a Plugin.
+/** This is a base class for anything that can be added to a Gst::Plugin.
*
*/
class PluginFeature : public Object
@@ -38,7 +38,7 @@
public:
/** For example,
- * bool on_filter(const Glib::RefPtr<PluginFeature>& feature);
+ * bool on_filter(const Glib::RefPtr<Gst::PluginFeature>& feature);
* The filter function should return true if the feature is a match, false
* otherwise.
*/
Modified: gstreamermm/trunk/tools/m4/convert_gst.m4
==============================================================================
--- gstreamermm/trunk/tools/m4/convert_gst.m4 (original)
+++ gstreamermm/trunk/tools/m4/convert_gst.m4 Thu Apr 17 22:30:24 2008
@@ -129,6 +129,7 @@
_CONVERSION(`const guint32&',`guint32',`$3')
#Basic Gstreamermm Conversions
+_CONVERSION(`ClockTime&',`GstClockTime*',`(GstClockTime*)(&($3))')
_CONVERSION(`ClockTimeDiff',`GstClockTimeDiff',`GstClockTimeDiff ($3)')
_CONVERSION(`ClockTimeDiff&',`GstClockTimeDiff*',`(GstClockTimeDiff*)(&($3))')
_CONVERSION(`Format&',`GstFormat*',`(($2) &($3))')
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
