2000-12-28 22:12:02 +00:00
|
|
|
/* GStreamer
|
|
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
|
|
|
*
|
|
|
|
|
* gstelement.h: Header for GstElement
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Library General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
|
|
|
|
* License along with this library; if not, write to the
|
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef __GST_ELEMENT_H__
|
|
|
|
|
#define __GST_ELEMENT_H__
|
|
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
#include <gst/gstconfig.h>
|
2001-12-18 19:03:07 +00:00
|
|
|
#include <gst/gsttypes.h>
|
2000-01-30 09:03:00 +00:00
|
|
|
#include <gst/gstobject.h>
|
|
|
|
|
#include <gst/gstpad.h>
|
2002-02-03 20:07:09 +00:00
|
|
|
#include <gst/gstclock.h>
|
2003-10-31 19:32:47 +00:00
|
|
|
#include <gst/gstplugin.h>
|
2001-08-21 20:16:48 +00:00
|
|
|
#include <gst/gstpluginfeature.h>
|
2002-12-12 22:14:36 +00:00
|
|
|
#include <gst/gstindex.h>
|
2003-11-24 02:09:23 +00:00
|
|
|
#include <gst/gsttag.h>
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-05-26 03:23:25 +00:00
|
|
|
G_BEGIN_DECLS
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
typedef struct _GstElementDetails GstElementDetails;
|
|
|
|
|
|
|
|
|
|
/* FIXME: need translatable stuff in here (how handle in registry)? */
|
|
|
|
|
struct _GstElementDetails {
|
|
|
|
|
gchar *longname; /* long, english name */
|
|
|
|
|
gchar *klass; /* type of element, as hierarchy */
|
|
|
|
|
gchar *description; /* insights of one form or another */
|
|
|
|
|
gchar *author; /* who wrote this thing? */
|
|
|
|
|
|
2003-12-09 02:39:31 +00:00
|
|
|
gpointer _gst_reserved[GST_PADDING];
|
2003-10-31 19:32:47 +00:00
|
|
|
};
|
|
|
|
|
#define GST_ELEMENT_DETAILS(longname,klass,description,author) \
|
2003-12-09 02:39:31 +00:00
|
|
|
{ longname, klass, description, author, GST_PADDING_INIT }
|
2003-10-31 19:32:47 +00:00
|
|
|
#define GST_IS_ELEMENT_DETAILS(details) ( \
|
|
|
|
|
(details) && ((details)->longname != NULL) && ((details)->klass != NULL) \
|
|
|
|
|
&& ((details)->description != NULL) && ((details)->author != NULL))
|
|
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
#define GST_NUM_STATES 4
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-12-15 18:15:13 +00:00
|
|
|
/* NOTE: this probably should be done with an #ifdef to decide
|
|
|
|
|
* whether to safe-cast or to just do the non-checking cast.
|
|
|
|
|
*/
|
2000-07-17 17:14:15 +00:00
|
|
|
#define GST_STATE(obj) (GST_ELEMENT(obj)->current_state)
|
|
|
|
|
#define GST_STATE_PENDING(obj) (GST_ELEMENT(obj)->pending_state)
|
|
|
|
|
|
2001-12-15 18:15:13 +00:00
|
|
|
/* Note: using 8 bit shift mostly "just because", it leaves us enough room to grow <g> */
|
2001-01-14 21:55:41 +00:00
|
|
|
#define GST_STATE_TRANSITION(obj) ((GST_STATE(obj)<<8) | GST_STATE_PENDING(obj))
|
2001-01-23 20:03:07 +00:00
|
|
|
#define GST_STATE_NULL_TO_READY ((GST_STATE_NULL<<8) | GST_STATE_READY)
|
2001-05-25 21:00:07 +00:00
|
|
|
#define GST_STATE_READY_TO_PAUSED ((GST_STATE_READY<<8) | GST_STATE_PAUSED)
|
2001-01-14 21:55:41 +00:00
|
|
|
#define GST_STATE_PAUSED_TO_PLAYING ((GST_STATE_PAUSED<<8) | GST_STATE_PLAYING)
|
2001-05-25 21:00:07 +00:00
|
|
|
#define GST_STATE_PLAYING_TO_PAUSED ((GST_STATE_PLAYING<<8) | GST_STATE_PAUSED)
|
|
|
|
|
#define GST_STATE_PAUSED_TO_READY ((GST_STATE_PAUSED<<8) | GST_STATE_READY)
|
2001-01-14 21:55:41 +00:00
|
|
|
#define GST_STATE_READY_TO_NULL ((GST_STATE_READY<<8) | GST_STATE_NULL)
|
2000-12-23 03:17:52 +00:00
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
extern GType _gst_element_type;
|
|
|
|
|
|
|
|
|
|
#define GST_TYPE_ELEMENT (_gst_element_type)
|
|
|
|
|
#define GST_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_ELEMENT))
|
2002-12-19 21:31:03 +00:00
|
|
|
#define GST_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_ELEMENT))
|
|
|
|
|
#define GST_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_ELEMENT, GstElementClass))
|
2003-12-13 16:58:29 +00:00
|
|
|
#define GST_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_ELEMENT, GstElement))
|
|
|
|
|
#define GST_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_ELEMENT, GstElementClass))
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-12-30 17:42:11 +00:00
|
|
|
/* convenience functions */
|
|
|
|
|
#ifdef G_HAVE_ISO_VARARGS
|
|
|
|
|
#define GST_ELEMENT_QUERY_TYPE_FUNCTION(functionname, ...) \
|
|
|
|
|
GST_QUERY_TYPE_FUNCTION (GstElement*, functionname, __VA_ARGS__);
|
|
|
|
|
#define GST_ELEMENT_FORMATS_FUNCTION(functionname, ...) \
|
|
|
|
|
GST_FORMATS_FUNCTION (GstElement*, functionname, __VA_ARGS__);
|
|
|
|
|
#define GST_ELEMENT_EVENT_MASK_FUNCTION(functionname, ...) \
|
|
|
|
|
GST_EVENT_MASK_FUNCTION (GstElement*, functionname, __VA_ARGS__);
|
|
|
|
|
#elif defined(G_HAVE_GNUC_VARARGS)
|
|
|
|
|
#define GST_ELEMENT_QUERY_TYPE_FUNCTION(functionname, a...) \
|
|
|
|
|
GST_QUERY_TYPE_FUNCTION (GstElement*, functionname, a);
|
|
|
|
|
#define GST_ELEMENT_FORMATS_FUNCTION(functionname, a...) \
|
|
|
|
|
GST_FORMATS_FUNCTION (GstElement*, functionname, a);
|
|
|
|
|
#define GST_ELEMENT_EVENT_MASK_FUNCTION(functionname, a...) \
|
|
|
|
|
GST_EVENT_MASK_FUNCTION (GstElement*, functionname, a);
|
|
|
|
|
#endif
|
|
|
|
|
|
2000-07-17 17:14:15 +00:00
|
|
|
typedef enum {
|
2000-12-28 21:42:23 +00:00
|
|
|
/* element is complex (for some def.) and generally require a cothread */
|
2000-12-20 09:39:43 +00:00
|
|
|
GST_ELEMENT_COMPLEX = GST_OBJECT_FLAG_LAST,
|
2000-12-28 21:42:23 +00:00
|
|
|
/* input and output pads aren't directly coupled to each other
|
|
|
|
|
examples: queues, multi-output async readers, etc. */
|
2000-12-26 23:51:04 +00:00
|
|
|
GST_ELEMENT_DECOUPLED,
|
2000-12-28 21:42:23 +00:00
|
|
|
/* this element should be placed in a thread if at all possible */
|
2000-12-15 01:57:34 +00:00
|
|
|
GST_ELEMENT_THREAD_SUGGESTED,
|
2001-12-22 21:18:17 +00:00
|
|
|
/* this element, for some reason, has a loop function that performs
|
|
|
|
|
* an infinite loop without calls to gst_element_yield () */
|
|
|
|
|
GST_ELEMENT_INFINITE_LOOP,
|
2000-12-28 21:42:23 +00:00
|
|
|
/* there is a new loopfunction ready for placement */
|
2000-12-15 01:57:34 +00:00
|
|
|
GST_ELEMENT_NEW_LOOPFUNC,
|
2001-11-14 21:07:33 +00:00
|
|
|
/* if this element can handle events */
|
|
|
|
|
GST_ELEMENT_EVENT_AWARE,
|
2002-05-26 03:23:25 +00:00
|
|
|
/* use threadsafe property get/set implementation */
|
|
|
|
|
GST_ELEMENT_USE_THREADSAFE_PROPERTIES,
|
|
|
|
|
|
|
|
|
|
/* private flags that can be used by the scheduler */
|
|
|
|
|
GST_ELEMENT_SCHEDULER_PRIVATE1,
|
|
|
|
|
GST_ELEMENT_SCHEDULER_PRIVATE2,
|
2001-11-14 21:07:33 +00:00
|
|
|
|
2003-03-25 19:39:18 +00:00
|
|
|
/* ignore state changes from parent */
|
|
|
|
|
GST_ELEMENT_LOCKED_STATE,
|
|
|
|
|
|
2003-06-03 21:18:39 +00:00
|
|
|
/* element is in error */
|
|
|
|
|
GST_ELEMENT_ERROR,
|
|
|
|
|
|
2000-12-15 01:57:34 +00:00
|
|
|
/* use some padding for future expansion */
|
2002-07-09 10:27:22 +00:00
|
|
|
GST_ELEMENT_FLAG_LAST = GST_OBJECT_FLAG_LAST + 16
|
2000-07-17 17:14:15 +00:00
|
|
|
} GstElementFlags;
|
|
|
|
|
|
Changed the way things are scheduled, especially sources. A Src used to have a push() function, and optionally a pus...
Original commit message from CVS:
Changed the way things are scheduled, especially sources. A Src used to
have a push() function, and optionally a pushregion() to deal with async
reads, etc. That whole thing has gone away, in favor of providing a
pull() function for the output (Src) pad instead, ala chain functions.
This makes constructing cothreaded schedules out of non-loop elements
somewhat easier. Basically there was always a question as to which pad
was being dealt with. In the pullregion case, cothread-specific data was
used to try to pass the region struct to the right place, which is a slow
hack. And in general, the push function severely limited the kind of
tricks that could be played when there's more than one output pad, such as
a multi-out file reader with async capabilities on each pad independently.
This changes the way cothread scheduling occurs. Instead of the hack to
deal with Src's by calling their push() function (or optionally the
pushregion(), in certain cases), we now are working towards a general
mechanism where pads are the only thing that are dealt with directly.
An optimization was made in the process of doing this: the loopfunction
actually run as the outer [stack] frame of the cothread is now set more
intelligently in create_plan() based on what kind of element it is. We
now have:
loopfunc_wrapper: used for loop-based elements, it simply calls the
loopfunc in a loop, paying attention to COTHREAD_STOPPING (see
below). It currently does other, soon to be depracated, stuff.
pullsrc_wrapper: wraps a Src that's not loop-based (since your options
are now loop- or pull-based)
There will be a couple more to deal with other cases, such as Connections
and chain-based elements. The general idea is that it's a lot more
efficient to make the decisions once in create_plan than to keep doing
this huge if/else chain in the wrapper. Just choose the right wrapper up
front. It'll be most apparent performance-wise in the case of whichever
element context is switched to first for each iteration, since the whole
wrapper setup is done for every iteration.
The tricky part is that there is now a bit of overloading of the function
pointers in a pad. The current meanings (possibly to change a bit more
soon) are:
chainfunc: as always, chainfunc pointer is mirrored between peer pads
(this may change, and the chain func may end up in pushfunc)
pushfunc: SrcPad: gst_pad_pushfunc_proxy, cothread_switch to peer
SinkPad: none (may take over chainfunc, see below) pullfunc:
SrcPad: Src or Connection's function to construct buffers
SinkPad: gst_pad_pullfunc_proxy, cothread_switch to peer
There are a number of issues remaining with the scheduling, not the least
of which is the fact that Connections are still dealt with the old way,
with _push() functions and such. I'm trying to figure out a way to unify
the system so it makes sense. Following the scheduling system is hard
enough, trying to change it is murder.
Another useful scheduling addition, mentioned above, is COTHREAD_STOPPING.
It's an element flag that's used to signal whatever code is running in
cothread context that it should be finishing up and exiting soon. An
example of this is in plugins/cobin/spindentity.c. All the loops should
now be composed of do/while loops, rather than while(1) loops:
do {
buf = gst_pad_pull(spindentity->sinkpad);
gst_pad_push(spindentity->srcpad,buf);
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING(element));
The reason for this is that COTHREAD_STOPPING may be set before the above
loop ever gets started. It wouldn't do for the body of the loop to never
once get called, that would simply stall the pipeline. Note that only the
core library code is ever responsible for setting and unsetting this flag.
All elements have to do is respond to it by cleanly exiting the loop and
the function holding it.
This is needed primarily to allow iterations to occur properly.
Basically, there's a single entry point in the cothread scheduling loop,
gst_bin_iterate_func() simply switches to this cothread. If the element
in this context is allowed to loop infinitely, nothing would even switch
back to the context from which the iterate() was originally called. This
is a bit of a problem. The solution is for there to be an implicit switch
back to the originating context. Now, even I'm not sure exactly how this
works, but if the cothread that's switched to actually returns, execution
returns back to the calling context, i.e. iterate_func().
COTHREAD_STOPPING is therefore set just before switching into this
(currently randomly chosen) context, on the assumption that it will return
promptly after finishing its duties. The burden of clearing the flag
falls to the various wrapper functions provided by the Bin code, thus
element writers don't have to worry about doing that at all (and simply
shouldn't).
Related changes:
All the sources in elements/ have been changed to reflect the new system.
FIXMEs:
1) gstpipeline.c calls gst_src_push at some point, dunno why, it's
commented out now.
2) any other sources, including vcdsrc, dvdsrc, and v4lsrc will break
badly and need to be modified to work as pull-based sources.
2000-12-04 10:52:30 +00:00
|
|
|
#define GST_ELEMENT_IS_THREAD_SUGGESTED(obj) (GST_FLAG_IS_SET(obj,GST_ELEMENT_THREAD_SUGGESTED))
|
2001-11-14 21:07:33 +00:00
|
|
|
#define GST_ELEMENT_IS_EVENT_AWARE(obj) (GST_FLAG_IS_SET(obj,GST_ELEMENT_EVENT_AWARE))
|
2001-12-27 00:47:41 +00:00
|
|
|
#define GST_ELEMENT_IS_DECOUPLED(obj) (GST_FLAG_IS_SET(obj,GST_ELEMENT_DECOUPLED))
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
#define GST_ELEMENT_NAME(obj) (GST_OBJECT_NAME(obj))
|
|
|
|
|
#define GST_ELEMENT_PARENT(obj) (GST_OBJECT_PARENT(obj))
|
2001-05-25 21:00:07 +00:00
|
|
|
#define GST_ELEMENT_MANAGER(obj) (((GstElement*)(obj))->manager)
|
|
|
|
|
#define GST_ELEMENT_SCHED(obj) (((GstElement*)(obj))->sched)
|
2002-02-03 20:07:09 +00:00
|
|
|
#define GST_ELEMENT_CLOCK(obj) (((GstElement*)(obj))->clock)
|
2001-03-07 21:52:56 +00:00
|
|
|
#define GST_ELEMENT_PADS(obj) ((obj)->pads)
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2004-01-26 23:16:21 +00:00
|
|
|
#define gst_element_error(el, domain, code, message, debug) G_STMT_START { \
|
2004-01-20 10:53:20 +00:00
|
|
|
gst_element_error_full (GST_ELEMENT(el), \
|
2004-01-18 21:36:20 +00:00
|
|
|
GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code, \
|
2004-01-19 18:23:19 +00:00
|
|
|
_gst_element_error_printf message, \
|
|
|
|
|
_gst_element_error_printf debug, \
|
2004-01-26 23:16:21 +00:00
|
|
|
__FILE__, GST_FUNCTION, __LINE__); } G_STMT_END
|
2004-01-18 21:36:20 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
typedef struct _GstElementFactory GstElementFactory;
|
2001-08-21 20:16:48 +00:00
|
|
|
typedef struct _GstElementFactoryClass GstElementFactoryClass;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-02-03 20:07:09 +00:00
|
|
|
typedef void (*GstElementLoopFunction) (GstElement *element);
|
2002-05-26 03:23:25 +00:00
|
|
|
typedef void (*GstElementPreRunFunction) (GstElement *element);
|
|
|
|
|
typedef void (*GstElementPostRunFunction) (GstElement *element);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
|
struct _GstElement {
|
2001-10-17 10:21:27 +00:00
|
|
|
GstObject object;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
/* element state and scheduling */
|
|
|
|
|
guint8 current_state;
|
|
|
|
|
guint8 pending_state;
|
2000-01-30 09:03:00 +00:00
|
|
|
GstElementLoopFunction loopfunc;
|
2001-12-22 21:18:17 +00:00
|
|
|
|
|
|
|
|
GstScheduler *sched;
|
|
|
|
|
gpointer sched_private;
|
2002-12-19 21:31:03 +00:00
|
|
|
|
|
|
|
|
/* allocated clock */
|
2002-05-26 21:54:27 +00:00
|
|
|
GstClock *clock;
|
gst/gstclock.*: deprecate old interface and disable functions that aren't in use anymore.
Original commit message from CVS:
2004-01-13 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_init),
(gst_clock_set_speed), (gst_clock_set_active),
(gst_clock_is_active), (gst_clock_reset),
(gst_clock_handle_discont):
* gst/gstclock.h:
deprecate old interface and disable functions that aren't in use
anymore.
* gst/gstelement.h:
* gst/gstelement.c: (gst_element_get_time), (gst_element_wait),
(gst_element_set_time), (gst_element_adjust_time):
add concept of "element time" and functions to get/set this time.
* gst/gstelement.c: (gst_element_change_state):
update element time correctly.
* gst/gstelement.c: (gst_element_get_compatible_pad_filtered):
This is a debug message, not a g_critical.
* gst/gstpad.c: (gst_pad_event_default):
handle discontinuous events right with element time.
* gst/gstscheduler.c: (gst_scheduler_state_transition):
update to clocking fixes.
set clocks on elements in READY=>PAUSED. The old behaviour caused
a wrong element time on the first element that started playing.
* gst/schedulers/gstbasicscheduler.c:
(gst_basic_scheduler_class_init):
* gst/schedulers/gstoptimalscheduler.c:
(gst_opt_scheduler_class_init):
remove code that just implements the default behaviour.
* gst/elements/gstfakesink.c: (gst_fakesink_chain):
update to use new clocking functions
* testsuite/clock/clock1.c: (gst_clock_debug), (main):
* testsuite/clock/clock2.c: (gst_clock_debug), (main):
update to test new element time.
* gst/autoplug/gstspideridentity.c: (gst_spider_identity_getcaps):
use _get_allowed_caps instead of _get_caps. This catches filtered
caps correctly.
* testsuite/debug/commandline.c:
update for new GST_DEBUG syntax.
* testsuite/threads/Makefile.am:
disable a test that only works sometimes.
2004-01-14 00:46:48 +00:00
|
|
|
GstClockTimeDiff base_time; /* NULL/READY: 0 - PAUSED: current time - PLAYING: difference to clock */
|
2001-10-17 10:21:27 +00:00
|
|
|
|
|
|
|
|
/* element pads */
|
|
|
|
|
guint16 numpads;
|
|
|
|
|
guint16 numsrcpads;
|
|
|
|
|
guint16 numsinkpads;
|
|
|
|
|
GList *pads;
|
2001-12-18 19:03:07 +00:00
|
|
|
|
|
|
|
|
GMutex *state_mutex;
|
|
|
|
|
GCond *state_cond;
|
2002-05-26 03:23:25 +00:00
|
|
|
|
|
|
|
|
GstElementPreRunFunction pre_run_func;
|
|
|
|
|
GstElementPostRunFunction post_run_func;
|
|
|
|
|
GAsyncQueue *prop_value_queue;
|
|
|
|
|
GMutex *property_mutex;
|
2002-12-19 21:31:03 +00:00
|
|
|
|
2003-12-09 02:39:31 +00:00
|
|
|
gpointer _gst_reserved[GST_PADDING];
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GstElementClass {
|
2001-10-17 10:21:27 +00:00
|
|
|
GstObjectClass parent_class;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
/* the element details */
|
|
|
|
|
GstElementDetails details;
|
2003-11-02 16:46:12 +00:00
|
|
|
|
|
|
|
|
/* factory that the element was created from */
|
|
|
|
|
GstElementFactory *elementfactory;
|
|
|
|
|
|
2001-07-11 12:33:17 +00:00
|
|
|
/* templates for our pads */
|
2001-10-17 10:21:27 +00:00
|
|
|
GList *padtemplates;
|
|
|
|
|
gint numpadtemplates;
|
2001-07-11 12:33:17 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/* signal callbacks */
|
2002-05-26 03:23:25 +00:00
|
|
|
void (*state_change) (GstElement *element, GstElementState old, GstElementState state);
|
|
|
|
|
void (*new_pad) (GstElement *element, GstPad *pad);
|
|
|
|
|
void (*pad_removed) (GstElement *element, GstPad *pad);
|
2004-01-18 21:36:20 +00:00
|
|
|
void (*error) (GstElement *element, GstElement *source, GError *error, gchar *debug);
|
2002-05-26 03:23:25 +00:00
|
|
|
void (*eos) (GstElement *element);
|
2004-01-29 02:24:52 +00:00
|
|
|
void (*found_tag) (GstElement *element, GstElement *source, const GstTagList *tag_list);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
|
/* local pointers for get/set */
|
2001-10-17 10:21:27 +00:00
|
|
|
void (*set_property) (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
|
2001-12-13 23:14:39 +00:00
|
|
|
void (*get_property) (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-12-18 19:03:07 +00:00
|
|
|
/* vtable*/
|
2002-05-26 21:54:27 +00:00
|
|
|
gboolean (*release_locks) (GstElement *element);
|
2002-12-30 17:42:11 +00:00
|
|
|
|
|
|
|
|
/* query/convert/events functions */
|
|
|
|
|
const GstEventMask* (*get_event_masks) (GstElement *element);
|
2002-05-30 19:03:30 +00:00
|
|
|
gboolean (*send_event) (GstElement *element, GstEvent *event);
|
2002-12-30 17:42:11 +00:00
|
|
|
const GstFormat* (*get_formats) (GstElement *element);
|
|
|
|
|
gboolean (*convert) (GstElement *element,
|
|
|
|
|
GstFormat src_format, gint64 src_value,
|
|
|
|
|
GstFormat *dest_format, gint64 *dest_value);
|
|
|
|
|
const GstQueryType* (*get_query_types) (GstElement *element);
|
|
|
|
|
gboolean (*query) (GstElement *element, GstQueryType type,
|
2002-06-08 14:59:34 +00:00
|
|
|
GstFormat *format, gint64 *value);
|
2002-12-30 17:42:11 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/* change the element state */
|
2001-01-23 20:03:07 +00:00
|
|
|
GstElementStateReturn (*change_state) (GstElement *element);
|
2002-12-30 17:42:11 +00:00
|
|
|
|
|
|
|
|
/* request/release pads */
|
2001-10-17 10:21:27 +00:00
|
|
|
GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar* name);
|
2002-04-28 13:27:32 +00:00
|
|
|
void (*release_pad) (GstElement *element, GstPad *pad);
|
2002-12-30 17:42:11 +00:00
|
|
|
|
2002-11-27 20:47:39 +00:00
|
|
|
/* set/get clocks */
|
|
|
|
|
GstClock* (*get_clock) (GstElement *element);
|
|
|
|
|
void (*set_clock) (GstElement *element, GstClock *clock);
|
2002-12-30 17:42:11 +00:00
|
|
|
|
2002-12-12 22:14:36 +00:00
|
|
|
/* index */
|
|
|
|
|
GstIndex* (*get_index) (GstElement *element);
|
|
|
|
|
void (*set_index) (GstElement *element, GstIndex *index);
|
2002-12-19 21:31:03 +00:00
|
|
|
|
2004-01-15 09:36:01 +00:00
|
|
|
GstElementStateReturn (*set_state) (GstElement *element, GstElementState state);
|
2004-01-15 03:03:15 +00:00
|
|
|
gpointer _gst_reserved[GST_PADDING - 1];
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
|
|
|
|
|
2002-04-11 20:35:18 +00:00
|
|
|
void gst_element_class_add_pad_template (GstElementClass *klass, GstPadTemplate *templ);
|
2002-05-26 03:23:25 +00:00
|
|
|
void gst_element_class_install_std_props (GstElementClass *klass,
|
|
|
|
|
const gchar *first_name, ...);
|
2003-10-31 19:32:47 +00:00
|
|
|
void gst_element_class_set_details (GstElementClass *klass,
|
2003-12-22 01:39:35 +00:00
|
|
|
const GstElementDetails *details);
|
2002-05-26 03:23:25 +00:00
|
|
|
|
2002-11-02 13:19:30 +00:00
|
|
|
#define gst_element_default_deep_notify gst_object_default_deep_notify
|
|
|
|
|
|
2004-01-18 21:36:20 +00:00
|
|
|
void gst_element_default_error (GObject *object, GstObject *orig, GError *error, gchar *debug);
|
2001-07-11 12:33:17 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType gst_element_get_type (void);
|
2001-01-19 22:15:21 +00:00
|
|
|
void gst_element_set_loop_function (GstElement *element,
|
|
|
|
|
GstElementLoopFunction loop);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-12-07 22:18:17 +00:00
|
|
|
#define gst_element_get_name(elem) gst_object_get_name(GST_OBJECT(elem))
|
2002-12-08 02:08:47 +00:00
|
|
|
#define gst_element_set_name(elem,name) gst_object_set_name(GST_OBJECT(elem),name)
|
2002-12-07 22:18:17 +00:00
|
|
|
#define gst_element_get_parent(elem) gst_object_get_parent(GST_OBJECT(elem))
|
2002-12-08 02:08:47 +00:00
|
|
|
#define gst_element_set_parent(elem,parent) gst_object_set_parent(GST_OBJECT(elem),parent)
|
2002-12-07 22:18:17 +00:00
|
|
|
|
2002-05-26 03:23:25 +00:00
|
|
|
/* threadsafe versions of their g_object_* counterparts */
|
|
|
|
|
void gst_element_set (GstElement *element, const gchar *first_property_name, ...);
|
|
|
|
|
void gst_element_get (GstElement *element, const gchar *first_property_name, ...);
|
|
|
|
|
void gst_element_set_valist (GstElement *element, const gchar *first_property_name,
|
|
|
|
|
va_list var_args);
|
|
|
|
|
void gst_element_get_valist (GstElement *element, const gchar *first_property_name,
|
|
|
|
|
va_list var_args);
|
|
|
|
|
void gst_element_set_property (GstElement *element, const gchar *property_name,
|
|
|
|
|
const GValue *value);
|
|
|
|
|
void gst_element_get_property (GstElement *element, const gchar *property_name,
|
|
|
|
|
GValue *value);
|
|
|
|
|
|
|
|
|
|
void gst_element_enable_threadsafe_properties (GstElement *element);
|
|
|
|
|
void gst_element_disable_threadsafe_properties (GstElement *element);
|
|
|
|
|
void gst_element_set_pending_properties (GstElement *element);
|
|
|
|
|
|
2002-11-27 20:47:39 +00:00
|
|
|
/* clocking */
|
|
|
|
|
gboolean gst_element_requires_clock (GstElement *element);
|
|
|
|
|
gboolean gst_element_provides_clock (GstElement *element);
|
2002-02-03 20:07:09 +00:00
|
|
|
GstClock* gst_element_get_clock (GstElement *element);
|
|
|
|
|
void gst_element_set_clock (GstElement *element, GstClock *clock);
|
gst/gstclock.*: deprecate old interface and disable functions that aren't in use anymore.
Original commit message from CVS:
2004-01-13 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_init),
(gst_clock_set_speed), (gst_clock_set_active),
(gst_clock_is_active), (gst_clock_reset),
(gst_clock_handle_discont):
* gst/gstclock.h:
deprecate old interface and disable functions that aren't in use
anymore.
* gst/gstelement.h:
* gst/gstelement.c: (gst_element_get_time), (gst_element_wait),
(gst_element_set_time), (gst_element_adjust_time):
add concept of "element time" and functions to get/set this time.
* gst/gstelement.c: (gst_element_change_state):
update element time correctly.
* gst/gstelement.c: (gst_element_get_compatible_pad_filtered):
This is a debug message, not a g_critical.
* gst/gstpad.c: (gst_pad_event_default):
handle discontinuous events right with element time.
* gst/gstscheduler.c: (gst_scheduler_state_transition):
update to clocking fixes.
set clocks on elements in READY=>PAUSED. The old behaviour caused
a wrong element time on the first element that started playing.
* gst/schedulers/gstbasicscheduler.c:
(gst_basic_scheduler_class_init):
* gst/schedulers/gstoptimalscheduler.c:
(gst_opt_scheduler_class_init):
remove code that just implements the default behaviour.
* gst/elements/gstfakesink.c: (gst_fakesink_chain):
update to use new clocking functions
* testsuite/clock/clock1.c: (gst_clock_debug), (main):
* testsuite/clock/clock2.c: (gst_clock_debug), (main):
update to test new element time.
* gst/autoplug/gstspideridentity.c: (gst_spider_identity_getcaps):
use _get_allowed_caps instead of _get_caps. This catches filtered
caps correctly.
* testsuite/debug/commandline.c:
update for new GST_DEBUG syntax.
* testsuite/threads/Makefile.am:
disable a test that only works sometimes.
2004-01-14 00:46:48 +00:00
|
|
|
#ifndef GST_DEISABLE_DEPRECATED
|
2002-12-27 22:57:13 +00:00
|
|
|
GstClockReturn gst_element_clock_wait (GstElement *element,
|
|
|
|
|
GstClockID id, GstClockTimeDiff *jitter);
|
gst/gstclock.*: deprecate old interface and disable functions that aren't in use anymore.
Original commit message from CVS:
2004-01-13 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_init),
(gst_clock_set_speed), (gst_clock_set_active),
(gst_clock_is_active), (gst_clock_reset),
(gst_clock_handle_discont):
* gst/gstclock.h:
deprecate old interface and disable functions that aren't in use
anymore.
* gst/gstelement.h:
* gst/gstelement.c: (gst_element_get_time), (gst_element_wait),
(gst_element_set_time), (gst_element_adjust_time):
add concept of "element time" and functions to get/set this time.
* gst/gstelement.c: (gst_element_change_state):
update element time correctly.
* gst/gstelement.c: (gst_element_get_compatible_pad_filtered):
This is a debug message, not a g_critical.
* gst/gstpad.c: (gst_pad_event_default):
handle discontinuous events right with element time.
* gst/gstscheduler.c: (gst_scheduler_state_transition):
update to clocking fixes.
set clocks on elements in READY=>PAUSED. The old behaviour caused
a wrong element time on the first element that started playing.
* gst/schedulers/gstbasicscheduler.c:
(gst_basic_scheduler_class_init):
* gst/schedulers/gstoptimalscheduler.c:
(gst_opt_scheduler_class_init):
remove code that just implements the default behaviour.
* gst/elements/gstfakesink.c: (gst_fakesink_chain):
update to use new clocking functions
* testsuite/clock/clock1.c: (gst_clock_debug), (main):
* testsuite/clock/clock2.c: (gst_clock_debug), (main):
update to test new element time.
* gst/autoplug/gstspideridentity.c: (gst_spider_identity_getcaps):
use _get_allowed_caps instead of _get_caps. This catches filtered
caps correctly.
* testsuite/debug/commandline.c:
update for new GST_DEBUG syntax.
* testsuite/threads/Makefile.am:
disable a test that only works sometimes.
2004-01-14 00:46:48 +00:00
|
|
|
#endif
|
|
|
|
|
GstClockTime gst_element_get_time (GstElement *element);
|
|
|
|
|
gboolean gst_element_wait (GstElement *element, GstClockTime timestamp);
|
|
|
|
|
void gst_element_set_time (GstElement *element, GstClockTime time);
|
|
|
|
|
void gst_element_adjust_time (GstElement *element, GstClockTimeDiff diff);
|
2003-02-10 20:32:32 +00:00
|
|
|
|
2002-12-12 22:14:36 +00:00
|
|
|
/* indexs */
|
2002-12-14 13:02:16 +00:00
|
|
|
gboolean gst_element_is_indexable (GstElement *element);
|
2002-12-12 22:14:36 +00:00
|
|
|
void gst_element_set_index (GstElement *element, GstIndex *index);
|
|
|
|
|
GstIndex* gst_element_get_index (GstElement *element);
|
2002-11-27 20:47:39 +00:00
|
|
|
|
2002-05-26 21:54:27 +00:00
|
|
|
|
|
|
|
|
gboolean gst_element_release_locks (GstElement *element);
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2001-12-22 23:19:17 +00:00
|
|
|
void gst_element_yield (GstElement *element);
|
2001-12-27 00:47:41 +00:00
|
|
|
gboolean gst_element_interrupt (GstElement *element);
|
2002-05-25 15:36:59 +00:00
|
|
|
void gst_element_set_scheduler (GstElement *element, GstScheduler *sched);
|
|
|
|
|
GstScheduler* gst_element_get_scheduler (GstElement *element);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
void gst_element_add_pad (GstElement *element, GstPad *pad);
|
2001-05-25 21:00:07 +00:00
|
|
|
void gst_element_remove_pad (GstElement *element, GstPad *pad);
|
2002-08-12 16:40:50 +00:00
|
|
|
GstPad * gst_element_add_ghost_pad (GstElement *element, GstPad *pad, const gchar *name);
|
2002-04-07 23:32:16 +00:00
|
|
|
void gst_element_remove_ghost_pad (GstElement *element, GstPad *pad);
|
|
|
|
|
|
2001-01-06 02:35:17 +00:00
|
|
|
GstPad* gst_element_get_pad (GstElement *element, const gchar *name);
|
2002-04-07 23:32:16 +00:00
|
|
|
GstPad* gst_element_get_static_pad (GstElement *element, const gchar *name);
|
|
|
|
|
GstPad* gst_element_get_request_pad (GstElement *element, const gchar *name);
|
2002-04-28 13:27:32 +00:00
|
|
|
void gst_element_release_request_pad (GstElement *element, GstPad *pad);
|
2002-04-07 23:32:16 +00:00
|
|
|
|
2003-11-29 06:34:05 +00:00
|
|
|
G_CONST_RETURN GList*
|
|
|
|
|
gst_element_get_pad_list (GstElement *element);
|
2002-04-07 23:32:16 +00:00
|
|
|
GstPad* gst_element_get_compatible_pad (GstElement *element, GstPad *pad);
|
2002-01-28 00:51:39 +00:00
|
|
|
GstPad* gst_element_get_compatible_pad_filtered (GstElement *element, GstPad *pad,
|
2003-12-22 01:39:35 +00:00
|
|
|
const GstCaps *filtercaps);
|
2002-04-12 20:06:14 +00:00
|
|
|
|
2003-11-08 23:28:04 +00:00
|
|
|
GstPadTemplate* gst_element_class_get_pad_template (GstElementClass *element_class, const gchar *name);
|
|
|
|
|
GList* gst_element_class_get_pad_template_list (GstElementClass *element_class);
|
2002-08-12 16:59:39 +00:00
|
|
|
GstPadTemplate* gst_element_get_pad_template (GstElement *element, const gchar *name);
|
2002-04-12 20:06:14 +00:00
|
|
|
GList* gst_element_get_pad_template_list (GstElement *element);
|
|
|
|
|
GstPadTemplate* gst_element_get_compatible_pad_template (GstElement *element, GstPadTemplate *compattempl);
|
2001-01-18 23:46:15 +00:00
|
|
|
|
2003-01-09 14:15:37 +00:00
|
|
|
gboolean gst_element_link (GstElement *src, GstElement *dest);
|
2003-03-25 19:39:18 +00:00
|
|
|
gboolean gst_element_link_many (GstElement *element_1,
|
|
|
|
|
GstElement *element_2, ...);
|
2003-01-09 14:15:37 +00:00
|
|
|
gboolean gst_element_link_filtered (GstElement *src, GstElement *dest,
|
2003-12-22 01:39:35 +00:00
|
|
|
const GstCaps *filtercaps);
|
2003-01-09 14:15:37 +00:00
|
|
|
void gst_element_unlink (GstElement *src, GstElement *dest);
|
2003-03-25 19:39:18 +00:00
|
|
|
void gst_element_unlink_many (GstElement *element_1,
|
|
|
|
|
GstElement *element_2, ...);
|
2002-04-07 23:32:16 +00:00
|
|
|
|
2003-03-25 19:39:18 +00:00
|
|
|
gboolean gst_element_link_pads (GstElement *src, const gchar *srcpadname,
|
2001-01-19 22:15:21 +00:00
|
|
|
GstElement *dest, const gchar *destpadname);
|
2003-03-25 19:39:18 +00:00
|
|
|
gboolean gst_element_link_pads_filtered (GstElement *src, const gchar *srcpadname,
|
2002-01-13 22:22:42 +00:00
|
|
|
GstElement *dest, const gchar *destpadname,
|
2003-12-22 01:39:35 +00:00
|
|
|
const GstCaps *filtercaps);
|
2003-03-25 19:39:18 +00:00
|
|
|
void gst_element_unlink_pads (GstElement *src, const gchar *srcpadname,
|
2001-01-19 22:15:21 +00:00
|
|
|
GstElement *dest, const gchar *destpadname);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-11-29 06:34:05 +00:00
|
|
|
G_CONST_RETURN GstEventMask*
|
|
|
|
|
gst_element_get_event_masks (GstElement *element);
|
2002-05-30 19:03:30 +00:00
|
|
|
gboolean gst_element_send_event (GstElement *element, GstEvent *event);
|
2003-08-04 21:48:06 +00:00
|
|
|
gboolean gst_element_seek (GstElement *element, GstSeekType seek_type,
|
|
|
|
|
guint64 offset);
|
2003-11-29 06:34:05 +00:00
|
|
|
G_CONST_RETURN GstQueryType*
|
|
|
|
|
gst_element_get_query_types (GstElement *element);
|
2002-12-30 17:42:11 +00:00
|
|
|
gboolean gst_element_query (GstElement *element, GstQueryType type,
|
2002-06-08 14:59:34 +00:00
|
|
|
GstFormat *format, gint64 *value);
|
2003-11-29 06:34:05 +00:00
|
|
|
G_CONST_RETURN GstFormat*
|
|
|
|
|
gst_element_get_formats (GstElement *element);
|
2002-12-30 17:42:11 +00:00
|
|
|
gboolean gst_element_convert (GstElement *element,
|
|
|
|
|
GstFormat src_format, gint64 src_value,
|
|
|
|
|
GstFormat *dest_format, gint64 *dest_value);
|
2002-05-30 19:03:30 +00:00
|
|
|
|
2004-01-29 02:24:52 +00:00
|
|
|
void gst_element_found_tags (GstElement *element, const GstTagList *tag_list);
|
2003-11-24 02:09:23 +00:00
|
|
|
void gst_element_found_tags_for_pad (GstElement *element, GstPad *pad, GstClockTime timestamp,
|
|
|
|
|
GstTagList *list);
|
|
|
|
|
|
2001-12-28 20:20:26 +00:00
|
|
|
void gst_element_set_eos (GstElement *element);
|
2000-12-29 02:28:04 +00:00
|
|
|
|
2004-01-20 10:53:20 +00:00
|
|
|
gchar * _gst_element_error_printf (const gchar *format, ...);
|
2004-01-26 03:44:14 +00:00
|
|
|
void gst_element_error_full (GstElement *element, GQuark domain, gint code,
|
|
|
|
|
gchar *message, gchar *debug,
|
|
|
|
|
const gchar *file, const gchar *function, gint line);
|
2000-12-29 02:28:04 +00:00
|
|
|
|
2003-04-11 00:00:46 +00:00
|
|
|
gboolean gst_element_is_locked_state (GstElement *element);
|
|
|
|
|
void gst_element_set_locked_state (GstElement *element, gboolean locked_state);
|
|
|
|
|
gboolean gst_element_sync_state_with_parent (GstElement *element);
|
2003-04-08 21:14:23 +00:00
|
|
|
|
2001-10-21 18:00:31 +00:00
|
|
|
GstElementState gst_element_get_state (GstElement *element);
|
2002-10-29 18:39:32 +00:00
|
|
|
GstElementStateReturn gst_element_set_state (GstElement *element, GstElementState state);
|
2001-12-04 22:12:50 +00:00
|
|
|
|
|
|
|
|
void gst_element_wait_state_change (GstElement *element);
|
|
|
|
|
|
2003-11-29 06:34:05 +00:00
|
|
|
G_CONST_RETURN gchar* gst_element_state_get_name (GstElementState state);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-11-02 16:46:12 +00:00
|
|
|
GstElementFactory* gst_element_get_factory (GstElement *element);
|
|
|
|
|
|
2002-03-06 16:14:34 +00:00
|
|
|
GstBin* gst_element_get_managing_bin (GstElement *element);
|
|
|
|
|
|
2001-12-13 23:37:47 +00:00
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
/*
|
2000-12-19 13:41:55 +00:00
|
|
|
*
|
|
|
|
|
* factories stuff
|
|
|
|
|
*
|
|
|
|
|
**/
|
2001-08-21 20:16:48 +00:00
|
|
|
|
2002-04-11 20:35:18 +00:00
|
|
|
#define GST_TYPE_ELEMENT_FACTORY (gst_element_factory_get_type())
|
|
|
|
|
#define GST_ELEMENT_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ELEMENT_FACTORY,\
|
2001-10-17 10:21:27 +00:00
|
|
|
GstElementFactory))
|
2002-04-11 20:35:18 +00:00
|
|
|
#define GST_ELEMENT_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ELEMENT_FACTORY,\
|
2001-10-17 10:21:27 +00:00
|
|
|
GstElementFactoryClass))
|
2002-04-11 20:35:18 +00:00
|
|
|
#define GST_IS_ELEMENT_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ELEMENT_FACTORY))
|
|
|
|
|
#define GST_IS_ELEMENT_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ELEMENT_FACTORY))
|
2001-08-21 20:16:48 +00:00
|
|
|
|
|
|
|
|
struct _GstElementFactory {
|
2003-10-31 19:32:47 +00:00
|
|
|
GstPluginFeature parent;
|
2001-08-21 20:16:48 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
GType type; /* unique GType of element or 0 if not loaded */
|
2001-08-21 20:16:48 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
GstElementDetails details;
|
2001-09-13 20:12:17 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
GList * padtemplates;
|
|
|
|
|
guint numpadtemplates;
|
2003-10-07 21:58:42 +00:00
|
|
|
|
2003-11-24 03:21:54 +00:00
|
|
|
/* URI interface stuff */
|
|
|
|
|
guint uri_type;
|
|
|
|
|
gchar ** uri_protocols;
|
|
|
|
|
|
|
|
|
|
GList * interfaces; /* interfaces this element implements */
|
2003-11-24 02:09:23 +00:00
|
|
|
|
2003-12-09 02:39:31 +00:00
|
|
|
gpointer _gst_reserved[GST_PADDING];
|
2001-08-21 20:16:48 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GstElementFactoryClass {
|
|
|
|
|
GstPluginFeatureClass parent_class;
|
2003-10-07 21:58:42 +00:00
|
|
|
|
2003-12-09 02:39:31 +00:00
|
|
|
gpointer _gst_reserved[GST_PADDING];
|
2001-08-21 20:16:48 +00:00
|
|
|
};
|
|
|
|
|
|
2002-04-11 20:35:18 +00:00
|
|
|
GType gst_element_factory_get_type (void);
|
2001-08-21 20:16:48 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
gboolean gst_element_register (GstPlugin *plugin,
|
|
|
|
|
const gchar *elementname,
|
|
|
|
|
guint rank,
|
|
|
|
|
GType type);
|
|
|
|
|
|
2003-11-02 16:24:22 +00:00
|
|
|
GstElementFactory * gst_element_factory_find (const gchar *name);
|
2003-10-31 19:32:47 +00:00
|
|
|
GType gst_element_factory_get_element_type (GstElementFactory *factory);
|
|
|
|
|
G_CONST_RETURN gchar * gst_element_factory_get_longname (GstElementFactory *factory);
|
|
|
|
|
G_CONST_RETURN gchar * gst_element_factory_get_klass (GstElementFactory *factory);
|
|
|
|
|
G_CONST_RETURN gchar * gst_element_factory_get_description (GstElementFactory *factory);
|
|
|
|
|
G_CONST_RETURN gchar * gst_element_factory_get_author (GstElementFactory *factory);
|
2003-12-04 10:02:41 +00:00
|
|
|
guint gst_element_factory_get_num_pad_templates (GstElementFactory *factory);
|
|
|
|
|
G_CONST_RETURN GList * gst_element_factory_get_pad_templates (GstElementFactory *factory);
|
2003-11-24 03:21:54 +00:00
|
|
|
guint gst_element_factory_get_uri_type (GstElementFactory *factory);
|
|
|
|
|
gchar ** gst_element_factory_get_uri_protocols (GstElementFactory *factory);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
GstElement* gst_element_factory_create (GstElementFactory *factory,
|
|
|
|
|
const gchar *name);
|
|
|
|
|
GstElement* gst_element_factory_make (const gchar *factoryname, const gchar *name);
|
2001-01-18 23:46:15 +00:00
|
|
|
|
2002-05-08 20:40:48 +00:00
|
|
|
gboolean gst_element_factory_can_src_caps (GstElementFactory *factory,
|
2003-12-22 01:39:35 +00:00
|
|
|
const GstCaps *caps);
|
2002-04-11 20:35:18 +00:00
|
|
|
gboolean gst_element_factory_can_sink_caps (GstElementFactory *factory,
|
2003-12-22 01:39:35 +00:00
|
|
|
const GstCaps *caps);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
void __gst_element_factory_add_pad_template (GstElementFactory *elementfactory,
|
|
|
|
|
GstPadTemplate *templ);
|
2003-11-24 02:09:23 +00:00
|
|
|
void __gst_element_factory_add_interface (GstElementFactory *elementfactory,
|
|
|
|
|
const gchar *interfacename);
|
2000-08-28 20:20:55 +00:00
|
|
|
|
2003-08-19 07:31:24 +00:00
|
|
|
|
2002-05-26 03:23:25 +00:00
|
|
|
G_END_DECLS
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
|
|
2001-01-23 20:03:07 +00:00
|
|
|
#endif /* __GST_ELEMENT_H__ */
|
2000-01-30 09:03:00 +00:00
|
|
|
|
