GstUtils

gst_calculate_linear_regression

gboolean
gst_calculate_linear_regression (const GstClockTime * xy,
                                 GstClockTime * temp,
                                 guint n,
                                 GstClockTime * m_num,
                                 GstClockTime * m_denom,
                                 GstClockTime * b,
                                 GstClockTime * xbase,
                                 gdouble * r_squared)

Calculates the linear regression of the values xy and places the result in m_num, m_denom, b and xbase, representing the function y(x) = m_num/m_denom * (x - xbase) + b that has the least-square distance from all points x and y.

r_squared will contain the remaining error.

If temp is not NULL, it will be used as temporary space for the function, in which case the function works without any allocation at all. If temp is NULL, an allocation will take place. temp should have at least the same amount of memory allocated as xy, i.e. 2nsizeof(GstClockTime).

This function assumes (x,y) values with reasonable large differences between them. It will not calculate the exact results if the differences between neighbouring values are too small due to not being able to represent sub-integer values during the calculations.

Since : 1.12

gst_parse_bin_from_description

GstElement *
gst_parse_bin_from_description (const gchar * bin_description,
                                gboolean ghost_unlinked_pads,
                                GError ** error)

This is a convenience wrapper around gst_parse_launch to create a GstBin from a gst-launch-style pipeline description. See gst_parse_launch and the gst-launch man page for details about the syntax. Ghost pads on the bin for unlinked source or sink pads within the bin can automatically be created (but only a maximum of one ghost pad for each direction will be created; if you expect multiple unlinked source pads or multiple unlinked sink pads and want them all ghosted, you will have to create the ghost pads yourself).

gst_parse_bin_from_description_full

GstElement *
gst_parse_bin_from_description_full (const gchar * bin_description,
                                     gboolean ghost_unlinked_pads,
                                     GstParseContext * context,
                                     GstParseFlags flags,
                                     GError ** error)

This is a convenience wrapper around gst_parse_launch to create a GstBin from a gst-launch-style pipeline description. See gst_parse_launch and the gst-launch man page for details about the syntax. Ghost pads on the bin for unlinked source or sink pads within the bin can automatically be created (but only a maximum of one ghost pad for each direction will be created; if you expect multiple unlinked source pads or multiple unlinked sink pads and want them all ghosted, you will have to create the ghost pads yourself).

gst_state_change_get_name

const gchar *
gst_state_change_get_name (GstStateChange transition)

Gets a string representing the given state transition.

Since : 1.14

gst_type_is_plugin_api

gboolean
gst_type_is_plugin_api (GType type,
                        GstPluginAPIFlags * flags)

Checks if type is plugin API. See gst_type_mark_as_plugin_api for details.

Since : 1.18

gst_type_mark_as_plugin_api

gst_type_mark_as_plugin_api (GType type,
                             GstPluginAPIFlags flags)

Marks type as plugin API. This should be called in class_init of elements that expose new types (i.e. enums, flags or internal GObjects) via properties, signals or pad templates.

Types exposed by plugins are not automatically added to the documentation as they might originate from another library and should in that case be documented via that library instead.

By marking a type as plugin API it will be included in the documentation of the plugin that defines it.

Since : 1.18

gst_util_array_binary_search

gpointer
gst_util_array_binary_search (gpointer array,
                              guint num_elements,
                              gsize element_size,
                              GCompareDataFunc search_func,
                              GstSearchMode mode,
                              gconstpointer search_data,
                              gpointer user_data)

Searches inside array for search_data by using the comparison function search_func. array must be sorted ascending.

As search_data is always passed as second argument to search_func it's not required that search_data has the same type as the array elements.

The complexity of this search function is O(log (num_elements)).

gst_util_ceil_log2

guint
gst_util_ceil_log2 (guint32 v)

Returns smallest integral value not less than log2(v).

Since : 1.24

gst_util_double_to_fraction

gst_util_double_to_fraction (gdouble src,
                             gint * dest_n,
                             gint * dest_d)

Transforms a gdouble to a fraction and simplifies the result.

gst_util_dump_buffer

gst_util_dump_buffer (GstBuffer * buf)

Dumps the buffer memory into a hex representation. Useful for debugging.

Since : 1.14

gst_util_dump_mem

gst_util_dump_mem (const guchar * mem,
                   guint size)

Dumps the memory block into a hex representation. Useful for debugging.

gst_util_filename_compare

gint
gst_util_filename_compare (const gchar * a,
                           const gchar * b)

Compares the given filenames using natural ordering.

Since : 1.24

gst_util_floor_log2

guint
gst_util_floor_log2 (guint32 x)

Returns smallest integral value not bigger than log2(v).

Since : 1.26

gst_util_fraction_add

gboolean
gst_util_fraction_add (gint a_n,
                       gint a_d,
                       gint b_n,
                       gint b_d,
                       gint * res_n,
                       gint * res_d)

Adds the fractions a_n/@a_d and b_n/@b_d and stores the result in res_n and res_d.

gst_util_fraction_compare

gint
gst_util_fraction_compare (gint a_n,
                           gint a_d,
                           gint b_n,
                           gint b_d)

Compares the fractions a_n/@a_d and b_n/@b_d and returns -1 if a < b, 0 if a = b and 1 if a > b.

gst_util_fraction_multiply

gboolean
gst_util_fraction_multiply (gint a_n,
                            gint a_d,
                            gint b_n,
                            gint b_d,
                            gint * res_n,
                            gint * res_d)

Multiplies the fractions a_n/@a_d and b_n/@b_d and stores the result in res_n and res_d.

gst_util_fraction_multiply_int64

gboolean
gst_util_fraction_multiply_int64 (gint64 a_n,
                                  gint64 a_d,
                                  gint64 b_n,
                                  gint64 b_d,
                                  gint64 * res_n,
                                  gint64 * res_d)

Multiplies the fractions a_n/@a_d and b_n/@b_d and stores the result in res_n and res_d.

Since : 1.26

gst_util_fraction_to_double

gst_util_fraction_to_double (gint src_n,
                             gint src_d,
                             gdouble * dest)

Transforms a fraction to a gdouble.

gst_util_gdouble_to_guint64

guint64
gst_util_gdouble_to_guint64 (gdouble value)

gst_util_get_object_array

gboolean
gst_util_get_object_array (GObject * object,
                           const gchar * name,
                           GValueArray ** array)

Get a property of type GST_TYPE_ARRAY and transform it into a GValueArray. This allow language bindings to get GST_TYPE_ARRAY properties which are otherwise not an accessible type.

Since : 1.12

gst_util_get_timestamp

GstClockTime
gst_util_get_timestamp ()

Get a timestamp as GstClockTime to be used for interval measurements. The timestamp should not be interpreted in any other way.

gst_util_greatest_common_divisor

gint
gst_util_greatest_common_divisor (gint a,
                                  gint b)

Calculates the greatest common divisor of a and b.

gst_util_greatest_common_divisor_int64

gint64
gst_util_greatest_common_divisor_int64 (gint64 a,
                                        gint64 b)

Calculates the greatest common divisor of a and b.

gst_util_group_id_next

guint
gst_util_group_id_next ()

Return a constantly incrementing group id.

This function is used to generate a new group-id for the stream-start event.

This function never returns GST_GROUP_ID_INVALID (which is 0)

gst_util_guint64_to_gdouble

gdouble
gst_util_guint64_to_gdouble (guint64 value)

gst_util_seqnum_compare

gint32
gst_util_seqnum_compare (guint32 s1,
                         guint32 s2)

Compare two sequence numbers, handling wraparound.

The current implementation just returns (gint32)(@s1 - s2).

gst_util_seqnum_next

guint32
gst_util_seqnum_next ()

Return a constantly incrementing sequence number.

This function is used internally to GStreamer to be able to determine which events and messages are "the same". For example, elements may set the seqnum on a segment-done message to be the same as that of the last seek event, to indicate that event and the message correspond to the same segment.

This function never returns GST_SEQNUM_INVALID (which is 0).

gst_util_set_object_arg

gst_util_set_object_arg (GObject * object,
                         const gchar * name,
                         const gchar * value)

Converts the string value to the type of the objects argument and sets the argument with it.

Note that this function silently returns if object has no property named name or when value cannot be converted to the type of the property.

gst_util_set_object_array

gboolean
gst_util_set_object_array (GObject * object,
                           const gchar * name,
                           const GValueArray * array)

Transfer a GValueArray to GST_TYPE_ARRAY and set this value on the specified property name. This allow language bindings to set GST_TYPE_ARRAY properties which are otherwise not an accessible type.

Since : 1.12

gst_util_set_value_from_string

gst_util_set_value_from_string (GValue * value,
                                const gchar * value_str)

Converts the string to the type of the value and sets the value with it.

Note that this function is dangerous as it does not return any indication if the conversion worked or not.

gst_util_simplify_fraction

gst_util_simplify_fraction (gint * numerator,
                            gint * denominator,
                            guint n_terms,
                            guint threshold)

Calculates the simpler representation of numerator and denominator and update both values with the resulting simplified fraction.

Simplify a fraction using a simple continued fraction decomposition. The idea here is to convert fractions such as 333333/10000000 to 1/30 using 32 bit arithmetic only. The algorithm is not perfect and relies upon two arbitrary parameters to remove non-significative terms from the simple continued fraction decomposition. Using 8 and 333 for n_terms and threshold respectively seems to give nice results.

Since : 1.24

gst_util_uint64_scale

guint64
gst_util_uint64_scale (guint64 val,
                       guint64 num,
                       guint64 denom)

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision.

This function can potentially be very slow if val and num are both greater than G_MAXUINT32.

gst_util_uint64_scale_ceil

guint64
gst_util_uint64_scale_ceil (guint64 val,
                            guint64 num,
                            guint64 denom)

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision.

This function can potentially be very slow if val and num are both greater than G_MAXUINT32.

gst_util_uint64_scale_int

guint64
gst_util_uint64_scale_int (guint64 val,
                           gint num,
                           gint denom)

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and denom must be positive.

gst_util_uint64_scale_int_ceil

guint64
gst_util_uint64_scale_int_ceil (guint64 val,
                                gint num,
                                gint denom)

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and denom must be positive.

gst_util_uint64_scale_int_round

guint64
gst_util_uint64_scale_int_round (guint64 val,
                                 gint num,
                                 gint denom)

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and denom must be positive.

gst_util_uint64_scale_round

guint64
gst_util_uint64_scale_round (guint64 val,
                             guint64 num,
                             guint64 denom)

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision.

This function can potentially be very slow if val and num are both greater than G_MAXUINT32.

GDOUBLE_FROM_BE

#define GDOUBLE_FROM_BE(val) (GDOUBLE_TO_BE (val))

Convert 64-bit floating point value (double) from big endian byte order into native byte order.

GDOUBLE_FROM_LE

#define GDOUBLE_FROM_LE(val) (GDOUBLE_TO_LE (val))

Convert 64-bit floating point value (double) from little endian byte order into native byte order.

GDOUBLE_TO_BE

#define GDOUBLE_TO_BE(val)   (GDOUBLE_SWAP_LE_BE (val))

Convert 64-bit floating point value (double) from native byte order into big endian byte order.

GDOUBLE_TO_LE

#define GDOUBLE_TO_LE(val)   ((gdouble) (val))

Convert 64-bit floating point value (double) from native byte order into little endian byte order.

GFLOAT_FROM_BE

#define GFLOAT_FROM_BE(val)  (GFLOAT_TO_BE (val))

Convert 32-bit floating point value (float) from big endian byte order into native byte order.

GFLOAT_FROM_LE

#define GFLOAT_FROM_LE(val)  (GFLOAT_TO_LE (val))

Convert 32-bit floating point value (float) from little endian byte order into native byte order.

GFLOAT_TO_BE

#define GFLOAT_TO_BE(val)    (GFLOAT_SWAP_LE_BE (val))

Convert 32-bit floating point value (float) from native byte order into big endian byte order.

GFLOAT_TO_LE

#define GFLOAT_TO_LE(val)    ((gfloat) (val))

Convert 32-bit floating point value (float) from native byte order into little endian byte order.

GST_CALL_PARENT

#define GST_CALL_PARENT(parent_class_cast, name, args)                  \
        ((parent_class_cast(parent_class)->name != NULL) ?              \
         parent_class_cast(parent_class)->name args : (void) 0)

Just call the parent handler. This assumes that there is a variable named parent_class that points to the (duh!) parent class. Note that this macro is not to be used with things that return something, use the _WITH_DEFAULT version for that

GST_CALL_PARENT_WITH_DEFAULT

#define GST_CALL_PARENT_WITH_DEFAULT(parent_class_cast, name, args, def_return)\
        ((parent_class_cast(parent_class)->name != NULL) ?              \
         parent_class_cast(parent_class)->name args : def_return)

Same as GST_CALL_PARENT, but in case there is no implementation, it evaluates to def_return.

GST_READ_UINT16_BE

#define GST_READ_UINT16_BE(data)      _GST_FAST_READ (16, data)

Read a 16 bit unsigned integer value in big endian format from the memory buffer.

GST_READ_UINT16_LE

#define GST_READ_UINT16_LE(data)      _GST_FAST_READ_SWAP (16, data)

Read a 16 bit unsigned integer value in little endian format from the memory buffer.

GST_READ_UINT24_BE

#define GST_READ_UINT24_BE(data) __gst_slow_read24_be((const guint8 *)(data))

Read a 24 bit unsigned integer value in big endian format from the memory buffer.

GST_READ_UINT24_LE

#define GST_READ_UINT24_LE(data) __gst_slow_read24_le((const guint8 *)(data))

Read a 24 bit unsigned integer value in little endian format from the memory buffer.

GST_READ_UINT32_BE

#define GST_READ_UINT32_BE(data)      _GST_FAST_READ (32, data)

Read a 32 bit unsigned integer value in big endian format from the memory buffer.

GST_READ_UINT32_LE

#define GST_READ_UINT32_LE(data)      _GST_FAST_READ_SWAP (32, data)

Read a 32 bit unsigned integer value in little endian format from the memory buffer.

GST_READ_UINT64_BE

#define GST_READ_UINT64_BE(data)      _GST_FAST_READ (64, data)

Read a 64 bit unsigned integer value in big endian format from the memory buffer.

GST_READ_UINT64_LE

#define GST_READ_UINT64_LE(data)      _GST_FAST_READ_SWAP (64, data)

Read a 64 bit unsigned integer value in little endian format from the memory buffer.

GST_READ_UINT8

#define GST_READ_UINT8(data)            (_GST_GET (data, 0,  8,  0))

Read an 8 bit unsigned integer value from the memory buffer.

GST_ROUND_DOWN_128

#define GST_ROUND_DOWN_128(num) ((num)&(~127))

Rounds an integer value down to the next multiple of 128.

Since : 1.4

GST_ROUND_DOWN_16

#define GST_ROUND_DOWN_16(num) ((num)&(~15))

Rounds an integer value down to the next multiple of 16.

GST_ROUND_DOWN_2

#define GST_ROUND_DOWN_2(num)  ((num)&(~1))

Rounds an integer value down to the next multiple of 2.

GST_ROUND_DOWN_32

#define GST_ROUND_DOWN_32(num) ((num)&(~31))

Rounds an integer value down to the next multiple of 32.

GST_ROUND_DOWN_4

#define GST_ROUND_DOWN_4(num)  ((num)&(~3))

Rounds an integer value down to the next multiple of 4.

GST_ROUND_DOWN_64

#define GST_ROUND_DOWN_64(num) ((num)&(~63))

Rounds an integer value down to the next multiple of 64.

GST_ROUND_DOWN_8

#define GST_ROUND_DOWN_8(num)  ((num)&(~7))

Rounds an integer value down to the next multiple of 8.

GST_ROUND_DOWN_N

#define GST_ROUND_DOWN_N(num,align) (((num) & ~((align) - 1)))

Rounds an integer value down to the next multiple of align. align MUST be a power of two.

GST_ROUND_UP_128

#define GST_ROUND_UP_128(num) (((num)+127)&~127)

Rounds an integer value up to the next multiple of 128.

Since : 1.4

GST_ROUND_UP_16

#define GST_ROUND_UP_16(num) (((num)+15)&~15)

Rounds an integer value up to the next multiple of 16.

GST_ROUND_UP_2

#define GST_ROUND_UP_2(num)  (((num)+1)&~1)

Rounds an integer value up to the next multiple of 2.

GST_ROUND_UP_32

#define GST_ROUND_UP_32(num) (((num)+31)&~31)

Rounds an integer value up to the next multiple of 32.

GST_ROUND_UP_4

#define GST_ROUND_UP_4(num)  (((num)+3)&~3)

Rounds an integer value up to the next multiple of 4.

GST_ROUND_UP_64

#define GST_ROUND_UP_64(num) (((num)+63)&~63)

Rounds an integer value up to the next multiple of 64.

GST_ROUND_UP_8

#define GST_ROUND_UP_8(num)  (((num)+7)&~7)

Rounds an integer value up to the next multiple of 8.

GST_ROUND_UP_N

#define GST_ROUND_UP_N(num,align) ((((num) + ((align) - 1)) & ~((align) - 1)))

Rounds an integer value up to the next multiple of align. align MUST be a power of two.

GST_WRITE_UINT16_BE

#define GST_WRITE_UINT16_BE(data,val) _GST_FAST_WRITE(16,data,val)

Store a 16 bit unsigned integer value in big endian format into the memory buffer.

GST_WRITE_UINT16_LE

#define GST_WRITE_UINT16_LE(data,val) _GST_FAST_WRITE_SWAP(16,data,val)

Store a 16 bit unsigned integer value in little endian format into the memory buffer.

GST_WRITE_UINT24_BE

#define GST_WRITE_UINT24_BE(data, num)  do { \
                                          gpointer __put_data = data; \
                                          guint32 __put_val = num; \
                                          _GST_PUT (__put_data, 0, 32,  16, __put_val); \
                                          _GST_PUT (__put_data, 1, 32,  8, __put_val); \
                                          _GST_PUT (__put_data, 2, 32,  0, __put_val); \
                                        } while (0)

Store a 24 bit unsigned integer value in big endian format into the memory buffer.

GST_WRITE_UINT24_LE

#define GST_WRITE_UINT24_LE(data, num)  do { \
                                          gpointer __put_data = data; \
                                          guint32 __put_val = num; \
                                          _GST_PUT (__put_data, 0, 32,  0, __put_val); \
                                          _GST_PUT (__put_data, 1, 32,  8, __put_val); \
                                          _GST_PUT (__put_data, 2, 32,  16, __put_val); \
                                        } while (0)

Store a 24 bit unsigned integer value in little endian format into the memory buffer.

GST_WRITE_UINT32_BE

#define GST_WRITE_UINT32_BE(data,val) _GST_FAST_WRITE(32,data,val)

Store a 32 bit unsigned integer value in big endian format into the memory buffer.

GST_WRITE_UINT32_LE

#define GST_WRITE_UINT32_LE(data,val) _GST_FAST_WRITE_SWAP(32,data,val)

Store a 32 bit unsigned integer value in little endian format into the memory buffer.

GST_WRITE_UINT64_BE

#define GST_WRITE_UINT64_BE(data,val) _GST_FAST_WRITE(64,data,val)

Store a 64 bit unsigned integer value in big endian format into the memory buffer.

GST_WRITE_UINT64_LE

#define GST_WRITE_UINT64_LE(data,val) _GST_FAST_WRITE_SWAP(64,data,val)

Store a 64 bit unsigned integer value in little endian format into the memory buffer.

GST_WRITE_UINT8

#define GST_WRITE_UINT8(data, num)      do { \
                                          _GST_PUT (data, 0,  8,  0, num); \
                                        } while (0)

Store an 8 bit unsigned integer value into the memory buffer.

_GST_FAST_READ

#define _GST_FAST_READ(s, d) __gst_fast_read##s((const guint8 *)(d))

_GST_FAST_READ_SWAP

#define _GST_FAST_READ_SWAP(s, d) __gst_fast_read_swap##s((const guint8 *)(d))

_GST_FAST_WRITE

#define _GST_FAST_WRITE(s, d, v) __gst_fast_write##s((guint8 *)(d), (v))

_GST_FAST_WRITE_SWAP

#define _GST_FAST_WRITE_SWAP(s, d, v) __gst_fast_write_swap##s((guint8 *)(d), (v))

_GST_GET

#define _GST_GET(__data, __idx, __size, __shift) \
    (((guint##__size) (((const guint8 *) (__data))[__idx])) << (__shift))

_GST_PUT

#define _GST_PUT(__data, __idx, __size, __shift, __num) \
    (((guint8 *) (__data))[__idx] = (((guint##__size) (__num)) >> (__shift)) & 0xff)

_GST_READ_UINT16_BE

#define _GST_READ_UINT16_BE(data)	(_GST_GET (data, 0, 16,  8) | \
					 _GST_GET (data, 1, 16,  0))

_GST_READ_UINT16_LE

#define _GST_READ_UINT16_LE(data)	(_GST_GET (data, 1, 16,  8) | \
					 _GST_GET (data, 0, 16,  0))

_GST_READ_UINT24_BE

#define _GST_READ_UINT24_BE(data)       (_GST_GET (data, 0, 32, 16) | \
                                         _GST_GET (data, 1, 32,  8) | \
                                         _GST_GET (data, 2, 32,  0))

_GST_READ_UINT24_LE

#define _GST_READ_UINT24_LE(data)       (_GST_GET (data, 2, 32, 16) | \
                                         _GST_GET (data, 1, 32,  8) | \
                                         _GST_GET (data, 0, 32,  0))

_GST_READ_UINT32_BE

#define _GST_READ_UINT32_BE(data)	(_GST_GET (data, 0, 32, 24) | \
					 _GST_GET (data, 1, 32, 16) | \
					 _GST_GET (data, 2, 32,  8) | \
					 _GST_GET (data, 3, 32,  0))

_GST_READ_UINT32_LE

#define _GST_READ_UINT32_LE(data)	(_GST_GET (data, 3, 32, 24) | \
					 _GST_GET (data, 2, 32, 16) | \
					 _GST_GET (data, 1, 32,  8) | \
					 _GST_GET (data, 0, 32,  0))

_GST_READ_UINT64_BE

#define _GST_READ_UINT64_BE(data)	(_GST_GET (data, 0, 64, 56) | \
					 _GST_GET (data, 1, 64, 48) | \
					 _GST_GET (data, 2, 64, 40) | \
					 _GST_GET (data, 3, 64, 32) | \
					 _GST_GET (data, 4, 64, 24) | \
					 _GST_GET (data, 5, 64, 16) | \
					 _GST_GET (data, 6, 64,  8) | \
					 _GST_GET (data, 7, 64,  0))

_GST_READ_UINT64_LE

#define _GST_READ_UINT64_LE(data)	(_GST_GET (data, 7, 64, 56) | \
					 _GST_GET (data, 6, 64, 48) | \
					 _GST_GET (data, 5, 64, 40) | \
					 _GST_GET (data, 4, 64, 32) | \
					 _GST_GET (data, 3, 64, 24) | \
					 _GST_GET (data, 2, 64, 16) | \
					 _GST_GET (data, 1, 64,  8) | \
					 _GST_GET (data, 0, 64,  0))

gst_gdouble_to_guint64

#define gst_gdouble_to_guint64(value)   gst_util_gdouble_to_guint64(value)

Convert value to a guint64.

gst_guint64_to_gdouble

#define gst_guint64_to_gdouble(value)   gst_util_guint64_to_gdouble(value)

Convert value to a gdouble.

GstPluginAPIFlags

Since : 1.18

GstSearchMode

The different search modes.

GST_GROUP_ID_INVALID

#define GST_GROUP_ID_INVALID (0)

A value which is guaranteed to never be returned by gst_util_group_id_next.

Can be used as a default value in variables used to store group_id.

Since : 1.14

GST_SEQNUM_INVALID

#define GST_SEQNUM_INVALID (0)

A value which is guaranteed to never be returned by gst_util_seqnum_next.

Can be used as a default value in variables used to store seqnum.

Since : 1.14