|
1 /* GStreamer |
|
2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu> |
|
3 * 2000,2004 Wim Taymans <wim@fluendo.com> |
|
4 * |
|
5 * gstelement.h: Header for GstElement |
|
6 * |
|
7 * This library is free software; you can redistribute it and/or |
|
8 * modify it under the terms of the GNU Library General Public |
|
9 * License as published by the Free Software Foundation; either |
|
10 * version 2 of the License, or (at your option) any later version. |
|
11 * |
|
12 * This library is distributed in the hope that it will be useful, |
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
15 * Library General Public License for more details. |
|
16 * |
|
17 * You should have received a copy of the GNU Library General Public |
|
18 * License along with this library; if not, write to the |
|
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
|
20 * Boston, MA 02111-1307, USA. |
|
21 */ |
|
22 |
|
23 |
|
24 #ifndef __GST_ELEMENT_H__ |
|
25 #define __GST_ELEMENT_H__ |
|
26 |
|
27 /* gstelement.h and gstelementfactory.h include eachother */ |
|
28 typedef struct _GstElement GstElement; |
|
29 typedef struct _GstElementClass GstElementClass; |
|
30 |
|
31 /* gstmessage.h needs State */ |
|
32 /** |
|
33 * GstState: |
|
34 * @GST_STATE_VOID_PENDING : no pending state. |
|
35 * @GST_STATE_NULL : the NULL state or initial state of an element |
|
36 * @GST_STATE_READY : the element is ready to go to PAUSED |
|
37 * @GST_STATE_PAUSED : the element is PAUSED |
|
38 * @GST_STATE_PLAYING : the element is PLAYING |
|
39 * |
|
40 * The posible states an element can be in. |
|
41 */ |
|
42 typedef enum { |
|
43 GST_STATE_VOID_PENDING = 0, |
|
44 GST_STATE_NULL = 1, |
|
45 GST_STATE_READY = 2, |
|
46 GST_STATE_PAUSED = 3, |
|
47 GST_STATE_PLAYING = 4 |
|
48 } GstState; |
|
49 |
|
50 |
|
51 #include <gst/gstconfig.h> |
|
52 #include <gst/gstobject.h> |
|
53 #include <gst/gstpad.h> |
|
54 #include <gst/gstbus.h> |
|
55 #include <gst/gstclock.h> |
|
56 #include <gst/gstelementfactory.h> |
|
57 #include <gst/gstplugin.h> |
|
58 #include <gst/gstpluginfeature.h> |
|
59 #include <gst/gstindex.h> |
|
60 #include <gst/gstindexfactory.h> |
|
61 #include <gst/gstiterator.h> |
|
62 #include <gst/gstmessage.h> |
|
63 #include <gst/gsttaglist.h> |
|
64 |
|
65 G_BEGIN_DECLS |
|
66 |
|
67 #define GST_TYPE_ELEMENT (gst_element_get_type ()) |
|
68 #define GST_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_ELEMENT)) |
|
69 #define GST_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_ELEMENT)) |
|
70 #define GST_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_ELEMENT, GstElementClass)) |
|
71 #define GST_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_ELEMENT, GstElement)) |
|
72 #define GST_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_ELEMENT, GstElementClass)) |
|
73 #define GST_ELEMENT_CAST(obj) ((GstElement*)(obj)) |
|
74 |
|
75 /** |
|
76 * GstStateChangeReturn: |
|
77 * @GST_STATE_CHANGE_FAILURE : the state change failed |
|
78 * @GST_STATE_CHANGE_SUCCESS : the state change succeeded |
|
79 * @GST_STATE_CHANGE_ASYNC : the state change will happen asynchronously |
|
80 * @GST_STATE_CHANGE_NO_PREROLL: the state change succeeded but the element |
|
81 * cannot produce data in PAUSED. This typically |
|
82 * happens with live sources. |
|
83 * |
|
84 * The possible return values from a state change function. Only |
|
85 * @GST_STATE_CHANGE_FAILURE is a real failure. |
|
86 */ |
|
87 typedef enum { |
|
88 GST_STATE_CHANGE_FAILURE = 0, |
|
89 GST_STATE_CHANGE_SUCCESS = 1, |
|
90 GST_STATE_CHANGE_ASYNC = 2, |
|
91 GST_STATE_CHANGE_NO_PREROLL = 3 |
|
92 } GstStateChangeReturn; |
|
93 |
|
94 /* NOTE: this probably should be done with an #ifdef to decide |
|
95 * whether to safe-cast or to just do the non-checking cast. |
|
96 */ |
|
97 |
|
98 /** |
|
99 * GST_STATE: |
|
100 * @elem: a #GstElement to return state for. |
|
101 * |
|
102 * This macro returns the current #GstState of the element. |
|
103 */ |
|
104 #define GST_STATE(elem) (GST_ELEMENT_CAST(elem)->current_state) |
|
105 |
|
106 /** |
|
107 * GST_STATE_NEXT: |
|
108 * @elem: a #GstElement to return the next state for. |
|
109 * |
|
110 * This macro returns the next #GstState of the element. |
|
111 */ |
|
112 #define GST_STATE_NEXT(elem) (GST_ELEMENT_CAST(elem)->next_state) |
|
113 |
|
114 /** |
|
115 * GST_STATE_PENDING: |
|
116 * @elem: a #GstElement to return the pending state for. |
|
117 * |
|
118 * This macro returns the currently pending #GstState of the element. |
|
119 */ |
|
120 #define GST_STATE_PENDING(elem) (GST_ELEMENT_CAST(elem)->pending_state) |
|
121 |
|
122 /** |
|
123 * GST_STATE_TARGET: |
|
124 * @elem: a #GstElement to return the target state for. |
|
125 * |
|
126 * This macro returns the target #GstState of the element. |
|
127 * |
|
128 * Since: 0.10.13 |
|
129 */ |
|
130 #define GST_STATE_TARGET(elem) (GST_ELEMENT_CAST(elem)->abidata.ABI.target_state) |
|
131 |
|
132 /** |
|
133 * GST_STATE_RETURN: |
|
134 * @elem: a #GstElement to return the last state result for. |
|
135 * |
|
136 * This macro returns the last #GstStateChangeReturn value. |
|
137 */ |
|
138 #define GST_STATE_RETURN(elem) (GST_ELEMENT_CAST(elem)->last_return) |
|
139 |
|
140 #define __GST_SIGN(val) ((val) < 0 ? -1 : ((val) > 0 ? 1 : 0)) |
|
141 /** |
|
142 * GST_STATE_GET_NEXT: |
|
143 * @cur: A starting #GstState |
|
144 * @pending: A target #GstState |
|
145 * |
|
146 * Given a current state @cur and a target state @pending, calculate the next (intermediate) |
|
147 * #GstState. |
|
148 */ |
|
149 #define GST_STATE_GET_NEXT(cur,pending) ((cur) + __GST_SIGN ((gint)(pending) - (gint)(cur))) |
|
150 /** |
|
151 * GST_STATE_TRANSITION: |
|
152 * @cur: A current state |
|
153 * @next: A next state |
|
154 * |
|
155 * Given a current state @cur and a next state @next, calculate the associated |
|
156 * #GstStateChange transition. |
|
157 */ |
|
158 #define GST_STATE_TRANSITION(cur,next) ((GstStateChange)(((cur)<<3)|(next))) |
|
159 /** |
|
160 * GST_STATE_TRANSITION_CURRENT: |
|
161 * @trans: A #GstStateChange |
|
162 * |
|
163 * Given a state transition @trans, extract the current #GstState. |
|
164 */ |
|
165 #define GST_STATE_TRANSITION_CURRENT(trans) ((GstState)((trans)>>3)) |
|
166 /** |
|
167 * GST_STATE_TRANSITION_NEXT: |
|
168 * @trans: A #GstStateChange |
|
169 * |
|
170 * Given a state transition @trans, extract the next #GstState. |
|
171 */ |
|
172 #define GST_STATE_TRANSITION_NEXT(trans) ((GstState)((trans)&0x7)) |
|
173 |
|
174 /** |
|
175 * GstStateChange: |
|
176 * @GST_STATE_CHANGE_NULL_TO_READY : state change from NULL to READY |
|
177 * @GST_STATE_CHANGE_READY_TO_PAUSED : state change from READY to PAUSED |
|
178 * @GST_STATE_CHANGE_PAUSED_TO_PLAYING: state change from PAUSED to PLAYING |
|
179 * @GST_STATE_CHANGE_PLAYING_TO_PAUSED: state change from PLAYING to PAUSED |
|
180 * @GST_STATE_CHANGE_PAUSED_TO_READY : state change from PAUSED to READY |
|
181 * @GST_STATE_CHANGE_READY_TO_NULL : state change from READY to NULL |
|
182 * |
|
183 * The different (interesting) state changes that are passed to the |
|
184 * state change functions of elements. |
|
185 */ |
|
186 typedef enum /*< flags=0 >*/ |
|
187 { |
|
188 GST_STATE_CHANGE_NULL_TO_READY = (GST_STATE_NULL<<3) | GST_STATE_READY, |
|
189 GST_STATE_CHANGE_READY_TO_PAUSED = (GST_STATE_READY<<3) | GST_STATE_PAUSED, |
|
190 GST_STATE_CHANGE_PAUSED_TO_PLAYING = (GST_STATE_PAUSED<<3) | GST_STATE_PLAYING, |
|
191 GST_STATE_CHANGE_PLAYING_TO_PAUSED = (GST_STATE_PLAYING<<3) | GST_STATE_PAUSED, |
|
192 GST_STATE_CHANGE_PAUSED_TO_READY = (GST_STATE_PAUSED<<3) | GST_STATE_READY, |
|
193 GST_STATE_CHANGE_READY_TO_NULL = (GST_STATE_READY<<3) | GST_STATE_NULL |
|
194 } GstStateChange; |
|
195 |
|
196 /** |
|
197 * GstElementFlags: |
|
198 * @GST_ELEMENT_LOCKED_STATE: ignore state changes from parent |
|
199 * @GST_ELEMENT_IS_SINK: the element is a sink |
|
200 * @GST_ELEMENT_UNPARENTING: Child is being removed from the parent bin. |
|
201 * gst_bin_remove() on a child already being removed immediately returns FALSE |
|
202 * @GST_ELEMENT_FLAG_LAST: offset to define more flags |
|
203 * |
|
204 * The standard flags that an element may have. |
|
205 */ |
|
206 typedef enum |
|
207 { |
|
208 GST_ELEMENT_LOCKED_STATE = (GST_OBJECT_FLAG_LAST << 0), |
|
209 GST_ELEMENT_IS_SINK = (GST_OBJECT_FLAG_LAST << 1), |
|
210 GST_ELEMENT_UNPARENTING = (GST_OBJECT_FLAG_LAST << 2), |
|
211 /* padding */ |
|
212 GST_ELEMENT_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 16) |
|
213 } GstElementFlags; |
|
214 |
|
215 /** |
|
216 * GST_ELEMENT_IS_LOCKED_STATE: |
|
217 * @elem: A #GstElement to query |
|
218 * |
|
219 * Check if the element is in the locked state and therefore will ignore state |
|
220 * changes from its parent object. |
|
221 */ |
|
222 #define GST_ELEMENT_IS_LOCKED_STATE(elem) (GST_OBJECT_FLAG_IS_SET(elem,GST_ELEMENT_LOCKED_STATE)) |
|
223 |
|
224 /** |
|
225 * GST_ELEMENT_NAME: |
|
226 * @elem: A #GstElement to query |
|
227 * |
|
228 * Gets the name of this element. Use only in core as this is not |
|
229 * ABI-compatible. Others use gst_element_get_name() |
|
230 */ |
|
231 #define GST_ELEMENT_NAME(elem) (GST_OBJECT_NAME(elem)) |
|
232 |
|
233 /** |
|
234 * GST_ELEMENT_PARENT: |
|
235 * @elem: A #GstElement to query |
|
236 * |
|
237 * Get the parent object of this element. |
|
238 */ |
|
239 #define GST_ELEMENT_PARENT(elem) (GST_ELEMENT_CAST(GST_OBJECT_PARENT(elem))) |
|
240 |
|
241 /** |
|
242 * GST_ELEMENT_BUS: |
|
243 * @elem: A #GstElement to query |
|
244 * |
|
245 * Get the message bus of this element. |
|
246 */ |
|
247 #define GST_ELEMENT_BUS(elem) (GST_ELEMENT_CAST(elem)->bus) |
|
248 |
|
249 /** |
|
250 * GST_ELEMENT_CLOCK: |
|
251 * @elem: A #GstElement to query |
|
252 * |
|
253 * Get the clock of this element |
|
254 */ |
|
255 #define GST_ELEMENT_CLOCK(elem) (GST_ELEMENT_CAST(elem)->clock) |
|
256 |
|
257 /** |
|
258 * GST_ELEMENT_PADS: |
|
259 * @elem: A #GstElement to query |
|
260 * |
|
261 * Get the pads of this elements. |
|
262 */ |
|
263 #define GST_ELEMENT_PADS(elem) (GST_ELEMENT_CAST(elem)->pads) |
|
264 |
|
265 /** |
|
266 * GST_ELEMENT_ERROR: |
|
267 * @el: the element that generates the error |
|
268 * @domain: like CORE, LIBRARY, RESOURCE or STREAM (see #GstGError) |
|
269 * @code: error code defined for that domain (see #GstGError) |
|
270 * @text: the message to display (format string and args enclosed in |
|
271 parentheses) |
|
272 * @debug: debugging information for the message (format string and args |
|
273 enclosed in parentheses) |
|
274 * |
|
275 * Utility function that elements can use in case they encountered a fatal |
|
276 * data processing error. The pipeline will post an error message and the |
|
277 * application will be requested to stop further media processing. |
|
278 */ |
|
279 #define GST_ELEMENT_ERROR(el, domain, code, text, debug) \ |
|
280 G_STMT_START { \ |
|
281 gchar *__txt = _gst_element_error_printf text; \ |
|
282 gchar *__dbg = _gst_element_error_printf debug; \ |
|
283 if (__txt) \ |
|
284 GST_WARNING_OBJECT (el, "error: %s", __txt); \ |
|
285 if (__dbg) \ |
|
286 GST_WARNING_OBJECT (el, "error: %s", __dbg); \ |
|
287 gst_element_message_full (GST_ELEMENT(el), GST_MESSAGE_ERROR, \ |
|
288 GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code, \ |
|
289 __txt, __dbg, __FILE__, GST_FUNCTION, __LINE__); \ |
|
290 } G_STMT_END |
|
291 |
|
292 /** |
|
293 * GST_ELEMENT_WARNING: |
|
294 * @el: the element that generates the warning |
|
295 * @domain: like CORE, LIBRARY, RESOURCE or STREAM (see #gstreamer-GstGError) |
|
296 * @code: error code defined for that domain (see #gstreamer-GstGError) |
|
297 * @text: the message to display (format string and args enclosed in |
|
298 parentheses) |
|
299 * @debug: debugging information for the message (format string and args |
|
300 enclosed in parentheses) |
|
301 * |
|
302 * Utility function that elements can use in case they encountered a non-fatal |
|
303 * data processing problem. The pipeline will post a warning message and the |
|
304 * application will be informed. |
|
305 */ |
|
306 #define GST_ELEMENT_WARNING(el, domain, code, text, debug) \ |
|
307 G_STMT_START { \ |
|
308 gchar *__txt = _gst_element_error_printf text; \ |
|
309 gchar *__dbg = _gst_element_error_printf debug; \ |
|
310 if (__txt) \ |
|
311 GST_WARNING_OBJECT (el, "warning: %s", __txt); \ |
|
312 if (__dbg) \ |
|
313 GST_WARNING_OBJECT (el, "warning: %s", __dbg); \ |
|
314 gst_element_message_full (GST_ELEMENT(el), GST_MESSAGE_WARNING, \ |
|
315 GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code, \ |
|
316 __txt, __dbg, __FILE__, GST_FUNCTION, __LINE__); \ |
|
317 } G_STMT_END |
|
318 |
|
319 /** |
|
320 * GST_ELEMENT_INFO: |
|
321 * @el: the element that generates the information |
|
322 * @domain: like CORE, LIBRARY, RESOURCE or STREAM (see #gstreamer-GstGError) |
|
323 * @code: error code defined for that domain (see #gstreamer-GstGError) |
|
324 * @text: the message to display (format string and args enclosed in |
|
325 parentheses) |
|
326 * @debug: debugging information for the message (format string and args |
|
327 enclosed in parentheses) |
|
328 * |
|
329 * Utility function that elements can use in case they want to inform |
|
330 * the application of something noteworthy that is not an error. |
|
331 * The pipeline will post a warning message and the |
|
332 * application will be informed. |
|
333 * |
|
334 * Since: 0.10.12 |
|
335 */ |
|
336 #define GST_ELEMENT_INFO(el, domain, code, text, debug) \ |
|
337 G_STMT_START { \ |
|
338 gchar *__txt = _gst_element_error_printf text; \ |
|
339 gchar *__dbg = _gst_element_error_printf debug; \ |
|
340 if (__txt) \ |
|
341 GST_INFO_OBJECT (el, "info: %s", __txt); \ |
|
342 if (__dbg) \ |
|
343 GST_INFO_OBJECT (el, "info: %s", __dbg); \ |
|
344 gst_element_message_full (GST_ELEMENT(el), GST_MESSAGE_INFO, \ |
|
345 GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code, \ |
|
346 __txt, __dbg, __FILE__, GST_FUNCTION, __LINE__); \ |
|
347 } G_STMT_END |
|
348 |
|
349 /* the state change mutexes and conds */ |
|
350 /** |
|
351 * GST_STATE_GET_LOCK: |
|
352 * @elem: a #GstElement |
|
353 * |
|
354 * Get a reference to the state lock of @elem. |
|
355 * This lock is used by the core. It is taken while getting or setting |
|
356 * the state, during state changes, and while finalizing. |
|
357 */ |
|
358 #define GST_STATE_GET_LOCK(elem) (GST_ELEMENT_CAST(elem)->state_lock) |
|
359 /** |
|
360 * GST_STATE_GET_COND: |
|
361 * @elem: a #GstElement |
|
362 * |
|
363 * Get the conditional used to signal the completion of a state change. |
|
364 */ |
|
365 #define GST_STATE_GET_COND(elem) (GST_ELEMENT_CAST(elem)->state_cond) |
|
366 |
|
367 #define GST_STATE_LOCK(elem) g_static_rec_mutex_lock(GST_STATE_GET_LOCK(elem)) |
|
368 #define GST_STATE_TRYLOCK(elem) g_static_rec_mutex_trylock(GST_STATE_GET_LOCK(elem)) |
|
369 #define GST_STATE_UNLOCK(elem) g_static_rec_mutex_unlock(GST_STATE_GET_LOCK(elem)) |
|
370 #define GST_STATE_UNLOCK_FULL(elem) g_static_rec_mutex_unlock_full(GST_STATE_GET_LOCK(elem)) |
|
371 #define GST_STATE_LOCK_FULL(elem,t) g_static_rec_mutex_lock_full(GST_STATE_GET_LOCK(elem), t) |
|
372 #define GST_STATE_WAIT(elem) g_cond_wait (GST_STATE_GET_COND (elem), \ |
|
373 GST_OBJECT_GET_LOCK (elem)) |
|
374 #define GST_STATE_TIMED_WAIT(elem, timeval) g_cond_timed_wait (GST_STATE_GET_COND (elem), \ |
|
375 GST_OBJECT_GET_LOCK (elem), timeval) |
|
376 #define GST_STATE_SIGNAL(elem) g_cond_signal (GST_STATE_GET_COND (elem)); |
|
377 #define GST_STATE_BROADCAST(elem) g_cond_broadcast (GST_STATE_GET_COND (elem)); |
|
378 |
|
379 /** |
|
380 * GstElement: |
|
381 * @state_lock: Used to serialize execution of gst_element_set_state() |
|
382 * @state_cond: Used to signal completion of a state change |
|
383 * @state_cookie: Used to detect concurrent execution of |
|
384 * gst_element_set_state() and gst_element_get_state() |
|
385 * @current_state: the current state of an element |
|
386 * @next_state: the next state of an element, can be #GST_STATE_VOID_PENDING if |
|
387 * the element is in the correct state. |
|
388 * @pending_state: the final state the element should go to, can be |
|
389 * #GST_STATE_VOID_PENDING if the element is in the correct state |
|
390 * @last_return: the last return value of an element state change |
|
391 * @bus: the bus of the element. This bus is provided to the element by the |
|
392 * parent element or the application. A #GstPipeline has a bus of its own. |
|
393 * @clock: the clock of the element. This clock is usually provided by to the |
|
394 * element by the toplevel #GstPipeline. |
|
395 * @base_time: the time of the clock right before the element is set to |
|
396 * PLAYING. Subtracting @base_time from the current clock time in the PLAYING |
|
397 * state will yield the stream time. |
|
398 * @numpads: number of pads of the element, includes both source and sink pads. |
|
399 * @pads: list of pads |
|
400 * @numsrcpads: number of source pads of the element. |
|
401 * @srcpads: list of source pads |
|
402 * @numsinkpads: number of sink pads of the element. |
|
403 * @sinkpads: list of sink pads |
|
404 * @pads_cookie: updated whenever the a pad is added or removed |
|
405 * |
|
406 * GStreamer element abstract base class. |
|
407 */ |
|
408 struct _GstElement |
|
409 { |
|
410 GstObject object; |
|
411 |
|
412 /*< public >*/ /* with LOCK */ |
|
413 GStaticRecMutex *state_lock; |
|
414 |
|
415 /* element state */ |
|
416 GCond *state_cond; |
|
417 guint32 state_cookie; |
|
418 GstState current_state; |
|
419 GstState next_state; |
|
420 GstState pending_state; |
|
421 GstStateChangeReturn last_return; |
|
422 |
|
423 GstBus *bus; |
|
424 |
|
425 /* allocated clock */ |
|
426 GstClock *clock; |
|
427 GstClockTimeDiff base_time; /* NULL/READY: 0 - PAUSED: current time - PLAYING: difference to clock */ |
|
428 |
|
429 /* element pads, these lists can only be iterated while holding |
|
430 * the LOCK or checking the cookie after each LOCK. */ |
|
431 guint16 numpads; |
|
432 GList *pads; |
|
433 guint16 numsrcpads; |
|
434 GList *srcpads; |
|
435 guint16 numsinkpads; |
|
436 GList *sinkpads; |
|
437 guint32 pads_cookie; |
|
438 |
|
439 /*< private >*/ |
|
440 union { |
|
441 struct { |
|
442 /* state set by application */ |
|
443 GstState target_state; |
|
444 } ABI; |
|
445 /* adding + 0 to mark ABI change to be undone later */ |
|
446 gpointer _gst_reserved[GST_PADDING + 0]; |
|
447 } abidata; |
|
448 }; |
|
449 |
|
450 /** |
|
451 * GstElementClass: |
|
452 * @parent_class: the parent class structure |
|
453 * @details: #GstElementDetails for elements of this class |
|
454 * @elementfactory: the #GstElementFactory that creates these elements |
|
455 * @padtemplates: a #GList of #GstPadTemplate |
|
456 * @numpadtemplates: the number of padtemplates |
|
457 * @pad_templ_cookie: changed whenever the padtemplates change |
|
458 * @request_new_pad: called when a new pad is requested |
|
459 * @release_pad: called when a request pad is to be released |
|
460 * @get_state: get the state of the element |
|
461 * @set_state: set a new state on the element |
|
462 * @change_state: called by @set_state to perform an incremental state change |
|
463 * @set_bus: set a #GstBus on the element |
|
464 * @provide_clock: gets the #GstClock provided by the element |
|
465 * @set_clock: set the #GstClock on the element |
|
466 * @get_index: set a #GstIndex on the element |
|
467 * @set_index: get the #GstIndex of an element |
|
468 * @send_event: send a #GstEvent to the element |
|
469 * @get_query_types: get the supported #GstQueryType of this element |
|
470 * @query: perform a #GstQuery on the element |
|
471 * |
|
472 * GStreamer element class. Override the vmethods to implement the element |
|
473 * functionality. |
|
474 */ |
|
475 struct _GstElementClass |
|
476 { |
|
477 GstObjectClass parent_class; |
|
478 |
|
479 /*< public >*/ |
|
480 /* the element details */ |
|
481 GstElementDetails details; |
|
482 |
|
483 /* factory that the element was created from */ |
|
484 GstElementFactory *elementfactory; |
|
485 |
|
486 /* templates for our pads */ |
|
487 GList *padtemplates; |
|
488 gint numpadtemplates; |
|
489 guint32 pad_templ_cookie; |
|
490 |
|
491 /*< private >*/ |
|
492 /* signal callbacks */ |
|
493 void (*pad_added) (GstElement *element, GstPad *pad); |
|
494 void (*pad_removed) (GstElement *element, GstPad *pad); |
|
495 void (*no_more_pads) (GstElement *element); |
|
496 |
|
497 /*< public >*/ |
|
498 /* virtual methods for subclasses */ |
|
499 |
|
500 /* request/release pads */ |
|
501 GstPad* (*request_new_pad) (GstElement *element, GstPadTemplate *templ, const gchar* name); |
|
502 void (*release_pad) (GstElement *element, GstPad *pad); |
|
503 |
|
504 /* state changes */ |
|
505 GstStateChangeReturn (*get_state) (GstElement * element, GstState * state, |
|
506 GstState * pending, GstClockTime timeout); |
|
507 GstStateChangeReturn (*set_state) (GstElement *element, GstState state); |
|
508 GstStateChangeReturn (*change_state) (GstElement *element, GstStateChange transition); |
|
509 |
|
510 /* bus */ |
|
511 void (*set_bus) (GstElement * element, GstBus * bus); |
|
512 |
|
513 /* set/get clocks */ |
|
514 GstClock* (*provide_clock) (GstElement *element); |
|
515 gboolean (*set_clock) (GstElement *element, GstClock *clock); |
|
516 |
|
517 /* index */ |
|
518 GstIndex* (*get_index) (GstElement *element); |
|
519 void (*set_index) (GstElement *element, GstIndex *index); |
|
520 |
|
521 /* query functions */ |
|
522 gboolean (*send_event) (GstElement *element, GstEvent *event); |
|
523 |
|
524 const GstQueryType* (*get_query_types) (GstElement *element); |
|
525 gboolean (*query) (GstElement *element, GstQuery *query); |
|
526 |
|
527 /*< private >*/ |
|
528 gpointer _gst_reserved[GST_PADDING]; |
|
529 }; |
|
530 |
|
531 /* element class pad templates */ |
|
532 #ifdef __SYMBIAN32__ |
|
533 IMPORT_C |
|
534 #endif |
|
535 |
|
536 void gst_element_class_add_pad_template (GstElementClass *klass, GstPadTemplate *templ); |
|
537 #ifdef __SYMBIAN32__ |
|
538 IMPORT_C |
|
539 #endif |
|
540 |
|
541 GstPadTemplate* gst_element_class_get_pad_template (GstElementClass *element_class, const gchar *name); |
|
542 #ifdef __SYMBIAN32__ |
|
543 IMPORT_C |
|
544 #endif |
|
545 |
|
546 GList* gst_element_class_get_pad_template_list (GstElementClass *element_class); |
|
547 #ifdef __SYMBIAN32__ |
|
548 IMPORT_C |
|
549 #endif |
|
550 |
|
551 void gst_element_class_set_details (GstElementClass *klass, const GstElementDetails *details); |
|
552 #ifdef __SYMBIAN32__ |
|
553 IMPORT_C |
|
554 #endif |
|
555 |
|
556 void gst_element_class_set_details_simple (GstElementClass *klass, |
|
557 const gchar *longname, |
|
558 const gchar *classification, |
|
559 const gchar *description, |
|
560 const gchar *author); |
|
561 |
|
562 /* element instance */ |
|
563 #ifdef __SYMBIAN32__ |
|
564 IMPORT_C |
|
565 #endif |
|
566 |
|
567 GType gst_element_get_type (void); |
|
568 |
|
569 /* basic name and parentage stuff from GstObject */ |
|
570 |
|
571 /** |
|
572 * gst_element_get_name: |
|
573 * @elem: a #GstElement to set the name of. |
|
574 * |
|
575 * Gets the name of the element. |
|
576 */ |
|
577 #define gst_element_get_name(elem) gst_object_get_name(GST_OBJECT_CAST(elem)) |
|
578 |
|
579 /** |
|
580 * gst_element_set_name: |
|
581 * @elem: a #GstElement to set the name of. |
|
582 * @name: the new name |
|
583 * |
|
584 * Sets the name of the element, getting rid of the old name if there was one. |
|
585 */ |
|
586 #define gst_element_set_name(elem,name) gst_object_set_name(GST_OBJECT_CAST(elem),name) |
|
587 |
|
588 /** |
|
589 * gst_element_get_parent: |
|
590 * @elem: a #GstElement to get the parent of. |
|
591 * |
|
592 * Gets the parent of an element. |
|
593 */ |
|
594 #define gst_element_get_parent(elem) gst_object_get_parent(GST_OBJECT_CAST(elem)) |
|
595 |
|
596 /** |
|
597 * gst_element_set_parent: |
|
598 * @elem: a #GstElement to set the parent of. |
|
599 * @parent: the new parent #GstObject of the element. |
|
600 * |
|
601 * Sets the parent of an element. |
|
602 */ |
|
603 #define gst_element_set_parent(elem,parent) gst_object_set_parent(GST_OBJECT_CAST(elem),parent) |
|
604 |
|
605 /* clocking */ |
|
606 #ifdef __SYMBIAN32__ |
|
607 IMPORT_C |
|
608 #endif |
|
609 |
|
610 gboolean gst_element_requires_clock (GstElement *element); |
|
611 #ifdef __SYMBIAN32__ |
|
612 IMPORT_C |
|
613 #endif |
|
614 |
|
615 gboolean gst_element_provides_clock (GstElement *element); |
|
616 #ifdef __SYMBIAN32__ |
|
617 IMPORT_C |
|
618 #endif |
|
619 |
|
620 GstClock* gst_element_provide_clock (GstElement *element); |
|
621 #ifdef __SYMBIAN32__ |
|
622 IMPORT_C |
|
623 #endif |
|
624 |
|
625 GstClock* gst_element_get_clock (GstElement *element); |
|
626 #ifdef __SYMBIAN32__ |
|
627 IMPORT_C |
|
628 #endif |
|
629 |
|
630 gboolean gst_element_set_clock (GstElement *element, GstClock *clock); |
|
631 #ifdef __SYMBIAN32__ |
|
632 IMPORT_C |
|
633 #endif |
|
634 |
|
635 void gst_element_set_base_time (GstElement *element, GstClockTime time); |
|
636 #ifdef __SYMBIAN32__ |
|
637 IMPORT_C |
|
638 #endif |
|
639 |
|
640 GstClockTime gst_element_get_base_time (GstElement *element); |
|
641 |
|
642 /* indexes */ |
|
643 #ifdef __SYMBIAN32__ |
|
644 IMPORT_C |
|
645 #endif |
|
646 |
|
647 gboolean gst_element_is_indexable (GstElement *element); |
|
648 #ifdef __SYMBIAN32__ |
|
649 IMPORT_C |
|
650 #endif |
|
651 |
|
652 void gst_element_set_index (GstElement *element, GstIndex *index); |
|
653 #ifdef __SYMBIAN32__ |
|
654 IMPORT_C |
|
655 #endif |
|
656 |
|
657 GstIndex* gst_element_get_index (GstElement *element); |
|
658 |
|
659 /* bus */ |
|
660 #ifdef __SYMBIAN32__ |
|
661 IMPORT_C |
|
662 #endif |
|
663 |
|
664 void gst_element_set_bus (GstElement * element, GstBus * bus); |
|
665 #ifdef __SYMBIAN32__ |
|
666 IMPORT_C |
|
667 #endif |
|
668 |
|
669 GstBus * gst_element_get_bus (GstElement * element); |
|
670 |
|
671 /* pad management */ |
|
672 #ifdef __SYMBIAN32__ |
|
673 IMPORT_C |
|
674 #endif |
|
675 |
|
676 gboolean gst_element_add_pad (GstElement *element, GstPad *pad); |
|
677 #ifdef __SYMBIAN32__ |
|
678 IMPORT_C |
|
679 #endif |
|
680 |
|
681 gboolean gst_element_remove_pad (GstElement *element, GstPad *pad); |
|
682 #ifdef __SYMBIAN32__ |
|
683 IMPORT_C |
|
684 #endif |
|
685 |
|
686 void gst_element_no_more_pads (GstElement *element); |
|
687 #ifdef __SYMBIAN32__ |
|
688 IMPORT_C |
|
689 #endif |
|
690 |
|
691 |
|
692 GstPad* gst_element_get_pad (GstElement *element, const gchar *name); |
|
693 #ifdef __SYMBIAN32__ |
|
694 IMPORT_C |
|
695 #endif |
|
696 |
|
697 GstPad* gst_element_get_static_pad (GstElement *element, const gchar *name); |
|
698 #ifdef __SYMBIAN32__ |
|
699 IMPORT_C |
|
700 #endif |
|
701 |
|
702 GstPad* gst_element_get_request_pad (GstElement *element, const gchar *name); |
|
703 #ifdef __SYMBIAN32__ |
|
704 IMPORT_C |
|
705 #endif |
|
706 |
|
707 void gst_element_release_request_pad (GstElement *element, GstPad *pad); |
|
708 #ifdef __SYMBIAN32__ |
|
709 IMPORT_C |
|
710 #endif |
|
711 |
|
712 |
|
713 GstIterator * gst_element_iterate_pads (GstElement * element); |
|
714 #ifdef __SYMBIAN32__ |
|
715 IMPORT_C |
|
716 #endif |
|
717 |
|
718 GstIterator * gst_element_iterate_src_pads (GstElement * element); |
|
719 #ifdef __SYMBIAN32__ |
|
720 IMPORT_C |
|
721 #endif |
|
722 |
|
723 GstIterator * gst_element_iterate_sink_pads (GstElement * element); |
|
724 |
|
725 /* event/query/format stuff */ |
|
726 #ifdef __SYMBIAN32__ |
|
727 IMPORT_C |
|
728 #endif |
|
729 |
|
730 gboolean gst_element_send_event (GstElement *element, GstEvent *event); |
|
731 #ifdef __SYMBIAN32__ |
|
732 IMPORT_C |
|
733 #endif |
|
734 |
|
735 gboolean gst_element_seek (GstElement *element, gdouble rate, |
|
736 GstFormat format, GstSeekFlags flags, |
|
737 GstSeekType cur_type, gint64 cur, |
|
738 GstSeekType stop_type, gint64 stop); |
|
739 #ifdef __SYMBIAN32__ |
|
740 IMPORT_C |
|
741 #endif |
|
742 |
|
743 G_CONST_RETURN GstQueryType* |
|
744 gst_element_get_query_types (GstElement *element); |
|
745 #ifdef __SYMBIAN32__ |
|
746 IMPORT_C |
|
747 #endif |
|
748 |
|
749 gboolean gst_element_query (GstElement *element, GstQuery *query); |
|
750 |
|
751 /* messages */ |
|
752 #ifdef __SYMBIAN32__ |
|
753 IMPORT_C |
|
754 #endif |
|
755 |
|
756 gboolean gst_element_post_message (GstElement * element, GstMessage * message); |
|
757 |
|
758 /* error handling */ |
|
759 /* gcc versions < 3.3 warn about NULL being passed as format to printf */ |
|
760 #if (defined(GST_USING_PRINTF_EXTENSION) || !defined(__GNUC__) || (__GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 3)) |
|
761 gchar * _gst_element_error_printf (const gchar *format, ...); |
|
762 #else |
|
763 gchar * _gst_element_error_printf (const gchar *format, ...) G_GNUC_PRINTF (1, 2); |
|
764 #endif |
|
765 void gst_element_message_full (GstElement * element, GstMessageType type, |
|
766 GQuark domain, gint code, gchar * text, |
|
767 gchar * debug, const gchar * file, |
|
768 const gchar * function, gint line); |
|
769 |
|
770 /* state management */ |
|
771 #ifdef __SYMBIAN32__ |
|
772 IMPORT_C |
|
773 #endif |
|
774 |
|
775 gboolean gst_element_is_locked_state (GstElement *element); |
|
776 #ifdef __SYMBIAN32__ |
|
777 IMPORT_C |
|
778 #endif |
|
779 |
|
780 gboolean gst_element_set_locked_state (GstElement *element, gboolean locked_state); |
|
781 #ifdef __SYMBIAN32__ |
|
782 IMPORT_C |
|
783 #endif |
|
784 |
|
785 gboolean gst_element_sync_state_with_parent (GstElement *element); |
|
786 #ifdef __SYMBIAN32__ |
|
787 IMPORT_C |
|
788 #endif |
|
789 |
|
790 |
|
791 GstStateChangeReturn gst_element_get_state (GstElement * element, |
|
792 GstState * state, |
|
793 GstState * pending, |
|
794 GstClockTime timeout); |
|
795 #ifdef __SYMBIAN32__ |
|
796 IMPORT_C |
|
797 #endif |
|
798 |
|
799 GstStateChangeReturn gst_element_set_state (GstElement *element, GstState state); |
|
800 #ifdef __SYMBIAN32__ |
|
801 IMPORT_C |
|
802 #endif |
|
803 |
|
804 |
|
805 void gst_element_abort_state (GstElement * element); |
|
806 #ifdef __SYMBIAN32__ |
|
807 IMPORT_C |
|
808 #endif |
|
809 |
|
810 GstStateChangeReturn gst_element_change_state (GstElement * element, |
|
811 GstStateChange transition); |
|
812 #ifdef __SYMBIAN32__ |
|
813 IMPORT_C |
|
814 #endif |
|
815 |
|
816 GstStateChangeReturn gst_element_continue_state (GstElement * element, |
|
817 GstStateChangeReturn ret); |
|
818 #ifdef __SYMBIAN32__ |
|
819 IMPORT_C |
|
820 #endif |
|
821 |
|
822 void gst_element_lost_state (GstElement * element); |
|
823 |
|
824 /* factory management */ |
|
825 #ifdef __SYMBIAN32__ |
|
826 IMPORT_C |
|
827 #endif |
|
828 |
|
829 GstElementFactory* gst_element_get_factory (GstElement *element); |
|
830 |
|
831 G_END_DECLS |
|
832 |
|
833 #endif /* __GST_ELEMENT_H__ */ |