|
1 /* GStreamer |
|
2 * Copyright (C) <2003> David A. Schleef <ds@schleef.org> |
|
3 * |
|
4 * This library is free software; you can redistribute it and/or |
|
5 * modify it under the terms of the GNU Library General Public |
|
6 * License as published by the Free Software Foundation; either |
|
7 * version 2 of the License, or (at your option) any later version. |
|
8 * |
|
9 * This library is distributed in the hope that it will be useful, |
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
12 * Library General Public License for more details. |
|
13 * |
|
14 * You should have received a copy of the GNU Library General Public |
|
15 * License along with this library; if not, write to the |
|
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
|
17 * Boston, MA 02111-1307, USA. |
|
18 */ |
|
19 |
|
20 #ifndef __GST_VALUE_H__ |
|
21 #define __GST_VALUE_H__ |
|
22 |
|
23 #include <gst/gstconfig.h> |
|
24 #include <gst/gstcaps.h> |
|
25 #include <gst/gststructure.h> |
|
26 |
|
27 G_BEGIN_DECLS |
|
28 |
|
29 /** |
|
30 * GST_MAKE_FOURCC: |
|
31 * @a: the first character |
|
32 * @b: the second character |
|
33 * @c: the third character |
|
34 * @d: the fourth character |
|
35 * |
|
36 * Transform four characters into a #guint32 fourcc value with host |
|
37 * endianness. |
|
38 * <informalexample> |
|
39 * <programlisting> |
|
40 * guint32 fourcc = GST_MAKE_FOURCC ('M', 'J', 'P', 'G'); |
|
41 * </programlisting> |
|
42 * </informalexample> |
|
43 */ |
|
44 #define GST_MAKE_FOURCC(a,b,c,d) (guint32)((a)|(b)<<8|(c)<<16|(d)<<24) |
|
45 |
|
46 /** |
|
47 * GST_STR_FOURCC: |
|
48 * @f: a string with at least four characters |
|
49 * |
|
50 * Transform an input string into a #guint32 fourcc value with host |
|
51 * endianness. |
|
52 * Caller is responsible for ensuring the input string consists of at least |
|
53 * four characters. |
|
54 * <informalexample> |
|
55 * <programlisting> |
|
56 * guint32 fourcc = GST_STR_FOURCC ("MJPG"); |
|
57 * </programlisting> |
|
58 * </informalexample> |
|
59 */ |
|
60 #define GST_STR_FOURCC(f) (guint32)(((f)[0])|((f)[1]<<8)|((f)[2]<<16)|((f)[3]<<24)) |
|
61 |
|
62 /** |
|
63 * GST_FOURCC_FORMAT: |
|
64 * |
|
65 * Can be used together with #GST_FOURCC_ARGS to properly output a |
|
66 * #guint32 fourcc value in a printf()-style text message. |
|
67 * <informalexample> |
|
68 * <programlisting> |
|
69 * printf ("fourcc: %" GST_FOURCC_FORMAT "\n", GST_FOURCC_ARGS (fcc)); |
|
70 * </programlisting> |
|
71 * </informalexample> |
|
72 */ |
|
73 #define GST_FOURCC_FORMAT "c%c%c%c" |
|
74 |
|
75 /** |
|
76 * GST_FOURCC_ARGS: |
|
77 * @fourcc: a #guint32 fourcc value to output |
|
78 * |
|
79 * Can be used together with #GST_FOURCC_FORMAT to properly output a |
|
80 * #guint32 fourcc value in a printf()-style text message. |
|
81 */ |
|
82 #define GST_FOURCC_ARGS(fourcc) \ |
|
83 ((gchar) ((fourcc) &0xff)), \ |
|
84 ((gchar) (((fourcc)>>8 )&0xff)), \ |
|
85 ((gchar) (((fourcc)>>16)&0xff)), \ |
|
86 ((gchar) (((fourcc)>>24)&0xff)) |
|
87 |
|
88 /** |
|
89 * GST_VALUE_HOLDS_FOURCC: |
|
90 * @x: the #GValue to check |
|
91 * |
|
92 * Checks if the given #GValue contains a #GST_TYPE_FOURCC value. |
|
93 */ |
|
94 #define GST_VALUE_HOLDS_FOURCC(x) (G_VALUE_HOLDS(x, gst_fourcc_get_type ())) |
|
95 |
|
96 /** |
|
97 * GST_VALUE_HOLDS_INT_RANGE: |
|
98 * @x: the #GValue to check |
|
99 * |
|
100 * Checks if the given #GValue contains a #GST_TYPE_INT_RANGE value. |
|
101 */ |
|
102 #define GST_VALUE_HOLDS_INT_RANGE(x) (G_VALUE_HOLDS(x, gst_int_range_get_type ())) |
|
103 |
|
104 /** |
|
105 * GST_VALUE_HOLDS_DOUBLE_RANGE: |
|
106 * @x: the #GValue to check |
|
107 * |
|
108 * Checks if the given #GValue contains a #GST_TYPE_DOUBLE_RANGE value. |
|
109 */ |
|
110 #define GST_VALUE_HOLDS_DOUBLE_RANGE(x) (G_VALUE_HOLDS(x, gst_double_range_get_type ())) |
|
111 |
|
112 /** |
|
113 * GST_VALUE_HOLDS_FRACTION_RANGE: |
|
114 * @x: the #GValue to check |
|
115 * |
|
116 * Checks if the given #GValue contains a #GST_TYPE_FRACTION_RANGE value. |
|
117 */ |
|
118 #define GST_VALUE_HOLDS_FRACTION_RANGE(x) (G_VALUE_HOLDS(x, gst_fraction_range_get_type ())) |
|
119 |
|
120 /** |
|
121 * GST_VALUE_HOLDS_LIST: |
|
122 * @x: the #GValue to check |
|
123 * |
|
124 * Checks if the given #GValue contains a #GST_TYPE_LIST value. |
|
125 */ |
|
126 #define GST_VALUE_HOLDS_LIST(x) (G_VALUE_HOLDS(x, gst_value_list_get_type ())) |
|
127 |
|
128 /** |
|
129 * GST_VALUE_HOLDS_ARRAY: |
|
130 * @x: the #GValue to check |
|
131 * |
|
132 * Checks if the given #GValue contains a #GST_TYPE_ARRAY value. |
|
133 */ |
|
134 #define GST_VALUE_HOLDS_ARRAY(x) (G_VALUE_HOLDS(x, gst_value_array_get_type ())) |
|
135 |
|
136 /** |
|
137 * GST_VALUE_HOLDS_CAPS: |
|
138 * @x: the #GValue to check |
|
139 * |
|
140 * Checks if the given #GValue contains a #GST_TYPE_CAPS value. |
|
141 */ |
|
142 #define GST_VALUE_HOLDS_CAPS(x) (G_VALUE_HOLDS(x, GST_TYPE_CAPS)) |
|
143 |
|
144 /** |
|
145 * GST_VALUE_HOLDS_STRUCTURE: |
|
146 * @x: the #GValue to check |
|
147 * |
|
148 * Checks if the given #GValue contains a #GST_TYPE_STRUCTURE value. |
|
149 * |
|
150 * Since: 0.10.15 |
|
151 */ |
|
152 #define GST_VALUE_HOLDS_STRUCTURE(x) (G_VALUE_HOLDS(x, GST_TYPE_STRUCTURE)) |
|
153 |
|
154 /** |
|
155 * GST_VALUE_HOLDS_BUFFER: |
|
156 * @x: the #GValue to check |
|
157 * |
|
158 * Checks if the given #GValue contains a #GST_TYPE_BUFFER value. |
|
159 */ |
|
160 #define GST_VALUE_HOLDS_BUFFER(x) (G_VALUE_HOLDS(x, GST_TYPE_BUFFER)) |
|
161 |
|
162 /** |
|
163 * GST_VALUE_HOLDS_FRACTION: |
|
164 * @x: the #GValue to check |
|
165 * |
|
166 * Checks if the given #GValue contains a #GST_TYPE_FRACTION value. |
|
167 */ |
|
168 #define GST_VALUE_HOLDS_FRACTION(x) (G_VALUE_HOLDS(x, gst_fraction_get_type ())) |
|
169 |
|
170 /** |
|
171 * GST_VALUE_HOLDS_DATE: |
|
172 * @x: the #GValue to check |
|
173 * |
|
174 * Checks if the given #GValue contains a #GST_TYPE_DATE value. |
|
175 */ |
|
176 #define GST_VALUE_HOLDS_DATE(x) (G_VALUE_HOLDS(x, gst_date_get_type ())) |
|
177 |
|
178 /** |
|
179 * GST_TYPE_FOURCC: |
|
180 * |
|
181 * a #GValue type that represents 4 byte identifier (e.g. used for codecs) |
|
182 * |
|
183 * Returns: the #GType of GstFourcc |
|
184 */ |
|
185 #define GST_TYPE_FOURCC gst_fourcc_get_type () |
|
186 |
|
187 /** |
|
188 * GST_TYPE_INT_RANGE: |
|
189 * |
|
190 * a #GValue type that represents an integer range |
|
191 * |
|
192 * Returns: the #GType of GstIntRange |
|
193 */ |
|
194 #define GST_TYPE_INT_RANGE gst_int_range_get_type () |
|
195 |
|
196 /** |
|
197 * GST_TYPE_DOUBLE_RANGE: |
|
198 * |
|
199 * a #GValue type that represents a floating point range with double precission |
|
200 * |
|
201 * Returns: the #GType of GstIntRange |
|
202 */ |
|
203 #define GST_TYPE_DOUBLE_RANGE gst_double_range_get_type () |
|
204 |
|
205 /** |
|
206 * GST_TYPE_FRACTION_RANGE: |
|
207 * |
|
208 * a #GValue type that represents a GstFraction range |
|
209 * |
|
210 * Returns: the #GType of GstFractionRange |
|
211 */ |
|
212 #define GST_TYPE_FRACTION_RANGE gst_fraction_range_get_type () |
|
213 |
|
214 /** |
|
215 * GST_TYPE_LIST: |
|
216 * |
|
217 * a #GValue type that represents an unordered list of #GValue values. This |
|
218 * is used for example to express a list of possible values for a field in |
|
219 * a caps structure, like a list of possible sample rates, of which only one |
|
220 * will be chosen in the end. This means that all values in the list are |
|
221 * meaningful on their own. |
|
222 * |
|
223 * Returns: the #GType of GstValueList (which is not explicitly typed) |
|
224 */ |
|
225 #define GST_TYPE_LIST gst_value_list_get_type () |
|
226 |
|
227 /** |
|
228 * GST_TYPE_ARRAY: |
|
229 * |
|
230 * a #GValue type that represents an ordered list of #GValue values. This is |
|
231 * used to express a set of values that is meaningful only in their specific |
|
232 * combination and order of values. Each value on its own is not particularly |
|
233 * meaningful, only the ordered array in its entirety is meaningful. This is |
|
234 * used for example to express channel layouts for multichannel audio where |
|
235 * each channel needs to be mapped to a position in the room. |
|
236 * |
|
237 * Returns: the #GType of GstArrayList (which is not explicitly typed) |
|
238 */ |
|
239 #define GST_TYPE_ARRAY gst_value_array_get_type () |
|
240 |
|
241 /** |
|
242 * GST_TYPE_FRACTION: |
|
243 * |
|
244 * a #GValue type that represents a fraction of an integer numerator over |
|
245 * an integer denominator |
|
246 * |
|
247 * Returns: the #GType of GstFraction (which is not explicitly typed) |
|
248 */ |
|
249 |
|
250 #define GST_TYPE_FRACTION gst_fraction_get_type () |
|
251 |
|
252 /** |
|
253 * GST_TYPE_DATE: |
|
254 * |
|
255 * a boxed #GValue type for #GDate that represents a date. |
|
256 * |
|
257 * Returns: the #GType of GstDate |
|
258 */ |
|
259 |
|
260 #define GST_TYPE_DATE gst_date_get_type () |
|
261 |
|
262 /** |
|
263 * GST_VALUE_LESS_THAN: |
|
264 * |
|
265 * Indicates that the first value provided to a comparison function |
|
266 * (gst_value_compare()) is lesser than the second one. |
|
267 */ |
|
268 #define GST_VALUE_LESS_THAN (-1) |
|
269 |
|
270 /** |
|
271 * GST_VALUE_EQUAL: |
|
272 * |
|
273 * Indicates that the first value provided to a comparison function |
|
274 * (gst_value_compare()) is equal to the second one. |
|
275 */ |
|
276 #define GST_VALUE_EQUAL 0 |
|
277 |
|
278 /** |
|
279 * GST_VALUE_GREATER_THAN: |
|
280 * |
|
281 * Indicates that the first value provided to a comparison function |
|
282 * (gst_value_compare()) is greater than the second one. |
|
283 */ |
|
284 #define GST_VALUE_GREATER_THAN 1 |
|
285 |
|
286 /** |
|
287 * GST_VALUE_UNORDERED: |
|
288 * |
|
289 * Indicates that the comparison function (gst_value_compare()) can not |
|
290 * determine a order for the two provided values. |
|
291 */ |
|
292 #define GST_VALUE_UNORDERED 2 |
|
293 |
|
294 /** |
|
295 * GstValueCompareFunc: |
|
296 * @value1: first value for comparission |
|
297 * @value2: second value for comparission |
|
298 * |
|
299 * Used together with gst_value_compare() to compare #GValues. |
|
300 * |
|
301 * Returns: one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN |
|
302 * or GST_VALUE_UNORDERED |
|
303 */ |
|
304 typedef gint (* GstValueCompareFunc) (const GValue *value1, |
|
305 const GValue *value2); |
|
306 |
|
307 /** |
|
308 * GstValueSerializeFunc: |
|
309 * @value1: a #GValue |
|
310 * |
|
311 * Used by gst_value_serialize() to obtain a non-binary form of the #GValue. |
|
312 * |
|
313 * Returns: the string representation of the value |
|
314 */ |
|
315 typedef gchar * (* GstValueSerializeFunc) (const GValue *value1); |
|
316 |
|
317 /** |
|
318 * GstValueDeserializeFunc: |
|
319 * @dest: a #GValue |
|
320 * @s: a string |
|
321 * |
|
322 * Used by gst_value_deserialize() to parse a non-binary form into the #GValue. |
|
323 * |
|
324 * Returns: %TRUE for success |
|
325 */ |
|
326 typedef gboolean (* GstValueDeserializeFunc) (GValue *dest, |
|
327 const gchar *s); |
|
328 |
|
329 /** |
|
330 * GstValueUnionFunc: |
|
331 * @dest: a #GValue for the result |
|
332 * @value1: a #GValue operand |
|
333 * @value2: a #GValue operand |
|
334 * |
|
335 * Used by gst_value_union() to perform unification for a specific #GValue |
|
336 * type. Register a new implementation with gst_value_register_union_func(). |
|
337 * |
|
338 * Returns: %TRUE if a union was successful |
|
339 */ |
|
340 typedef gboolean (* GstValueUnionFunc) (GValue *dest, |
|
341 const GValue *value1, |
|
342 const GValue *value2); |
|
343 |
|
344 /** |
|
345 * GstValueIntersectFunc: |
|
346 * @dest: a #GValue for the result |
|
347 * @value1: a #GValue operand |
|
348 * @value2: a #GValue operand |
|
349 * |
|
350 * Used by gst_value_intersect() to perform intersection for a specific #GValue |
|
351 * type. If the intersection is non-empty, the result is |
|
352 * placed in @dest and TRUE is returned. If the intersection is |
|
353 * empty, @dest is unmodified and FALSE is returned. |
|
354 * Register a new implementation with gst_value_register_intersection_func(). |
|
355 * |
|
356 * Returns: %TRUE if the values can intersect |
|
357 */ |
|
358 typedef gboolean (* GstValueIntersectFunc) (GValue *dest, |
|
359 const GValue *value1, |
|
360 const GValue *value2); |
|
361 |
|
362 /** |
|
363 * GstValueSubtractFunc: |
|
364 * @dest: a #GValue for the result |
|
365 * @minuend: a #GValue operand |
|
366 * @subtrahend: a #GValue operand |
|
367 * |
|
368 * Used by gst_value_subtract() to perform subtraction for a specific #GValue |
|
369 * type. Register a new implementation with gst_value_register_subtract_func(). |
|
370 * |
|
371 * Returns: %TRUE if the subtraction is not empty |
|
372 */ |
|
373 typedef gboolean (* GstValueSubtractFunc) (GValue *dest, |
|
374 const GValue *minuend, |
|
375 const GValue *subtrahend); |
|
376 |
|
377 typedef struct _GstValueTable GstValueTable; |
|
378 /** |
|
379 * GstValueTable: |
|
380 * @type: a #GType |
|
381 * @compare: a #GstValueCompareFunc |
|
382 * @serialize: a #GstValueSerializeFunc |
|
383 * @deserialize: a #GstValueDeserializeFunc |
|
384 * |
|
385 * VTable for the #GValue @type. |
|
386 */ |
|
387 struct _GstValueTable { |
|
388 GType type; |
|
389 GstValueCompareFunc compare; |
|
390 GstValueSerializeFunc serialize; |
|
391 GstValueDeserializeFunc deserialize; |
|
392 |
|
393 /*< private >*/ |
|
394 void *_gst_reserved [GST_PADDING]; |
|
395 }; |
|
396 #ifdef __SYMBIAN32__ |
|
397 IMPORT_C |
|
398 #endif |
|
399 |
|
400 |
|
401 GType gst_int_range_get_type (void); |
|
402 #ifdef __SYMBIAN32__ |
|
403 IMPORT_C |
|
404 #endif |
|
405 |
|
406 GType gst_double_range_get_type (void); |
|
407 #ifdef __SYMBIAN32__ |
|
408 IMPORT_C |
|
409 #endif |
|
410 |
|
411 GType gst_fraction_range_get_type (void); |
|
412 #ifdef __SYMBIAN32__ |
|
413 IMPORT_C |
|
414 #endif |
|
415 |
|
416 GType gst_fourcc_get_type (void); |
|
417 #ifdef __SYMBIAN32__ |
|
418 IMPORT_C |
|
419 #endif |
|
420 |
|
421 GType gst_fraction_get_type (void); |
|
422 #ifdef __SYMBIAN32__ |
|
423 IMPORT_C |
|
424 #endif |
|
425 |
|
426 GType gst_value_list_get_type (void); |
|
427 #ifdef __SYMBIAN32__ |
|
428 IMPORT_C |
|
429 #endif |
|
430 |
|
431 GType gst_value_array_get_type (void); |
|
432 #ifdef __SYMBIAN32__ |
|
433 IMPORT_C |
|
434 #endif |
|
435 |
|
436 |
|
437 GType gst_date_get_type (void); |
|
438 #ifdef __SYMBIAN32__ |
|
439 IMPORT_C |
|
440 #endif |
|
441 |
|
442 |
|
443 void gst_value_register (const GstValueTable *table); |
|
444 #ifdef __SYMBIAN32__ |
|
445 IMPORT_C |
|
446 #endif |
|
447 |
|
448 void gst_value_init_and_copy (GValue *dest, |
|
449 const GValue *src); |
|
450 #ifdef __SYMBIAN32__ |
|
451 IMPORT_C |
|
452 #endif |
|
453 |
|
454 |
|
455 gchar * gst_value_serialize (const GValue *value); |
|
456 #ifdef __SYMBIAN32__ |
|
457 IMPORT_C |
|
458 #endif |
|
459 |
|
460 gboolean gst_value_deserialize (GValue *dest, |
|
461 const gchar *src); |
|
462 |
|
463 /* list */ |
|
464 #ifdef __SYMBIAN32__ |
|
465 IMPORT_C |
|
466 #endif |
|
467 |
|
468 void gst_value_list_append_value (GValue *value, |
|
469 const GValue *append_value); |
|
470 #ifdef __SYMBIAN32__ |
|
471 IMPORT_C |
|
472 #endif |
|
473 |
|
474 void gst_value_list_prepend_value (GValue *value, |
|
475 const GValue *prepend_value); |
|
476 #ifdef __SYMBIAN32__ |
|
477 IMPORT_C |
|
478 #endif |
|
479 |
|
480 void gst_value_list_concat (GValue *dest, |
|
481 const GValue *value1, |
|
482 const GValue *value2); |
|
483 #ifdef __SYMBIAN32__ |
|
484 IMPORT_C |
|
485 #endif |
|
486 |
|
487 guint gst_value_list_get_size (const GValue *value); |
|
488 #ifdef __SYMBIAN32__ |
|
489 IMPORT_C |
|
490 #endif |
|
491 |
|
492 G_CONST_RETURN GValue * |
|
493 gst_value_list_get_value (const GValue *value, |
|
494 guint index); |
|
495 |
|
496 /* array */ |
|
497 #ifdef __SYMBIAN32__ |
|
498 IMPORT_C |
|
499 #endif |
|
500 |
|
501 void gst_value_array_append_value (GValue *value, |
|
502 const GValue *append_value); |
|
503 #ifdef __SYMBIAN32__ |
|
504 IMPORT_C |
|
505 #endif |
|
506 |
|
507 void gst_value_array_prepend_value (GValue *value, |
|
508 const GValue *prepend_value); |
|
509 #ifdef __SYMBIAN32__ |
|
510 IMPORT_C |
|
511 #endif |
|
512 |
|
513 guint gst_value_array_get_size (const GValue *value); |
|
514 #ifdef __SYMBIAN32__ |
|
515 IMPORT_C |
|
516 #endif |
|
517 |
|
518 G_CONST_RETURN GValue * |
|
519 gst_value_array_get_value (const GValue *value, |
|
520 guint index); |
|
521 |
|
522 /* fourcc */ |
|
523 #ifdef __SYMBIAN32__ |
|
524 IMPORT_C |
|
525 #endif |
|
526 |
|
527 void gst_value_set_fourcc (GValue *value, |
|
528 guint32 fourcc); |
|
529 #ifdef __SYMBIAN32__ |
|
530 IMPORT_C |
|
531 #endif |
|
532 |
|
533 guint32 gst_value_get_fourcc (const GValue *value); |
|
534 |
|
535 /* int range */ |
|
536 #ifdef __SYMBIAN32__ |
|
537 IMPORT_C |
|
538 #endif |
|
539 |
|
540 void gst_value_set_int_range (GValue *value, |
|
541 gint start, |
|
542 gint end); |
|
543 #ifdef __SYMBIAN32__ |
|
544 IMPORT_C |
|
545 #endif |
|
546 |
|
547 gint gst_value_get_int_range_min (const GValue *value); |
|
548 #ifdef __SYMBIAN32__ |
|
549 IMPORT_C |
|
550 #endif |
|
551 |
|
552 gint gst_value_get_int_range_max (const GValue *value); |
|
553 |
|
554 /* double range */ |
|
555 #ifdef __SYMBIAN32__ |
|
556 IMPORT_C |
|
557 #endif |
|
558 |
|
559 void gst_value_set_double_range (GValue *value, |
|
560 gdouble start, |
|
561 gdouble end); |
|
562 #ifdef __SYMBIAN32__ |
|
563 IMPORT_C |
|
564 #endif |
|
565 |
|
566 gdouble gst_value_get_double_range_min (const GValue *value); |
|
567 #ifdef __SYMBIAN32__ |
|
568 IMPORT_C |
|
569 #endif |
|
570 |
|
571 gdouble gst_value_get_double_range_max (const GValue *value); |
|
572 |
|
573 /* caps */ |
|
574 #ifdef __SYMBIAN32__ |
|
575 IMPORT_C |
|
576 #endif |
|
577 |
|
578 G_CONST_RETURN GstCaps * |
|
579 gst_value_get_caps (const GValue *value); |
|
580 #ifdef __SYMBIAN32__ |
|
581 IMPORT_C |
|
582 #endif |
|
583 |
|
584 void gst_value_set_caps (GValue *value, |
|
585 const GstCaps *caps); |
|
586 |
|
587 /* structure */ |
|
588 #ifdef __SYMBIAN32__ |
|
589 IMPORT_C |
|
590 #endif |
|
591 |
|
592 G_CONST_RETURN GstStructure * |
|
593 gst_value_get_structure (const GValue *value); |
|
594 #ifdef __SYMBIAN32__ |
|
595 IMPORT_C |
|
596 #endif |
|
597 |
|
598 void gst_value_set_structure (GValue *value, |
|
599 const GstStructure *structure); |
|
600 |
|
601 /* fraction */ |
|
602 #ifdef __SYMBIAN32__ |
|
603 IMPORT_C |
|
604 #endif |
|
605 |
|
606 void gst_value_set_fraction (GValue *value, |
|
607 gint numerator, |
|
608 gint denominator); |
|
609 #ifdef __SYMBIAN32__ |
|
610 IMPORT_C |
|
611 #endif |
|
612 |
|
613 gint gst_value_get_fraction_numerator (const GValue *value); |
|
614 #ifdef __SYMBIAN32__ |
|
615 IMPORT_C |
|
616 #endif |
|
617 |
|
618 gint gst_value_get_fraction_denominator(const GValue *value); |
|
619 #ifdef __SYMBIAN32__ |
|
620 IMPORT_C |
|
621 #endif |
|
622 |
|
623 gboolean gst_value_fraction_multiply (GValue *product, |
|
624 const GValue *factor1, |
|
625 const GValue *factor2); |
|
626 #ifdef __SYMBIAN32__ |
|
627 IMPORT_C |
|
628 #endif |
|
629 |
|
630 gboolean gst_value_fraction_subtract (GValue * dest, |
|
631 const GValue * minuend, |
|
632 const GValue * subtrahend); |
|
633 |
|
634 /* fraction range */ |
|
635 #ifdef __SYMBIAN32__ |
|
636 IMPORT_C |
|
637 #endif |
|
638 |
|
639 void gst_value_set_fraction_range (GValue *value, |
|
640 const GValue *start, |
|
641 const GValue *end); |
|
642 #ifdef __SYMBIAN32__ |
|
643 IMPORT_C |
|
644 #endif |
|
645 |
|
646 void gst_value_set_fraction_range_full (GValue *value, |
|
647 gint numerator_start, |
|
648 gint denominator_start, |
|
649 gint numerator_end, |
|
650 gint denominator_end); |
|
651 #ifdef __SYMBIAN32__ |
|
652 IMPORT_C |
|
653 #endif |
|
654 |
|
655 const GValue *gst_value_get_fraction_range_min (const GValue *value); |
|
656 #ifdef __SYMBIAN32__ |
|
657 IMPORT_C |
|
658 #endif |
|
659 |
|
660 const GValue *gst_value_get_fraction_range_max (const GValue *value); |
|
661 |
|
662 /* date */ |
|
663 #ifdef __SYMBIAN32__ |
|
664 IMPORT_C |
|
665 #endif |
|
666 |
|
667 G_CONST_RETURN GDate * |
|
668 gst_value_get_date (const GValue *value); |
|
669 #ifdef __SYMBIAN32__ |
|
670 IMPORT_C |
|
671 #endif |
|
672 |
|
673 void gst_value_set_date (GValue *value, |
|
674 const GDate *date); |
|
675 |
|
676 /* compare */ |
|
677 #ifdef __SYMBIAN32__ |
|
678 IMPORT_C |
|
679 #endif |
|
680 |
|
681 gint gst_value_compare (const GValue *value1, |
|
682 const GValue *value2); |
|
683 #ifdef __SYMBIAN32__ |
|
684 IMPORT_C |
|
685 #endif |
|
686 |
|
687 gboolean gst_value_can_compare (const GValue *value1, |
|
688 const GValue *value2); |
|
689 /* union */ |
|
690 #ifdef __SYMBIAN32__ |
|
691 IMPORT_C |
|
692 #endif |
|
693 |
|
694 gboolean gst_value_union (GValue *dest, |
|
695 const GValue *value1, |
|
696 const GValue *value2); |
|
697 #ifdef __SYMBIAN32__ |
|
698 IMPORT_C |
|
699 #endif |
|
700 |
|
701 gboolean gst_value_can_union (const GValue *value1, |
|
702 const GValue *value2); |
|
703 #ifdef __SYMBIAN32__ |
|
704 IMPORT_C |
|
705 #endif |
|
706 |
|
707 void gst_value_register_union_func (GType type1, |
|
708 GType type2, |
|
709 GstValueUnionFunc func); |
|
710 |
|
711 /* intersection */ |
|
712 #ifdef __SYMBIAN32__ |
|
713 IMPORT_C |
|
714 #endif |
|
715 |
|
716 gboolean gst_value_intersect (GValue *dest, |
|
717 const GValue *value1, |
|
718 const GValue *value2); |
|
719 #ifdef __SYMBIAN32__ |
|
720 IMPORT_C |
|
721 #endif |
|
722 |
|
723 gboolean gst_value_can_intersect (const GValue *value1, |
|
724 const GValue *value2); |
|
725 #ifdef __SYMBIAN32__ |
|
726 IMPORT_C |
|
727 #endif |
|
728 |
|
729 void gst_value_register_intersect_func (GType type1, |
|
730 GType type2, |
|
731 GstValueIntersectFunc func); |
|
732 |
|
733 /* subtraction */ |
|
734 #ifdef __SYMBIAN32__ |
|
735 IMPORT_C |
|
736 #endif |
|
737 |
|
738 gboolean gst_value_subtract (GValue *dest, |
|
739 const GValue *minuend, |
|
740 const GValue *subtrahend); |
|
741 #ifdef __SYMBIAN32__ |
|
742 IMPORT_C |
|
743 #endif |
|
744 |
|
745 gboolean gst_value_can_subtract (const GValue *minuend, |
|
746 const GValue *subtrahend); |
|
747 #ifdef __SYMBIAN32__ |
|
748 IMPORT_C |
|
749 #endif |
|
750 |
|
751 void gst_value_register_subtract_func (GType minuend_type, |
|
752 GType subtrahend_type, |
|
753 GstValueSubtractFunc func); |
|
754 |
|
755 /* fixation */ |
|
756 #ifdef __SYMBIAN32__ |
|
757 IMPORT_C |
|
758 #endif |
|
759 |
|
760 gboolean gst_value_is_fixed (const GValue *value); |
|
761 |
|
762 G_END_DECLS |
|
763 |
|
764 #endif |
|
765 |
|
766 |