|
1 /* GStreamer |
|
2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu> |
|
3 * 2000 Wim Taymans <wim.taymans@chello.be> |
|
4 * 2005 Wim Taymans <wim@fluendo.com> |
|
5 * |
|
6 * gstevent.h: Header for GstEvent subsystem |
|
7 * |
|
8 * This library is free software; you can redistribute it and/or |
|
9 * modify it under the terms of the GNU Library General Public |
|
10 * License as published by the Free Software Foundation; either |
|
11 * version 2 of the License, or (at your option) any later version. |
|
12 * |
|
13 * This library is distributed in the hope that it will be useful, |
|
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
16 * Library General Public License for more details. |
|
17 * |
|
18 * You should have received a copy of the GNU Library General Public |
|
19 * License along with this library; if not, write to the |
|
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
|
21 * Boston, MA 02111-1307, USA. |
|
22 */ |
|
23 |
|
24 |
|
25 #ifndef __GST_EVENT_H__ |
|
26 #define __GST_EVENT_H__ |
|
27 |
|
28 #include <gst/gstminiobject.h> |
|
29 #include <gst/gstformat.h> |
|
30 #include <gst/gstobject.h> |
|
31 #include <gst/gstclock.h> |
|
32 #include <gst/gststructure.h> |
|
33 #include <gst/gsttaglist.h> |
|
34 |
|
35 G_BEGIN_DECLS |
|
36 |
|
37 /** |
|
38 * GstEventTypeFlags: |
|
39 * @GST_EVENT_TYPE_UPSTREAM: Set if the event can travel upstream. |
|
40 * @GST_EVENT_TYPE_DOWNSTREAM: Set if the event can travel downstream. |
|
41 * @GST_EVENT_TYPE_SERIALIZED: Set if the event should be serialized with data |
|
42 * flow. |
|
43 * |
|
44 * #GstEventTypeFlags indicate the aspects of the different #GstEventType |
|
45 * values. You can get the type flags of a #GstEventType with the |
|
46 * gst_event_type_get_flags() function. |
|
47 */ |
|
48 typedef enum { |
|
49 GST_EVENT_TYPE_UPSTREAM = 1 << 0, |
|
50 GST_EVENT_TYPE_DOWNSTREAM = 1 << 1, |
|
51 GST_EVENT_TYPE_SERIALIZED = 1 << 2 |
|
52 } GstEventTypeFlags; |
|
53 |
|
54 /** |
|
55 * GST_EVENT_TYPE_BOTH: |
|
56 * |
|
57 * The same thing as #GST_EVENT_TYPE_UPSTREAM | #GST_EVENT_TYPE_DOWNSTREAM. |
|
58 */ |
|
59 #define GST_EVENT_TYPE_BOTH \ |
|
60 (GST_EVENT_TYPE_UPSTREAM | GST_EVENT_TYPE_DOWNSTREAM) |
|
61 |
|
62 #define GST_EVENT_TYPE_SHIFT 4 |
|
63 |
|
64 /** |
|
65 * GST_EVENT_MAKE_TYPE: |
|
66 * @num: the event number to create |
|
67 * @flags: the event flags |
|
68 * |
|
69 * when making custom event types, use this macro with the num and |
|
70 * the given flags |
|
71 */ |
|
72 #define GST_EVENT_MAKE_TYPE(num,flags) \ |
|
73 (((num) << GST_EVENT_TYPE_SHIFT) | (flags)) |
|
74 |
|
75 #define FLAG(name) GST_EVENT_TYPE_##name |
|
76 |
|
77 /** |
|
78 * GstEventType: |
|
79 * @GST_EVENT_UNKNOWN: unknown event. |
|
80 * @GST_EVENT_FLUSH_START: Start a flush operation |
|
81 * @GST_EVENT_FLUSH_STOP: Stop a flush operation |
|
82 * @GST_EVENT_EOS: End-Of-Stream. No more data is to be expected to follow |
|
83 * without a NEWSEGMENT event. |
|
84 * @GST_EVENT_NEWSEGMENT: A new media segment follows in the dataflow. |
|
85 * @GST_EVENT_TAG: A new set of metadata tags has been found in the stream. |
|
86 * @GST_EVENT_BUFFERSIZE: Notification of buffering requirements |
|
87 * @GST_EVENT_QOS: A quality message. Used to indicate to upstream elements |
|
88 * that the downstream elements are being starved of or |
|
89 * flooded with data. |
|
90 * @GST_EVENT_SEEK: A request for a new playback position and rate. |
|
91 * @GST_EVENT_NAVIGATION: Navigation events are usually used for communicating |
|
92 * user requests, such as mouse or keyboard movements, |
|
93 * to upstream elements. |
|
94 * @GST_EVENT_LATENCY: Notification of new latency adjustment. Since: 0.10.12 |
|
95 * @GST_EVENT_CUSTOM_UPSTREAM: Upstream custom event |
|
96 * @GST_EVENT_CUSTOM_DOWNSTREAM: Downstream custom event that travels in the |
|
97 * data flow. |
|
98 * @GST_EVENT_CUSTOM_DOWNSTREAM_OOB: Custom out-of-band downstream event. |
|
99 * @GST_EVENT_CUSTOM_BOTH: Custom upstream or downstream event. |
|
100 * In-band when travelling downstream. |
|
101 * @GST_EVENT_CUSTOM_BOTH_OOB: Custom upstream or downstream out-of-band event. |
|
102 * |
|
103 * #GstEventType lists the standard event types that can be sent in a pipeline. |
|
104 * |
|
105 * The custom event types can be used for private messages between elements |
|
106 * that can't be expressed using normal |
|
107 * GStreamer buffer passing semantics. Custom events carry an arbitrary |
|
108 * #GstStructure. |
|
109 * Specific custom events are distinguished by the name of the structure. |
|
110 */ |
|
111 /* NOTE: keep in sync with quark registration in gstevent.c */ |
|
112 typedef enum { |
|
113 GST_EVENT_UNKNOWN = GST_EVENT_MAKE_TYPE (0, 0), |
|
114 /* bidirectional events */ |
|
115 GST_EVENT_FLUSH_START = GST_EVENT_MAKE_TYPE (1, FLAG(BOTH)), |
|
116 GST_EVENT_FLUSH_STOP = GST_EVENT_MAKE_TYPE (2, FLAG(BOTH) | FLAG(SERIALIZED)), |
|
117 /* downstream serialized events */ |
|
118 GST_EVENT_EOS = GST_EVENT_MAKE_TYPE (5, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), |
|
119 GST_EVENT_NEWSEGMENT = GST_EVENT_MAKE_TYPE (6, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), |
|
120 GST_EVENT_TAG = GST_EVENT_MAKE_TYPE (7, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), |
|
121 GST_EVENT_BUFFERSIZE = GST_EVENT_MAKE_TYPE (8, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), |
|
122 /* upstream events */ |
|
123 GST_EVENT_QOS = GST_EVENT_MAKE_TYPE (15, FLAG(UPSTREAM)), |
|
124 GST_EVENT_SEEK = GST_EVENT_MAKE_TYPE (16, FLAG(UPSTREAM)), |
|
125 GST_EVENT_NAVIGATION = GST_EVENT_MAKE_TYPE (17, FLAG(UPSTREAM)), |
|
126 GST_EVENT_LATENCY = GST_EVENT_MAKE_TYPE (18, FLAG(UPSTREAM)), |
|
127 |
|
128 /* custom events start here */ |
|
129 GST_EVENT_CUSTOM_UPSTREAM = GST_EVENT_MAKE_TYPE (32, FLAG(UPSTREAM)), |
|
130 GST_EVENT_CUSTOM_DOWNSTREAM = GST_EVENT_MAKE_TYPE (32, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), |
|
131 GST_EVENT_CUSTOM_DOWNSTREAM_OOB = GST_EVENT_MAKE_TYPE (32, FLAG(DOWNSTREAM)), |
|
132 GST_EVENT_CUSTOM_BOTH = GST_EVENT_MAKE_TYPE (32, FLAG(BOTH) | FLAG(SERIALIZED)), |
|
133 GST_EVENT_CUSTOM_BOTH_OOB = GST_EVENT_MAKE_TYPE (32, FLAG(BOTH)) |
|
134 } GstEventType; |
|
135 #undef FLAG |
|
136 |
|
137 /** |
|
138 * GST_EVENT_TRACE_NAME: |
|
139 * |
|
140 * The name used for memory allocation tracing |
|
141 */ |
|
142 #define GST_EVENT_TRACE_NAME "GstEvent" |
|
143 |
|
144 typedef struct _GstEvent GstEvent; |
|
145 typedef struct _GstEventClass GstEventClass; |
|
146 |
|
147 #define GST_TYPE_EVENT (gst_event_get_type()) |
|
148 #define GST_IS_EVENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_EVENT)) |
|
149 #define GST_IS_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_EVENT)) |
|
150 #define GST_EVENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_EVENT, GstEventClass)) |
|
151 #define GST_EVENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_EVENT, GstEvent)) |
|
152 #define GST_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_EVENT, GstEventClass)) |
|
153 #define GST_EVENT_CAST(obj) ((GstEvent *)(obj)) |
|
154 |
|
155 /** |
|
156 * GST_EVENT_TYPE: |
|
157 * @event: the event to query |
|
158 * |
|
159 * Get the #GstEventType of the event. |
|
160 */ |
|
161 #define GST_EVENT_TYPE(event) (GST_EVENT_CAST(event)->type) |
|
162 |
|
163 /** |
|
164 * GST_EVENT_TYPE_NAME: |
|
165 * @event: the event to query |
|
166 * |
|
167 * Get a constant string representation of the #GstEventType of the event. |
|
168 */ |
|
169 #define GST_EVENT_TYPE_NAME(event) (gst_event_type_get_name(GST_EVENT_TYPE(event))) |
|
170 |
|
171 /** |
|
172 * GST_EVENT_TIMESTAMP: |
|
173 * @event: the event to query |
|
174 * |
|
175 * Get the #GstClockTime timestamp of the event. This is the time when the event |
|
176 * was created. |
|
177 */ |
|
178 #define GST_EVENT_TIMESTAMP(event) (GST_EVENT_CAST(event)->timestamp) |
|
179 |
|
180 /** |
|
181 * GST_EVENT_SRC: |
|
182 * @event: the event to query |
|
183 * |
|
184 * The source #GstObject that generated this event. |
|
185 */ |
|
186 #define GST_EVENT_SRC(event) (GST_EVENT_CAST(event)->src) |
|
187 |
|
188 /** |
|
189 * GST_EVENT_IS_UPSTREAM: |
|
190 * @ev: the event to query |
|
191 * |
|
192 * Check if an event can travel upstream. |
|
193 */ |
|
194 #define GST_EVENT_IS_UPSTREAM(ev) !!(GST_EVENT_TYPE (ev) & GST_EVENT_TYPE_UPSTREAM) |
|
195 /** |
|
196 * GST_EVENT_IS_DOWNSTREAM: |
|
197 * @ev: the event to query |
|
198 * |
|
199 * Check if an event can travel downstream. |
|
200 */ |
|
201 #define GST_EVENT_IS_DOWNSTREAM(ev) !!(GST_EVENT_TYPE (ev) & GST_EVENT_TYPE_DOWNSTREAM) |
|
202 /** |
|
203 * GST_EVENT_IS_SERIALIZED: |
|
204 * @ev: the event to query |
|
205 * |
|
206 * Check if an event is serialized with the data stream. |
|
207 */ |
|
208 #define GST_EVENT_IS_SERIALIZED(ev) !!(GST_EVENT_TYPE (ev) & GST_EVENT_TYPE_SERIALIZED) |
|
209 |
|
210 /** |
|
211 * gst_event_replace: |
|
212 * @old_event: pointer to a pointer to a #GstEvent to be replaced. |
|
213 * @new_event: pointer to a #GstEvent that will replace the event pointed to |
|
214 * by @old_event. |
|
215 * |
|
216 * Modifies a pointer to a #GstEvent to point to a different #GstEvent. The |
|
217 * modification is done atomically (so this is useful for ensuring thread safety |
|
218 * in some cases), and the reference counts are updated appropriately (the old |
|
219 * event is unreffed, the new one is reffed). |
|
220 * |
|
221 * Either @new_event or the #GstEvent pointed to by @old_event may be NULL. |
|
222 * |
|
223 * Since: 0.10.3 |
|
224 */ |
|
225 #define gst_event_replace(old_event,new_event) \ |
|
226 gst_mini_object_replace ((GstMiniObject **)(old_event), GST_MINI_OBJECT (new_event)) |
|
227 |
|
228 /** |
|
229 * GstSeekType: |
|
230 * @GST_SEEK_TYPE_NONE: no change in position is required |
|
231 * @GST_SEEK_TYPE_CUR: change relative to current position |
|
232 * @GST_SEEK_TYPE_SET: absolute position is requested |
|
233 * @GST_SEEK_TYPE_END: relative position to duration is requested |
|
234 * |
|
235 * The different types of seek events. When constructing a seek event with |
|
236 * gst_event_new_seek(), a format, a seek method and optional flags are to |
|
237 * be provided. The seek event is then inserted into the graph with |
|
238 * gst_pad_send_event() or gst_element_send_event(). |
|
239 */ |
|
240 typedef enum { |
|
241 /* one of these */ |
|
242 GST_SEEK_TYPE_NONE = 0, |
|
243 GST_SEEK_TYPE_CUR = 1, |
|
244 GST_SEEK_TYPE_SET = 2, |
|
245 GST_SEEK_TYPE_END = 3 |
|
246 } GstSeekType; |
|
247 |
|
248 /** |
|
249 * GstSeekFlags: |
|
250 * @GST_SEEK_FLAG_NONE: no flag |
|
251 * @GST_SEEK_FLAG_FLUSH: flush pipeline |
|
252 * @GST_SEEK_FLAG_ACCURATE: accurate position is requested, this might |
|
253 * be considerably slower for some formats. |
|
254 * @GST_SEEK_FLAG_KEY_UNIT: seek to the nearest keyframe. This might be |
|
255 * faster but less accurate. |
|
256 * @GST_SEEK_FLAG_SEGMENT: perform a segment seek. |
|
257 * |
|
258 * Flags to be used with gst_element_seek() or gst_event_new_seek(). All flags |
|
259 * can be used together. |
|
260 * |
|
261 * A non flushing seek might take some time to perform as the currently |
|
262 * playing data in the pipeline will not be cleared. |
|
263 * |
|
264 * An accurate seek might be slower for formats that don't have any indexes |
|
265 * or timestamp markers in the stream. Specifying this flag might require a |
|
266 * complete scan of the file in those cases. |
|
267 * |
|
268 * When performing a segment seek: after the playback of the segment completes, |
|
269 * no EOS will be emmited by the element that performed the seek, but a |
|
270 * #GST_MESSAGE_SEGMENT_DONE message will be posted on the bus by the element. |
|
271 * When this message is posted, it is possible to send a new seek event to |
|
272 * continue playback. With this seek method it is possible to perform seemless |
|
273 * looping or simple linear editing. |
|
274 */ |
|
275 typedef enum { |
|
276 GST_SEEK_FLAG_NONE = 0, |
|
277 GST_SEEK_FLAG_FLUSH = (1 << 0), |
|
278 GST_SEEK_FLAG_ACCURATE = (1 << 1), |
|
279 GST_SEEK_FLAG_KEY_UNIT = (1 << 2), |
|
280 GST_SEEK_FLAG_SEGMENT = (1 << 3) |
|
281 } GstSeekFlags; |
|
282 |
|
283 |
|
284 /** |
|
285 * GstEvent: |
|
286 * @mini_object: the parent structure |
|
287 * @type: the #GstEventType of the event |
|
288 * @timestamp: the timestamp of the event |
|
289 * @src: the src of the event |
|
290 * @structure: the #GstStructure containing the event info. |
|
291 * |
|
292 * A #GstEvent. |
|
293 */ |
|
294 struct _GstEvent { |
|
295 GstMiniObject mini_object; |
|
296 |
|
297 /*< public >*/ /* with COW */ |
|
298 GstEventType type; |
|
299 guint64 timestamp; |
|
300 GstObject *src; |
|
301 |
|
302 GstStructure *structure; |
|
303 |
|
304 /*< private >*/ |
|
305 gpointer _gst_reserved; |
|
306 }; |
|
307 |
|
308 struct _GstEventClass { |
|
309 GstMiniObjectClass mini_object_class; |
|
310 |
|
311 /*< private >*/ |
|
312 gpointer _gst_reserved[GST_PADDING]; |
|
313 }; |
|
314 #ifdef __SYMBIAN32__ |
|
315 IMPORT_C |
|
316 #endif |
|
317 |
|
318 |
|
319 const gchar* gst_event_type_get_name (GstEventType type); |
|
320 #ifdef __SYMBIAN32__ |
|
321 IMPORT_C |
|
322 #endif |
|
323 |
|
324 GQuark gst_event_type_to_quark (GstEventType type); |
|
325 #ifdef __SYMBIAN32__ |
|
326 IMPORT_C |
|
327 #endif |
|
328 |
|
329 GstEventTypeFlags |
|
330 gst_event_type_get_flags (GstEventType type); |
|
331 #ifdef __SYMBIAN32__ |
|
332 IMPORT_C |
|
333 #endif |
|
334 |
|
335 |
|
336 |
|
337 GType gst_event_get_type (void); |
|
338 |
|
339 /* refcounting */ |
|
340 /** |
|
341 * gst_event_ref: |
|
342 * @event: The event to refcount |
|
343 * |
|
344 * Increase the refcount of this event. |
|
345 * |
|
346 * Returns: @event (for convenience when doing assignments) |
|
347 */ |
|
348 #ifdef _FOOL_GTK_DOC_ |
|
349 G_INLINE_FUNC GstEvent * gst_event_ref (GstEvent * event); |
|
350 #endif |
|
351 |
|
352 static inline GstEvent * |
|
353 gst_event_ref (GstEvent * ev) |
|
354 { |
|
355 /* not using a macro here because gcc-4.1 will complain |
|
356 * if the return value isn't used (because of the cast) */ |
|
357 return (GstEvent *) gst_mini_object_ref (GST_MINI_OBJECT (ev)); |
|
358 } |
|
359 |
|
360 /** |
|
361 * gst_event_unref: |
|
362 * @ev: The event to refcount |
|
363 * |
|
364 * Decrease the refcount of an event, freeing it if the refcount reaches 0. |
|
365 */ |
|
366 #define gst_event_unref(ev) gst_mini_object_unref (GST_MINI_OBJECT (ev)) |
|
367 |
|
368 /* copy event */ |
|
369 /** |
|
370 * gst_event_copy: |
|
371 * @ev: The event to copy |
|
372 * |
|
373 * Copy the event using the event specific copy function. |
|
374 */ |
|
375 #define gst_event_copy(ev) GST_EVENT_CAST (gst_mini_object_copy (GST_MINI_OBJECT (ev))) |
|
376 |
|
377 /* custom event */ |
|
378 #ifdef __SYMBIAN32__ |
|
379 IMPORT_C |
|
380 #endif |
|
381 |
|
382 GstEvent* gst_event_new_custom (GstEventType type, GstStructure *structure); |
|
383 #ifdef __SYMBIAN32__ |
|
384 IMPORT_C |
|
385 #endif |
|
386 |
|
387 |
|
388 const GstStructure * |
|
389 gst_event_get_structure (GstEvent *event); |
|
390 |
|
391 /* flush events */ |
|
392 #ifdef __SYMBIAN32__ |
|
393 IMPORT_C |
|
394 #endif |
|
395 |
|
396 GstEvent * gst_event_new_flush_start (void); |
|
397 #ifdef __SYMBIAN32__ |
|
398 IMPORT_C |
|
399 #endif |
|
400 |
|
401 GstEvent * gst_event_new_flush_stop (void); |
|
402 |
|
403 /* EOS event */ |
|
404 #ifdef __SYMBIAN32__ |
|
405 IMPORT_C |
|
406 #endif |
|
407 |
|
408 GstEvent * gst_event_new_eos (void); |
|
409 |
|
410 /* newsegment events */ |
|
411 #ifdef __SYMBIAN32__ |
|
412 IMPORT_C |
|
413 #endif |
|
414 |
|
415 GstEvent* gst_event_new_new_segment (gboolean update, gdouble rate, |
|
416 GstFormat format, |
|
417 gint64 start, gint64 stop, |
|
418 gint64 position); |
|
419 #ifdef __SYMBIAN32__ |
|
420 IMPORT_C |
|
421 #endif |
|
422 |
|
423 GstEvent* gst_event_new_new_segment_full (gboolean update, gdouble rate, |
|
424 gdouble applied_rate, |
|
425 GstFormat format, |
|
426 gint64 start, gint64 stop, |
|
427 gint64 position); |
|
428 #ifdef __SYMBIAN32__ |
|
429 IMPORT_C |
|
430 #endif |
|
431 |
|
432 void gst_event_parse_new_segment (GstEvent *event, |
|
433 gboolean *update, |
|
434 gdouble *rate, |
|
435 GstFormat *format, |
|
436 gint64 *start, gint64 *stop, |
|
437 gint64 *position); |
|
438 #ifdef __SYMBIAN32__ |
|
439 IMPORT_C |
|
440 #endif |
|
441 |
|
442 void gst_event_parse_new_segment_full (GstEvent *event, |
|
443 gboolean *update, |
|
444 gdouble *rate, |
|
445 gdouble *applied_rate, |
|
446 GstFormat *format, |
|
447 gint64 *start, gint64 *stop, |
|
448 gint64 *position); |
|
449 |
|
450 /* tag event */ |
|
451 #ifdef __SYMBIAN32__ |
|
452 IMPORT_C |
|
453 #endif |
|
454 |
|
455 GstEvent* gst_event_new_tag (GstTagList *taglist); |
|
456 #ifdef __SYMBIAN32__ |
|
457 IMPORT_C |
|
458 #endif |
|
459 |
|
460 void gst_event_parse_tag (GstEvent *event, GstTagList **taglist); |
|
461 |
|
462 /* buffer */ |
|
463 #ifdef __SYMBIAN32__ |
|
464 IMPORT_C |
|
465 #endif |
|
466 |
|
467 GstEvent * gst_event_new_buffer_size (GstFormat format, gint64 minsize, gint64 maxsize, |
|
468 gboolean async); |
|
469 #ifdef __SYMBIAN32__ |
|
470 IMPORT_C |
|
471 #endif |
|
472 |
|
473 void gst_event_parse_buffer_size (GstEvent *event, GstFormat *format, gint64 *minsize, |
|
474 gint64 *maxsize, gboolean *async); |
|
475 |
|
476 /* QOS events */ |
|
477 #ifdef __SYMBIAN32__ |
|
478 IMPORT_C |
|
479 #endif |
|
480 |
|
481 GstEvent* gst_event_new_qos (gdouble proportion, GstClockTimeDiff diff, |
|
482 GstClockTime timestamp); |
|
483 #ifdef __SYMBIAN32__ |
|
484 IMPORT_C |
|
485 #endif |
|
486 |
|
487 void gst_event_parse_qos (GstEvent *event, gdouble *proportion, GstClockTimeDiff *diff, |
|
488 GstClockTime *timestamp); |
|
489 /* seek event */ |
|
490 #ifdef __SYMBIAN32__ |
|
491 IMPORT_C |
|
492 #endif |
|
493 |
|
494 GstEvent* gst_event_new_seek (gdouble rate, GstFormat format, GstSeekFlags flags, |
|
495 GstSeekType start_type, gint64 start, |
|
496 GstSeekType stop_type, gint64 stop); |
|
497 #ifdef __SYMBIAN32__ |
|
498 IMPORT_C |
|
499 #endif |
|
500 |
|
501 void gst_event_parse_seek (GstEvent *event, gdouble *rate, GstFormat *format, |
|
502 GstSeekFlags *flags, |
|
503 GstSeekType *start_type, gint64 *start, |
|
504 GstSeekType *stop_type, gint64 *stop); |
|
505 /* navigation event */ |
|
506 #ifdef __SYMBIAN32__ |
|
507 IMPORT_C |
|
508 #endif |
|
509 |
|
510 GstEvent* gst_event_new_navigation (GstStructure *structure); |
|
511 |
|
512 /* latency event */ |
|
513 #ifdef __SYMBIAN32__ |
|
514 IMPORT_C |
|
515 #endif |
|
516 |
|
517 GstEvent* gst_event_new_latency (GstClockTime latency); |
|
518 #ifdef __SYMBIAN32__ |
|
519 IMPORT_C |
|
520 #endif |
|
521 |
|
522 void gst_event_parse_latency (GstEvent *event, GstClockTime *latency); |
|
523 |
|
524 G_END_DECLS |
|
525 |
|
526 #endif /* __GST_EVENT_H__ */ |