subprojects/gstreamer/gst/gstutils.h

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  *                    2002 Thomas Vander Stichele <thomas@apestaart.org>
   5  *
   6  * gstutils.h: Header for various utility functions
   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., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24
  25 #ifndef __GST_UTILS_H__
  26 #define __GST_UTILS_H__
  27
  28 #include <glib.h>
  29 #include <gst/gstconfig.h>
  30 #include <gst/gstbin.h>
  31 #include <gst/gstparse.h>
  32
  33 G_BEGIN_DECLS
  34
  35 GST_API
  36 void            gst_util_set_value_from_string  (GValue *value, const gchar *value_str);
  37
  38 GST_API
  39 void            gst_util_set_object_arg         (GObject *object, const gchar *name, const gchar *value);
  40
  41 GST_API
  42 gboolean        gst_util_set_object_array       (GObject * object, const gchar * name,
  43                                                  const GValueArray * array);
  44 GST_API
  45 gboolean        gst_util_get_object_array       (GObject * object, const gchar * name,
  46                                                  GValueArray ** array);
  47 GST_API
  48 void            gst_util_dump_mem               (const guchar *mem, guint size);
  49
  50 GST_API
  51 void            gst_util_dump_buffer            (GstBuffer * buf);
  52
  53 GST_API
  54 guint64         gst_util_gdouble_to_guint64     (gdouble value)  G_GNUC_CONST;
  55
  56 GST_API
  57 gdouble         gst_util_guint64_to_gdouble     (guint64 value)  G_GNUC_CONST;
  58
  59 /**
  60  * gst_guint64_to_gdouble:
  61  * @value: the #guint64 value to convert
  62  *
  63  * Convert @value to a gdouble.
  64  *
  65  * Returns: @value converted to a #gdouble.
  66  */
  67
  68 /**
  69  * gst_gdouble_to_guint64:
  70  * @value: the #gdouble value to convert
  71  *
  72  * Convert @value to a guint64.
  73  *
  74  * Returns: @value converted to a #guint64.
  75  */
  76 #ifdef WIN32
  77 #define         gst_gdouble_to_guint64(value)   gst_util_gdouble_to_guint64(value)
  78 #define         gst_guint64_to_gdouble(value)   gst_util_guint64_to_gdouble(value)
  79 #else
  80 #define         gst_gdouble_to_guint64(value)   ((guint64) (value))
  81 #define         gst_guint64_to_gdouble(value)   ((gdouble) (value))
  82 #endif
  83
  84 GST_API
  85 guint64         gst_util_uint64_scale           (guint64 val, guint64 num, guint64 denom);
  86
  87 GST_API
  88 guint64         gst_util_uint64_scale_round     (guint64 val, guint64 num, guint64 denom);
  89
  90 GST_API
  91 guint64         gst_util_uint64_scale_ceil      (guint64 val, guint64 num, guint64 denom);
  92
  93 GST_API
  94 guint64         gst_util_uint64_scale_int       (guint64 val, gint num, gint denom);
  95
  96 GST_API
  97 guint64         gst_util_uint64_scale_int_round (guint64 val, gint num, gint denom);
  98
  99 GST_API
 100 guint64         gst_util_uint64_scale_int_ceil  (guint64 val, gint num, gint denom);
 101
 102 /**
 103  * GST_SEQNUM_INVALID:
 104  *
 105  * A value which is guaranteed to never be returned by
 106  * gst_util_seqnum_next().
 107  *
 108  * Can be used as a default value in variables used to store seqnum.
 109  *
 110  * Since: 1.14
 111  */
 112 #define GST_SEQNUM_INVALID (0)
 113
 114 GST_API
 115 guint32         gst_util_seqnum_next            (void);
 116
 117 GST_API
 118 gint32          gst_util_seqnum_compare         (guint32 s1, guint32 s2);
 119
 120 /**
 121  * GST_GROUP_ID_INVALID:
 122  *
 123  * A value which is guaranteed to never be returned by
 124  * gst_util_group_id_next().
 125  *
 126  * Can be used as a default value in variables used to store group_id.
 127  *
 128  * Since: 1.14
 129  */
 130 #define GST_GROUP_ID_INVALID (0)
 131
 132 GST_API
 133 guint           gst_util_group_id_next          (void);
 134
 135 /**
 136  * GST_CALL_PARENT:
 137  * @parent_class_cast: the name of the class cast macro for the parent type
 138  * @name: name of the function to call
 139  * @args: arguments enclosed in '( )'
 140  *
 141  * Just call the parent handler.  This assumes that there is a variable
 142  * named parent_class that points to the (duh!) parent class.  Note that
 143  * this macro is not to be used with things that return something, use
 144  * the _WITH_DEFAULT version for that
 145  */
 146 #define GST_CALL_PARENT(parent_class_cast, name, args)                  \
 147         ((parent_class_cast(parent_class)->name != NULL) ?              \
 148          parent_class_cast(parent_class)->name args : (void) 0)
 149
 150 /**
 151  * GST_CALL_PARENT_WITH_DEFAULT:
 152  * @parent_class_cast: the name of the class cast macro for the parent type
 153  * @name: name of the function to call
 154  * @args: arguments enclosed in '( )'
 155  * @def_return: default result
 156  *
 157  * Same as GST_CALL_PARENT(), but in case there is no implementation, it
 158  * evaluates to @def_return.
 159  */
 160 #define GST_CALL_PARENT_WITH_DEFAULT(parent_class_cast, name, args, def_return)\
 161         ((parent_class_cast(parent_class)->name != NULL) ?              \
 162          parent_class_cast(parent_class)->name args : def_return)
 163
 164 /* Define PUT and GET functions for unaligned memory */
 165 #define _GST_GET(__data, __idx, __size, __shift) \
 166     (((guint##__size) (((const guint8 *) (__data))[__idx])) << (__shift))
 167
 168 #define _GST_PUT(__data, __idx, __size, __shift, __num) \
 169     (((guint8 *) (__data))[__idx] = (((guint##__size) (__num)) >> (__shift)) & 0xff)
 170
 171 #ifndef __GTK_DOC_IGNORE__
 172 #if GST_HAVE_UNALIGNED_ACCESS
 173 static inline guint16 __gst_fast_read16(const guint8 *v) {
 174   return *(const guint16*)(const void*)(v);
 175 }
 176 static inline guint32 __gst_fast_read32(const guint8 *v) {
 177   return *(const guint32*)(const void*)(v);
 178 }
 179 static inline guint64 __gst_fast_read64(const guint8 *v) {
 180   return *(const guint64*)(const void*)(v);
 181 }
 182 static inline guint16 __gst_fast_read_swap16(const guint8 *v) {
 183   return GUINT16_SWAP_LE_BE(*(const guint16*)(const void*)(v));
 184 }
 185 static inline guint32 __gst_fast_read_swap32(const guint8 *v) {
 186   return GUINT32_SWAP_LE_BE(*(const guint32*)(const void*)(v));
 187 }
 188 static inline guint64 __gst_fast_read_swap64(const guint8 *v) {
 189   return GUINT64_SWAP_LE_BE(*(const guint64*)(const void*)(v));
 190 }
 191 # define _GST_FAST_READ(s, d) __gst_fast_read##s((const guint8 *)(d))
 192 # define _GST_FAST_READ_SWAP(s, d) __gst_fast_read_swap##s((const guint8 *)(d))
 193
 194 static inline void __gst_fast_write16 (guint8 *p, guint16 v) {
 195   *(guint16*)(void*)(p) = v;
 196 }
 197 static inline void __gst_fast_write32 (guint8 *p, guint32 v) {
 198   *(guint32*)(void*)(p) = v;
 199 }
 200 static inline void __gst_fast_write64 (guint8 *p, guint64 v) {
 201   *(guint64*)(void*)(p) = v;
 202 }
 203 static inline void __gst_fast_write_swap16 (guint8 *p, guint16 v) {
 204   *(guint16*)(void*)(p) = GUINT16_SWAP_LE_BE (v);
 205 }
 206 static inline void __gst_fast_write_swap32 (guint8 *p, guint32 v) {
 207   *(guint32*)(void*)(p) = GUINT32_SWAP_LE_BE (v);
 208 }
 209 static inline void __gst_fast_write_swap64 (guint8 *p, guint64 v) {
 210   *(guint64*)(void*)(p) = GUINT64_SWAP_LE_BE (v);
 211 }
 212 # define _GST_FAST_WRITE(s, d, v) __gst_fast_write##s((guint8 *)(d), (v))
 213 # define _GST_FAST_WRITE_SWAP(s, d, v) __gst_fast_write_swap##s((guint8 *)(d), (v))
 214 #endif
 215 #endif
 216
 217
 218 /**
 219  * GST_READ_UINT64_BE:
 220  * @data: memory location
 221  *
 222  * Read a 64 bit unsigned integer value in big endian format from the memory buffer.
 223  */
 224
 225 /**
 226  * GST_READ_UINT64_LE:
 227  * @data: memory location
 228  *
 229  * Read a 64 bit unsigned integer value in little endian format from the memory buffer.
 230  */
 231 #if GST_HAVE_UNALIGNED_ACCESS
 232 # if (G_BYTE_ORDER == G_BIG_ENDIAN)
 233 #  define GST_READ_UINT64_BE(data)      _GST_FAST_READ (64, data)
 234 #  define GST_READ_UINT64_LE(data)      _GST_FAST_READ_SWAP (64, data)
 235 # else
 236 #  define GST_READ_UINT64_BE(data)      _GST_FAST_READ_SWAP (64, data)
 237 #  define GST_READ_UINT64_LE(data)      _GST_FAST_READ (64, data)
 238 # endif
 239 #else
 240 #define _GST_READ_UINT64_BE(data)       (_GST_GET (data, 0, 64, 56) | \
 241                                          _GST_GET (data, 1, 64, 48) | \
 242                                          _GST_GET (data, 2, 64, 40) | \
 243                                          _GST_GET (data, 3, 64, 32) | \
 244                                          _GST_GET (data, 4, 64, 24) | \
 245                                          _GST_GET (data, 5, 64, 16) | \
 246                                          _GST_GET (data, 6, 64,  8) | \
 247                                          _GST_GET (data, 7, 64,  0))
 248
 249 #define _GST_READ_UINT64_LE(data)       (_GST_GET (data, 7, 64, 56) | \
 250                                          _GST_GET (data, 6, 64, 48) | \
 251                                          _GST_GET (data, 5, 64, 40) | \
 252                                          _GST_GET (data, 4, 64, 32) | \
 253                                          _GST_GET (data, 3, 64, 24) | \
 254                                          _GST_GET (data, 2, 64, 16) | \
 255                                          _GST_GET (data, 1, 64,  8) | \
 256                                          _GST_GET (data, 0, 64,  0))
 257
 258 #define GST_READ_UINT64_BE(data) __gst_slow_read64_be((const guint8 *)(data))
 259 static inline guint64 __gst_slow_read64_be (const guint8 * data) {
 260   return _GST_READ_UINT64_BE (data);
 261 }
 262 #define GST_READ_UINT64_LE(data) __gst_slow_read64_le((const guint8 *)(data))
 263 static inline guint64 __gst_slow_read64_le (const guint8 * data) {
 264   return _GST_READ_UINT64_LE (data);
 265 }
 266 #endif
 267
 268 /**
 269  * GST_READ_UINT32_BE:
 270  * @data: memory location
 271  *
 272  * Read a 32 bit unsigned integer value in big endian format from the memory buffer.
 273  */
 274
 275 /**
 276  * GST_READ_UINT32_LE:
 277  * @data: memory location
 278  *
 279  * Read a 32 bit unsigned integer value in little endian format from the memory buffer.
 280  */
 281 #if GST_HAVE_UNALIGNED_ACCESS
 282 # if (G_BYTE_ORDER == G_BIG_ENDIAN)
 283 #  define GST_READ_UINT32_BE(data)      _GST_FAST_READ (32, data)
 284 #  define GST_READ_UINT32_LE(data)      _GST_FAST_READ_SWAP (32, data)
 285 # else
 286 #  define GST_READ_UINT32_BE(data)      _GST_FAST_READ_SWAP (32, data)
 287 #  define GST_READ_UINT32_LE(data)      _GST_FAST_READ (32, data)
 288 # endif
 289 #else
 290 #define _GST_READ_UINT32_BE(data)       (_GST_GET (data, 0, 32, 24) | \
 291                                          _GST_GET (data, 1, 32, 16) | \
 292                                          _GST_GET (data, 2, 32,  8) | \
 293                                          _GST_GET (data, 3, 32,  0))
 294
 295 #define _GST_READ_UINT32_LE(data)       (_GST_GET (data, 3, 32, 24) | \
 296                                          _GST_GET (data, 2, 32, 16) | \
 297                                          _GST_GET (data, 1, 32,  8) | \
 298                                          _GST_GET (data, 0, 32,  0))
 299
 300 #define GST_READ_UINT32_BE(data) __gst_slow_read32_be((const guint8 *)(data))
 301 static inline guint32 __gst_slow_read32_be (const guint8 * data) {
 302   return _GST_READ_UINT32_BE (data);
 303 }
 304 #define GST_READ_UINT32_LE(data) __gst_slow_read32_le((const guint8 *)(data))
 305 static inline guint32 __gst_slow_read32_le (const guint8 * data) {
 306   return _GST_READ_UINT32_LE (data);
 307 }
 308 #endif
 309
 310 /**
 311  * GST_READ_UINT24_BE:
 312  * @data: memory location
 313  *
 314  * Read a 24 bit unsigned integer value in big endian format from the memory buffer.
 315  */
 316 #define _GST_READ_UINT24_BE(data)       (_GST_GET (data, 0, 32, 16) | \
 317                                          _GST_GET (data, 1, 32,  8) | \
 318                                          _GST_GET (data, 2, 32,  0))
 319
 320 #define GST_READ_UINT24_BE(data) __gst_slow_read24_be((const guint8 *)(data))
 321 static inline guint32 __gst_slow_read24_be (const guint8 * data) {
 322   return _GST_READ_UINT24_BE (data);
 323 }
 324
 325 /**
 326  * GST_READ_UINT24_LE:
 327  * @data: memory location
 328  *
 329  * Read a 24 bit unsigned integer value in little endian format from the memory buffer.
 330  */
 331 #define _GST_READ_UINT24_LE(data)       (_GST_GET (data, 2, 32, 16) | \
 332                                          _GST_GET (data, 1, 32,  8) | \
 333                                          _GST_GET (data, 0, 32,  0))
 334
 335 #define GST_READ_UINT24_LE(data) __gst_slow_read24_le((const guint8 *)(data))
 336 static inline guint32 __gst_slow_read24_le (const guint8 * data) {
 337   return _GST_READ_UINT24_LE (data);
 338 }
 339
 340 /**
 341  * GST_READ_UINT16_BE:
 342  * @data: memory location
 343  *
 344  * Read a 16 bit unsigned integer value in big endian format from the memory buffer.
 345  */
 346 /**
 347  * GST_READ_UINT16_LE:
 348  * @data: memory location
 349  *
 350  * Read a 16 bit unsigned integer value in little endian format from the memory buffer.
 351  */
 352 #if GST_HAVE_UNALIGNED_ACCESS
 353 # if (G_BYTE_ORDER == G_BIG_ENDIAN)
 354 #  define GST_READ_UINT16_BE(data)      _GST_FAST_READ (16, data)
 355 #  define GST_READ_UINT16_LE(data)      _GST_FAST_READ_SWAP (16, data)
 356 # else
 357 #  define GST_READ_UINT16_BE(data)      _GST_FAST_READ_SWAP (16, data)
 358 #  define GST_READ_UINT16_LE(data)      _GST_FAST_READ (16, data)
 359 # endif
 360 #else
 361 #define _GST_READ_UINT16_BE(data)       (_GST_GET (data, 0, 16,  8) | \
 362                                          _GST_GET (data, 1, 16,  0))
 363
 364 #define _GST_READ_UINT16_LE(data)       (_GST_GET (data, 1, 16,  8) | \
 365                                          _GST_GET (data, 0, 16,  0))
 366
 367 #define GST_READ_UINT16_BE(data) __gst_slow_read16_be((const guint8 *)(data))
 368 static inline guint16 __gst_slow_read16_be (const guint8 * data) {
 369   return _GST_READ_UINT16_BE (data);
 370 }
 371 #define GST_READ_UINT16_LE(data) __gst_slow_read16_le((const guint8 *)(data))
 372 static inline guint16 __gst_slow_read16_le (const guint8 * data) {
 373   return _GST_READ_UINT16_LE (data);
 374 }
 375 #endif
 376
 377 /**
 378  * GST_READ_UINT8:
 379  * @data: memory location
 380  *
 381  * Read an 8 bit unsigned integer value from the memory buffer.
 382  */
 383 #define GST_READ_UINT8(data)            (_GST_GET (data, 0,  8,  0))
 384
 385 /**
 386  * GST_WRITE_UINT64_BE:
 387  * @data: memory location
 388  * @val: value to store
 389  *
 390  * Store a 64 bit unsigned integer value in big endian format into the memory buffer.
 391  */
 392 /**
 393  * GST_WRITE_UINT64_LE:
 394  * @data: memory location
 395  * @val: value to store
 396  *
 397  * Store a 64 bit unsigned integer value in little endian format into the memory buffer.
 398  */
 399 #if GST_HAVE_UNALIGNED_ACCESS
 400 # if (G_BYTE_ORDER == G_BIG_ENDIAN)
 401 #  define GST_WRITE_UINT64_BE(data,val) _GST_FAST_WRITE(64,data,val)
 402 #  define GST_WRITE_UINT64_LE(data,val) _GST_FAST_WRITE_SWAP(64,data,val)
 403 # else
 404 #  define GST_WRITE_UINT64_BE(data,val) _GST_FAST_WRITE_SWAP(64,data,val)
 405 #  define GST_WRITE_UINT64_LE(data,val) _GST_FAST_WRITE(64,data,val)
 406 # endif
 407 #else
 408 #define GST_WRITE_UINT64_BE(data,val)   do { \
 409                                           gpointer __put_data = data; \
 410                                           guint64 __put_val = val; \
 411                                           _GST_PUT (__put_data, 0, 64, 56, __put_val); \
 412                                           _GST_PUT (__put_data, 1, 64, 48, __put_val); \
 413                                           _GST_PUT (__put_data, 2, 64, 40, __put_val); \
 414                                           _GST_PUT (__put_data, 3, 64, 32, __put_val); \
 415                                           _GST_PUT (__put_data, 4, 64, 24, __put_val); \
 416                                           _GST_PUT (__put_data, 5, 64, 16, __put_val); \
 417                                           _GST_PUT (__put_data, 6, 64,  8, __put_val); \
 418                                           _GST_PUT (__put_data, 7, 64,  0, __put_val); \
 419                                         } while (0)
 420
 421 #define GST_WRITE_UINT64_LE(data,val)   do { \
 422                                           gpointer __put_data = data; \
 423                                           guint64 __put_val = val; \
 424                                           _GST_PUT (__put_data, 0, 64,  0, __put_val); \
 425                                           _GST_PUT (__put_data, 1, 64,  8, __put_val); \
 426                                           _GST_PUT (__put_data, 2, 64, 16, __put_val); \
 427                                           _GST_PUT (__put_data, 3, 64, 24, __put_val); \
 428                                           _GST_PUT (__put_data, 4, 64, 32, __put_val); \
 429                                           _GST_PUT (__put_data, 5, 64, 40, __put_val); \
 430                                           _GST_PUT (__put_data, 6, 64, 48, __put_val); \
 431                                           _GST_PUT (__put_data, 7, 64, 56, __put_val); \
 432                                         } while (0)
 433 #endif /* !GST_HAVE_UNALIGNED_ACCESS */
 434
 435 /**
 436  * GST_WRITE_UINT32_BE:
 437  * @data: memory location
 438  * @val: value to store
 439  *
 440  * Store a 32 bit unsigned integer value in big endian format into the memory buffer.
 441  */
 442 /**
 443  * GST_WRITE_UINT32_LE:
 444  * @data: memory location
 445  * @val: value to store
 446  *
 447  * Store a 32 bit unsigned integer value in little endian format into the memory buffer.
 448  */
 449 #if GST_HAVE_UNALIGNED_ACCESS
 450 # if (G_BYTE_ORDER == G_BIG_ENDIAN)
 451 #  define GST_WRITE_UINT32_BE(data,val) _GST_FAST_WRITE(32,data,val)
 452 #  define GST_WRITE_UINT32_LE(data,val) _GST_FAST_WRITE_SWAP(32,data,val)
 453 # else
 454 #  define GST_WRITE_UINT32_BE(data,val) _GST_FAST_WRITE_SWAP(32,data,val)
 455 #  define GST_WRITE_UINT32_LE(data,val) _GST_FAST_WRITE(32,data,val)
 456 # endif
 457 #else
 458 #define GST_WRITE_UINT32_BE(data,val)   do { \
 459                                           gpointer __put_data = data; \
 460                                           guint32 __put_val = val; \
 461                                           _GST_PUT (__put_data, 0, 32, 24, __put_val); \
 462                                           _GST_PUT (__put_data, 1, 32, 16, __put_val); \
 463                                           _GST_PUT (__put_data, 2, 32,  8, __put_val); \
 464                                           _GST_PUT (__put_data, 3, 32,  0, __put_val); \
 465                                         } while (0)
 466
 467 #define GST_WRITE_UINT32_LE(data,val)   do { \
 468                                           gpointer __put_data = data; \
 469                                           guint32 __put_val = val; \
 470                                           _GST_PUT (__put_data, 0, 32,  0, __put_val); \
 471                                           _GST_PUT (__put_data, 1, 32,  8, __put_val); \
 472                                           _GST_PUT (__put_data, 2, 32, 16, __put_val); \
 473                                           _GST_PUT (__put_data, 3, 32, 24, __put_val); \
 474                                         } while (0)
 475 #endif /* !GST_HAVE_UNALIGNED_ACCESS */
 476
 477 /**
 478  * GST_WRITE_UINT24_BE:
 479  * @data: memory location
 480  * @num: value to store
 481  *
 482  * Store a 24 bit unsigned integer value in big endian format into the memory buffer.
 483  */
 484 #define GST_WRITE_UINT24_BE(data, num)  do { \
 485                                           gpointer __put_data = data; \
 486                                           guint32 __put_val = num; \
 487                                           _GST_PUT (__put_data, 0, 32,  16, __put_val); \
 488                                           _GST_PUT (__put_data, 1, 32,  8, __put_val); \
 489                                           _GST_PUT (__put_data, 2, 32,  0, __put_val); \
 490                                         } while (0)
 491
 492 /**
 493  * GST_WRITE_UINT24_LE:
 494  * @data: memory location
 495  * @num: value to store
 496  *
 497  * Store a 24 bit unsigned integer value in little endian format into the memory buffer.
 498  */
 499 #define GST_WRITE_UINT24_LE(data, num)  do { \
 500                                           gpointer __put_data = data; \
 501                                           guint32 __put_val = num; \
 502                                           _GST_PUT (__put_data, 0, 32,  0, __put_val); \
 503                                           _GST_PUT (__put_data, 1, 32,  8, __put_val); \
 504                                           _GST_PUT (__put_data, 2, 32,  16, __put_val); \
 505                                         } while (0)
 506
 507 /**
 508  * GST_WRITE_UINT16_BE:
 509  * @data: memory location
 510  * @val: value to store
 511  *
 512  * Store a 16 bit unsigned integer value in big endian format into the memory buffer.
 513  */
 514 /**
 515  * GST_WRITE_UINT16_LE:
 516  * @data: memory location
 517  * @val: value to store
 518  *
 519  * Store a 16 bit unsigned integer value in little endian format into the memory buffer.
 520  */
 521 #if GST_HAVE_UNALIGNED_ACCESS
 522 # if (G_BYTE_ORDER == G_BIG_ENDIAN)
 523 #  define GST_WRITE_UINT16_BE(data,val) _GST_FAST_WRITE(16,data,val)
 524 #  define GST_WRITE_UINT16_LE(data,val) _GST_FAST_WRITE_SWAP(16,data,val)
 525 # else
 526 #  define GST_WRITE_UINT16_BE(data,val) _GST_FAST_WRITE_SWAP(16,data,val)
 527 #  define GST_WRITE_UINT16_LE(data,val) _GST_FAST_WRITE(16,data,val)
 528 # endif
 529 #else
 530 #define GST_WRITE_UINT16_BE(data,val)   do { \
 531                                           gpointer __put_data = data; \
 532                                           guint16 __put_val = val; \
 533                                           _GST_PUT (__put_data, 0, 16,  8, __put_val); \
 534                                           _GST_PUT (__put_data, 1, 16,  0, __put_val); \
 535                                         } while (0)
 536
 537 #define GST_WRITE_UINT16_LE(data,val)   do { \
 538                                           gpointer __put_data = data; \
 539                                           guint16 __put_val = val; \
 540                                           _GST_PUT (__put_data, 0, 16,  0, __put_val); \
 541                                           _GST_PUT (__put_data, 1, 16,  8, __put_val); \
 542                                         } while (0)
 543 #endif /* !GST_HAVE_UNALIGNED_ACCESS */
 544
 545 /**
 546  * GST_WRITE_UINT8:
 547  * @data: memory location
 548  * @num: value to store
 549  *
 550  * Store an 8 bit unsigned integer value into the memory buffer.
 551  */
 552 #define GST_WRITE_UINT8(data, num)      do { \
 553                                           _GST_PUT (data, 0,  8,  0, num); \
 554                                         } while (0)
 555
 556 /* Float endianness conversion macros */
 557 #ifndef __GI_SCANNER__
 558
 559 /* FIXME: Remove this once we depend on a GLib version with this */
 560 #ifndef GFLOAT_FROM_LE
 561 /**
 562  * GFLOAT_SWAP_LE_BE: (skip)
 563  * @in: input value
 564  *
 565  * Swap byte order of a 32-bit floating point value (float).
 566  *
 567  * Returns: @in byte-swapped.
 568  */
 569 static inline gfloat
 570 GFLOAT_SWAP_LE_BE(gfloat in)
 571 {
 572   union
 573   {
 574     guint32 i;
 575     gfloat f;
 576   } u;
 577
 578   u.f = in;
 579   u.i = GUINT32_SWAP_LE_BE (u.i);
 580   return u.f;
 581 }
 582
 583 /**
 584  * GDOUBLE_SWAP_LE_BE: (skip)
 585  * @in: input value
 586  *
 587  * Swap byte order of a 64-bit floating point value (double).
 588  *
 589  * Returns: @in byte-swapped.
 590  */
 591 static inline gdouble
 592 GDOUBLE_SWAP_LE_BE(gdouble in)
 593 {
 594   union
 595   {
 596     guint64 i;
 597     gdouble d;
 598   } u;
 599
 600   u.d = in;
 601   u.i = GUINT64_SWAP_LE_BE (u.i);
 602   return u.d;
 603 }
 604
 605 /**
 606  * GDOUBLE_TO_LE: (skip)
 607  * @val: value
 608  *
 609  * Convert 64-bit floating point value (double) from native byte order into
 610  * little endian byte order.
 611  */
 612 /**
 613  * GDOUBLE_TO_BE: (skip)
 614  * @val: value
 615  *
 616  * Convert 64-bit floating point value (double) from native byte order into
 617  * big endian byte order.
 618  */
 619 /**
 620  * GDOUBLE_FROM_LE: (skip)
 621  * @val: value
 622  *
 623  * Convert 64-bit floating point value (double) from little endian byte order
 624  * into native byte order.
 625  */
 626 /**
 627  * GDOUBLE_FROM_BE: (skip)
 628  * @val: value
 629  *
 630  * Convert 64-bit floating point value (double) from big endian byte order
 631  * into native byte order.
 632  */
 633
 634 /**
 635  * GFLOAT_TO_LE: (skip)
 636  * @val: value
 637  *
 638  * Convert 32-bit floating point value (float) from native byte order into
 639  * little endian byte order.
 640  */
 641 /**
 642  * GFLOAT_TO_BE: (skip)
 643  * @val: value
 644  *
 645  * Convert 32-bit floating point value (float) from native byte order into
 646  * big endian byte order.
 647  */
 648 /**
 649  * GFLOAT_FROM_LE: (skip)
 650  * @val: value
 651  *
 652  * Convert 32-bit floating point value (float) from little endian byte order
 653  * into native byte order.
 654  */
 655 /**
 656  * GFLOAT_FROM_BE: (skip)
 657  * @val: value
 658  *
 659  * Convert 32-bit floating point value (float) from big endian byte order
 660  * into native byte order.
 661  */
 662
 663 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
 664 #define GFLOAT_TO_LE(val)    ((gfloat) (val))
 665 #define GFLOAT_TO_BE(val)    (GFLOAT_SWAP_LE_BE (val))
 666 #define GDOUBLE_TO_LE(val)   ((gdouble) (val))
 667 #define GDOUBLE_TO_BE(val)   (GDOUBLE_SWAP_LE_BE (val))
 668
 669 #elif G_BYTE_ORDER == G_BIG_ENDIAN
 670 #define GFLOAT_TO_LE(val)    (GFLOAT_SWAP_LE_BE (val))
 671 #define GFLOAT_TO_BE(val)    ((gfloat) (val))
 672 #define GDOUBLE_TO_LE(val)   (GDOUBLE_SWAP_LE_BE (val))
 673 #define GDOUBLE_TO_BE(val)   ((gdouble) (val))
 674
 675 #else /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
 676 #error unknown ENDIAN type
 677 #endif /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
 678
 679 #define GFLOAT_FROM_LE(val)  (GFLOAT_TO_LE (val))
 680 #define GFLOAT_FROM_BE(val)  (GFLOAT_TO_BE (val))
 681 #define GDOUBLE_FROM_LE(val) (GDOUBLE_TO_LE (val))
 682 #define GDOUBLE_FROM_BE(val) (GDOUBLE_TO_BE (val))
 683
 684 #endif /* !defined(GFLOAT_FROM_LE) */
 685
 686 #endif /* !__GI_SCANNER__ */
 687
 688 /**
 689  * GST_READ_FLOAT_LE:
 690  * @data: memory location
 691  *
 692  * Read a 32 bit float value in little endian format from the memory buffer.
 693  *
 694  * Returns: The floating point value read from @data
 695  */
 696 static inline gfloat
 697 GST_READ_FLOAT_LE(const guint8 *data)
 698 {
 699   union
 700   {
 701     guint32 i;
 702     gfloat f;
 703   } u;
 704
 705   u.i = GST_READ_UINT32_LE (data);
 706   return u.f;
 707 }
 708
 709 /**
 710  * GST_READ_FLOAT_BE:
 711  * @data: memory location
 712  *
 713  * Read a 32 bit float value in big endian format from the memory buffer.
 714  *
 715  * Returns: The floating point value read from @data
 716  */
 717 static inline gfloat
 718 GST_READ_FLOAT_BE(const guint8 *data)
 719 {
 720   union
 721   {
 722     guint32 i;
 723     gfloat f;
 724   } u;
 725
 726   u.i = GST_READ_UINT32_BE (data);
 727   return u.f;
 728 }
 729
 730 /**
 731  * GST_READ_DOUBLE_LE:
 732  * @data: memory location
 733  *
 734  * Read a 64 bit double value in little endian format from the memory buffer.
 735  *
 736  * Returns: The double-precision floating point value read from @data
 737  */
 738 static inline gdouble
 739 GST_READ_DOUBLE_LE(const guint8 *data)
 740 {
 741   union
 742   {
 743     guint64 i;
 744     gdouble d;
 745   } u;
 746
 747   u.i = GST_READ_UINT64_LE (data);
 748   return u.d;
 749 }
 750
 751 /**
 752  * GST_READ_DOUBLE_BE:
 753  * @data: memory location
 754  *
 755  * Read a 64 bit double value in big endian format from the memory buffer.
 756  *
 757  * Returns: The double-precision floating point value read from @data
 758  */
 759 static inline gdouble
 760 GST_READ_DOUBLE_BE(const guint8 *data)
 761 {
 762   union
 763   {
 764     guint64 i;
 765     gdouble d;
 766   } u;
 767
 768   u.i = GST_READ_UINT64_BE (data);
 769   return u.d;
 770 }
 771
 772 /**
 773  * GST_WRITE_FLOAT_LE:
 774  * @data: memory location
 775  * @num: value to store
 776  *
 777  * Store a 32 bit float value in little endian format into the memory buffer.
 778  */
 779 static inline void
 780 GST_WRITE_FLOAT_LE(guint8 *data, gfloat num)
 781 {
 782   union
 783   {
 784     guint32 i;
 785     gfloat f;
 786   } u;
 787
 788   u.f = num;
 789   GST_WRITE_UINT32_LE (data, u.i);
 790 }
 791
 792 /**
 793  * GST_WRITE_FLOAT_BE:
 794  * @data: memory location
 795  * @num: value to store
 796  *
 797  * Store a 32 bit float value in big endian format into the memory buffer.
 798  */
 799 static inline void
 800 GST_WRITE_FLOAT_BE(guint8 *data, gfloat num)
 801 {
 802   union
 803   {
 804     guint32 i;
 805     gfloat f;
 806   } u;
 807
 808   u.f = num;
 809   GST_WRITE_UINT32_BE (data, u.i);
 810 }
 811
 812 /**
 813  * GST_WRITE_DOUBLE_LE:
 814  * @data: memory location
 815  * @num: value to store
 816  *
 817  * Store a 64 bit double value in little endian format into the memory buffer.
 818  */
 819 static inline void
 820 GST_WRITE_DOUBLE_LE(guint8 *data, gdouble num)
 821 {
 822   union
 823   {
 824     guint64 i;
 825     gdouble d;
 826   } u;
 827
 828   u.d = num;
 829   GST_WRITE_UINT64_LE (data, u.i);
 830 }
 831
 832 /**
 833  * GST_WRITE_DOUBLE_BE:
 834  * @data: memory location
 835  * @num: value to store
 836  *
 837  * Store a 64 bit double value in big endian format into the memory buffer.
 838  */
 839 static inline void
 840 GST_WRITE_DOUBLE_BE(guint8 *data, gdouble num)
 841 {
 842   union
 843   {
 844     guint64 i;
 845     gdouble d;
 846   } u;
 847
 848   u.d = num;
 849   GST_WRITE_UINT64_BE (data, u.i);
 850 }
 851
 852 /* Miscellaneous utility macros */
 853
 854 /**
 855  * GST_ROUND_UP_2:
 856  * @num: integer value to round up
 857  *
 858  * Rounds an integer value up to the next multiple of 2.
 859  */
 860 #define GST_ROUND_UP_2(num)  (((num)+1)&~1)
 861 /**
 862  * GST_ROUND_UP_4:
 863  * @num: integer value to round up
 864  *
 865  * Rounds an integer value up to the next multiple of 4.
 866  */
 867 #define GST_ROUND_UP_4(num)  (((num)+3)&~3)
 868 /**
 869  * GST_ROUND_UP_8:
 870  * @num: integer value to round up
 871  *
 872  * Rounds an integer value up to the next multiple of 8.
 873  */
 874 #define GST_ROUND_UP_8(num)  (((num)+7)&~7)
 875 /**
 876  * GST_ROUND_UP_16:
 877  * @num: integer value to round up
 878  *
 879  * Rounds an integer value up to the next multiple of 16.
 880  */
 881 #define GST_ROUND_UP_16(num) (((num)+15)&~15)
 882 /**
 883  * GST_ROUND_UP_32:
 884  * @num: integer value to round up
 885  *
 886  * Rounds an integer value up to the next multiple of 32.
 887  */
 888 #define GST_ROUND_UP_32(num) (((num)+31)&~31)
 889 /**
 890  * GST_ROUND_UP_64:
 891  * @num: integer value to round up
 892  *
 893  * Rounds an integer value up to the next multiple of 64.
 894  */
 895 #define GST_ROUND_UP_64(num) (((num)+63)&~63)
 896 /**
 897  * GST_ROUND_UP_128:
 898  * @num: integer value to round up
 899  *
 900  * Rounds an integer value up to the next multiple of 128.
 901  * Since: 1.4
 902  */
 903 #define GST_ROUND_UP_128(num) (((num)+127)&~127)
 904 /**
 905  * GST_ROUND_UP_N:
 906  * @num: integrer value to round up
 907  * @align: a power of two to round up to
 908  *
 909  * Rounds an integer value up to the next multiple of @align. @align MUST be a
 910  * power of two.
 911  */
 912 #define GST_ROUND_UP_N(num,align) ((((num) + ((align) - 1)) & ~((align) - 1)))
 913
 914
 915 /**
 916  * GST_ROUND_DOWN_2:
 917  * @num: integer value to round down
 918  *
 919  * Rounds an integer value down to the next multiple of 2.
 920  */
 921 #define GST_ROUND_DOWN_2(num)  ((num)&(~1))
 922 /**
 923  * GST_ROUND_DOWN_4:
 924  * @num: integer value to round down
 925  *
 926  * Rounds an integer value down to the next multiple of 4.
 927  */
 928 #define GST_ROUND_DOWN_4(num)  ((num)&(~3))
 929 /**
 930  * GST_ROUND_DOWN_8:
 931  * @num: integer value to round down
 932  *
 933  * Rounds an integer value down to the next multiple of 8.
 934  */
 935 #define GST_ROUND_DOWN_8(num)  ((num)&(~7))
 936 /**
 937  * GST_ROUND_DOWN_16:
 938  * @num: integer value to round down
 939  *
 940  * Rounds an integer value down to the next multiple of 16.
 941  */
 942 #define GST_ROUND_DOWN_16(num) ((num)&(~15))
 943 /**
 944  * GST_ROUND_DOWN_32:
 945  * @num: integer value to round down
 946  *
 947  * Rounds an integer value down to the next multiple of 32.
 948  */
 949 #define GST_ROUND_DOWN_32(num) ((num)&(~31))
 950 /**
 951  * GST_ROUND_DOWN_64:
 952  * @num: integer value to round down
 953  *
 954  * Rounds an integer value down to the next multiple of 64.
 955  */
 956 #define GST_ROUND_DOWN_64(num) ((num)&(~63))
 957 /**
 958  * GST_ROUND_DOWN_128:
 959  * @num: integer value to round down
 960  *
 961  * Rounds an integer value down to the next multiple of 128.
 962  * Since: 1.4
 963  */
 964 #define GST_ROUND_DOWN_128(num) ((num)&(~127))
 965 /**
 966  * GST_ROUND_DOWN_N:
 967  * @num: integrer value to round down
 968  * @align: a power of two to round down to
 969  *
 970  * Rounds an integer value down to the next multiple of @align. @align MUST be a
 971  * power of two.
 972  */
 973 #define GST_ROUND_DOWN_N(num,align) (((num) & ~((align) - 1)))
 974
 975
 976 GST_API
 977 void                    gst_object_default_error        (GstObject    * source,
 978                                                          const GError * error,
 979                                                          const gchar  * debug);
 980
 981 /* element functions */
 982
 983 GST_API
 984 void                    gst_element_create_all_pads     (GstElement *element);
 985
 986 GST_API
 987 GstPad*                 gst_element_get_compatible_pad  (GstElement *element, GstPad *pad,
 988                                                          GstCaps *caps);
 989 GST_API
 990 GstPadTemplate*         gst_element_get_compatible_pad_template (GstElement *element, GstPadTemplate *compattempl);
 991
 992 GST_API
 993 const gchar*            gst_element_state_get_name      (GstState state);
 994
 995 GST_API
 996 const gchar *           gst_element_state_change_return_get_name (GstStateChangeReturn state_ret);
 997
 998 GST_API
 999 const gchar *           gst_state_change_get_name       (GstStateChange transition);
1000
1001 GST_API
1002 gboolean                gst_element_link                (GstElement *src, GstElement *dest);
1003
1004 GST_API
1005 gboolean                gst_element_link_many           (GstElement *element_1,
1006                                                          GstElement *element_2, ...) G_GNUC_NULL_TERMINATED;
1007 GST_API
1008 gboolean                gst_element_link_filtered       (GstElement * src,
1009                                                          GstElement * dest,
1010                                                          GstCaps *filter);
1011 GST_API
1012 void                    gst_element_unlink              (GstElement *src, GstElement *dest);
1013
1014 GST_API
1015 void                    gst_element_unlink_many         (GstElement *element_1,
1016                                                          GstElement *element_2, ...) G_GNUC_NULL_TERMINATED;
1017 GST_API
1018 gboolean                gst_element_link_pads           (GstElement *src, const gchar *srcpadname,
1019                                                          GstElement *dest, const gchar *destpadname);
1020 GST_API
1021 gboolean                gst_element_link_pads_full      (GstElement *src, const gchar *srcpadname,
1022                                                          GstElement *dest, const gchar *destpadname,
1023                                                          GstPadLinkCheck flags);
1024 GST_API
1025 void                    gst_element_unlink_pads         (GstElement *src, const gchar *srcpadname,
1026                                                          GstElement *dest, const gchar *destpadname);
1027 GST_API
1028 gboolean                gst_element_link_pads_filtered  (GstElement * src, const gchar * srcpadname,
1029                                                          GstElement * dest, const gchar * destpadname,
1030                                                          GstCaps *filter);
1031 GST_API
1032 gboolean                gst_element_seek_simple         (GstElement   *element,
1033                                                          GstFormat     format,
1034                                                          GstSeekFlags  seek_flags,
1035                                                          gint64        seek_pos);
1036
1037 /* util elementfactory functions */
1038
1039 GST_API
1040 gboolean gst_element_factory_can_sink_all_caps (GstElementFactory *factory, const GstCaps *caps);
1041
1042 GST_API
1043 gboolean gst_element_factory_can_src_all_caps  (GstElementFactory *factory, const GstCaps *caps);
1044
1045 GST_API
1046 gboolean gst_element_factory_can_sink_any_caps (GstElementFactory *factory, const GstCaps *caps);
1047
1048 GST_API
1049 gboolean gst_element_factory_can_src_any_caps  (GstElementFactory *factory, const GstCaps *caps);
1050
1051 /* util query functions */
1052
1053 GST_API
1054 gboolean                gst_element_query_position      (GstElement *element, GstFormat format, gint64 *cur);
1055
1056 GST_API
1057 gboolean                gst_element_query_duration      (GstElement *element, GstFormat format, gint64 *duration);
1058
1059 GST_API
1060 gboolean                gst_element_query_convert       (GstElement *element, GstFormat src_format, gint64 src_val,
1061                                                          GstFormat dest_format, gint64 *dest_val);
1062
1063 /* pad functions */
1064
1065 GST_API
1066 void                    gst_pad_use_fixed_caps          (GstPad *pad);
1067
1068 GST_API
1069 GstElement*             gst_pad_get_parent_element      (GstPad *pad);
1070
1071 /* util query functions */
1072
1073 GST_API
1074 gboolean                gst_pad_proxy_query_accept_caps (GstPad *pad, GstQuery *query);
1075
1076 GST_API
1077 gboolean                gst_pad_proxy_query_caps        (GstPad *pad, GstQuery *query);
1078
1079 GST_API
1080 gboolean                gst_pad_query_position          (GstPad *pad, GstFormat format, gint64 *cur);
1081
1082 GST_API
1083 gboolean                gst_pad_query_duration          (GstPad *pad, GstFormat format, gint64 *duration);
1084
1085 GST_API
1086 gboolean                gst_pad_query_convert           (GstPad *pad, GstFormat src_format, gint64 src_val,
1087                                                          GstFormat dest_format, gint64 *dest_val);
1088 GST_API
1089 GstCaps *               gst_pad_query_caps              (GstPad *pad, GstCaps *filter);
1090
1091 GST_API
1092 gboolean                gst_pad_query_accept_caps       (GstPad *pad, GstCaps *caps);
1093
1094 GST_API
1095 gboolean                gst_pad_link_maybe_ghosting      (GstPad            *src,
1096                                                           GstPad            *sink);
1097 GST_API
1098 gboolean                gst_pad_link_maybe_ghosting_full (GstPad            *src,
1099                                                           GstPad            *sink,
1100                                                           GstPadLinkCheck   flags);
1101 GST_API
1102 gboolean                gst_pad_peer_query_position     (GstPad *pad, GstFormat format, gint64 *cur);
1103
1104 GST_API
1105 gboolean                gst_pad_peer_query_duration     (GstPad *pad, GstFormat format, gint64 *duration);
1106
1107 GST_API
1108 gboolean                gst_pad_peer_query_convert      (GstPad *pad, GstFormat src_format, gint64 src_val,
1109                                                          GstFormat dest_format, gint64 *dest_val);
1110 GST_API
1111 GstCaps *               gst_pad_peer_query_caps         (GstPad * pad, GstCaps *filter);
1112
1113 GST_API
1114 gboolean                gst_pad_peer_query_accept_caps  (GstPad * pad, GstCaps *caps);
1115
1116 GST_API
1117 gchar *                 gst_pad_create_stream_id               (GstPad * pad, GstElement * parent, const gchar *stream_id) G_GNUC_MALLOC;
1118
1119 GST_API
1120 gchar *                 gst_pad_create_stream_id_printf        (GstPad * pad, GstElement * parent, const gchar *stream_id, ...) G_GNUC_PRINTF (3, 4) G_GNUC_MALLOC;
1121
1122 GST_API
1123 gchar *                 gst_pad_create_stream_id_printf_valist (GstPad * pad, GstElement * parent, const gchar *stream_id, va_list var_args) G_GNUC_PRINTF (3, 0) G_GNUC_MALLOC;
1124
1125 GST_API
1126 gchar *                 gst_pad_get_stream_id           (GstPad * pad);
1127
1128 GST_API
1129 GstStream *             gst_pad_get_stream              (GstPad * pad);
1130
1131 /* bin functions */
1132
1133 GST_API
1134 void                    gst_bin_add_many                (GstBin *bin, GstElement *element_1, ...) G_GNUC_NULL_TERMINATED;
1135
1136 GST_API
1137 void                    gst_bin_remove_many             (GstBin *bin, GstElement *element_1, ...) G_GNUC_NULL_TERMINATED;
1138
1139 GST_API
1140 GstPad *                gst_bin_find_unlinked_pad       (GstBin *bin, GstPadDirection direction);
1141
1142 GST_API
1143 gboolean                gst_bin_sync_children_states    (GstBin *bin);
1144
1145 /* parse utility functions */
1146
1147 GST_API
1148 GstElement *            gst_parse_bin_from_description      (const gchar     * bin_description,
1149                                                              gboolean          ghost_unlinked_pads,
1150                                                              GError         ** err);
1151 GST_API
1152 GstElement *            gst_parse_bin_from_description_full (const gchar     * bin_description,
1153                                                              gboolean          ghost_unlinked_pads,
1154                                                              GstParseContext * context,
1155                                                              GstParseFlags     flags,
1156                                                              GError         ** err);
1157 GST_API
1158 GstClockTime            gst_util_get_timestamp          (void);
1159
1160 /**
1161  * GstSearchMode:
1162  * @GST_SEARCH_MODE_EXACT : Only search for exact matches.
1163  * @GST_SEARCH_MODE_BEFORE: Search for an exact match or the element just before.
1164  * @GST_SEARCH_MODE_AFTER : Search for an exact match or the element just after.
1165  *
1166  * The different search modes.
1167  */
1168 typedef enum {
1169   GST_SEARCH_MODE_EXACT = 0,
1170   GST_SEARCH_MODE_BEFORE,
1171   GST_SEARCH_MODE_AFTER
1172 } GstSearchMode;
1173
1174 /**
1175  * GstPluginAPIFlags:
1176  * @GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS: Ignore enum members when generating
1177  *   the plugins cache. This is useful if the members of the enum are generated
1178  *   dynamically, in order not to expose incorrect documentation to the end user.
1179  *
1180  * Since: 1.18
1181  */
1182 typedef enum {
1183   GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS = (1 << 0),
1184 } GstPluginAPIFlags;
1185
1186 GST_API
1187 gpointer      gst_util_array_binary_search      (gpointer array, guint num_elements,
1188                                                  gsize element_size, GCompareDataFunc search_func,
1189                                                  GstSearchMode mode, gconstpointer search_data,
1190                                                  gpointer user_data);
1191
1192 /* fraction operations */
1193
1194 GST_API
1195 gint          gst_util_greatest_common_divisor  (gint a, gint b);
1196
1197 GST_API
1198 gint64        gst_util_greatest_common_divisor_int64 (gint64 a, gint64 b);
1199
1200 GST_API
1201 void          gst_util_fraction_to_double       (gint src_n, gint src_d, gdouble *dest);
1202
1203 GST_API
1204 void          gst_util_double_to_fraction       (gdouble src, gint *dest_n, gint *dest_d);
1205
1206 GST_API
1207 gboolean      gst_util_fraction_multiply        (gint a_n, gint a_d, gint b_n, gint b_d,
1208                                                  gint *res_n, gint *res_d);
1209 GST_API
1210 gboolean      gst_util_fraction_add             (gint a_n, gint a_d, gint b_n, gint b_d,
1211                                                  gint *res_n, gint *res_d);
1212 GST_API
1213 gint          gst_util_fraction_compare         (gint a_n, gint a_d, gint b_n, gint b_d);
1214
1215 GST_API
1216 gboolean      gst_calculate_linear_regression   (const GstClockTime * xy,
1217                                                  GstClockTime * temp, guint n,
1218                                                  GstClockTime * m_num, GstClockTime * m_denom,
1219                                                  GstClockTime * b, GstClockTime * xbase,
1220                                                  gdouble * r_squared);
1221
1222 GST_API
1223 void          gst_type_mark_as_plugin_api       (GType type, GstPluginAPIFlags flags);
1224
1225 GST_API
1226 gboolean      gst_type_is_plugin_api            (GType type, GstPluginAPIFlags *flags);
1227
1228 G_END_DECLS
1229
1230 #endif /* __GST_UTILS_H__ */