GST_VALUE_HOLDS_FOURCC()

#define GST_VALUE_HOLDS_FOURCC(x)       (G_VALUE_HOLDS((x), gst_fourcc_get_type ()))

Checks if the given GValue contains a GST_TYPE_FOURCC value.

GST_MAKE_FOURCC()

#define GST_MAKE_FOURCC(a,b,c,d)        ((guint32)((a)|(b)<<8|(c)<<16|(d)<<24))

Transform four characters into a guint32 fourcc value with host endianness.

guint32 fourcc = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');

GST_STR_FOURCC()

#define GST_STR_FOURCC(f)               ((guint32)(((f)[0])|((f)[1]<<8)|((f)[2]<<16)|((f)[3]<<24)))

Transform an input string into a guint32 fourcc value with host endianness. Caller is responsible for ensuring the input string consists of at least four characters.

guint32 fourcc = GST_STR_FOURCC ("MJPG");

GST_FOURCC_FORMAT

#define GST_FOURCC_FORMAT "c%c%c%c"

Can be used together with GST_FOURCC_ARGS to properly output a guint32 fourcc value in a printf()-style text message.

printf ("fourcc: %" GST_FOURCC_FORMAT "\n", GST_FOURCC_ARGS (fcc));

GST_FOURCC_ARGS()

#define             GST_FOURCC_ARGS(fourcc)

Can be used together with GST_FOURCC_FORMAT to properly output a guint32 fourcc value in a printf()-style text message.

GST_TYPE_FOURCC

#define GST_TYPE_FOURCC                  gst_fourcc_get_type ()

a GValue type that represents 4 byte identifier (e.g. used for codecs)

gst_value_set_fourcc ()

void                gst_value_set_fourcc                (GValue *value,
                                                         guint32 fourcc);

Sets value to fourcc.

gst_value_get_fourcc ()

guint32             gst_value_get_fourcc                (const GValue *value);

Gets the guint32 fourcc contained in value.

GST_VALUE_HOLDS_INT_RANGE()

#define GST_VALUE_HOLDS_INT_RANGE(x)    (G_VALUE_HOLDS((x), gst_int_range_get_type ()))

Checks if the given GValue contains a GST_TYPE_INT_RANGE value.

GST_TYPE_INT_RANGE

#define GST_TYPE_INT_RANGE               gst_int_range_get_type ()

a GValue type that represents an integer range

gst_value_set_int_range ()

void                gst_value_set_int_range             (GValue *value,
                                                         gint start,
                                                         gint end);

Sets value to the range specified by start and end.

gst_value_get_int_range_min ()

gint                gst_value_get_int_range_min         (const GValue *value);

Gets the minimum of the range specified by value.

gst_value_get_int_range_max ()

gint                gst_value_get_int_range_max         (const GValue *value);

Gets the maximum of the range specified by value.

GST_VALUE_HOLDS_DOUBLE_RANGE()

#define GST_VALUE_HOLDS_DOUBLE_RANGE(x) (G_VALUE_HOLDS((x), gst_double_range_get_type ()))

Checks if the given GValue contains a GST_TYPE_DOUBLE_RANGE value.

GST_TYPE_DOUBLE_RANGE

#define GST_TYPE_DOUBLE_RANGE            gst_double_range_get_type ()

a GValue type that represents a floating point range with double precission

gst_value_set_double_range ()

void                gst_value_set_double_range          (GValue *value,
                                                         gdouble start,
                                                         gdouble end);

Sets value to the range specified by start and end.

gst_value_get_double_range_min ()

gdouble             gst_value_get_double_range_min      (const GValue *value);

Gets the minimum of the range specified by value.

gst_value_get_double_range_max ()

gdouble             gst_value_get_double_range_max      (const GValue *value);

Gets the maximum of the range specified by value.

GST_VALUE_HOLDS_LIST()

#define GST_VALUE_HOLDS_LIST(x)		(G_VALUE_HOLDS((x), gst_value_list_get_type ()))

Checks if the given GValue contains a GST_TYPE_LIST value.

GST_TYPE_LIST

#define GST_TYPE_LIST                    gst_value_list_get_type ()

a GValue type that represents an unordered list of GValue values. This is used for example to express a list of possible values for a field in a caps structure, like a list of possible sample rates, of which only one will be chosen in the end. This means that all values in the list are meaningful on their own.

GST_VALUE_HOLDS_ARRAY()

#define GST_VALUE_HOLDS_ARRAY(x)	(G_VALUE_HOLDS((x), gst_value_array_get_type ()))

Checks if the given GValue contains a GST_TYPE_ARRAY value.

GST_TYPE_ARRAY

#define GST_TYPE_ARRAY			 gst_value_array_get_type ()

a GValue type that represents an ordered list of GValue values. This is used to express a set of values that is meaningful only in their specific combination and order of values. Each value on its own is not particularly meaningful, only the ordered array in its entirety is meaningful. This is used for example to express channel layouts for multichannel audio where each channel needs to be mapped to a position in the room.

gst_value_list_append_value ()

void                gst_value_list_append_value         (GValue *value,
                                                         const GValue *append_value);

Appends append_value to the GstValueList in value.

gst_value_list_prepend_value ()

void                gst_value_list_prepend_value        (GValue *value,
                                                         const GValue *prepend_value);

Prepends prepend_value to the GstValueList in value.

gst_value_list_concat ()

void                gst_value_list_concat               (GValue *dest,
                                                         const GValue *value1,
                                                         const GValue *value2);

Concatenates copies of value1 and value2 into a list. Values that are not of type GST_TYPE_LIST are treated as if they were lists of length 1. dest will be initialized to the type GST_TYPE_LIST.

gst_value_list_get_size ()

guint               gst_value_list_get_size             (const GValue *value);

Gets the number of values contained in value.

gst_value_list_get_value ()

const GValue*       gst_value_list_get_value            (const GValue *value,
                                                         guint index);

Gets the value that is a member of the list contained in value and has the index index.

GST_VALUE_HOLDS_FRACTION()

#define GST_VALUE_HOLDS_FRACTION(x)	(G_VALUE_HOLDS((x), gst_fraction_get_type ()))

Checks if the given GValue contains a GST_TYPE_FRACTION value.

GST_TYPE_FRACTION

#define GST_TYPE_FRACTION                gst_fraction_get_type ()

a GValue type that represents a fraction of an integer numerator over an integer denominator

gst_value_set_fraction ()

void                gst_value_set_fraction              (GValue *value,
                                                         gint numerator,
                                                         gint denominator);

Sets value to the fraction specified by numerator over denominator. The fraction gets reduced to the smallest numerator and denominator, and if necessary the sign is moved to the numerator.

gst_value_get_fraction_numerator ()

gint                gst_value_get_fraction_numerator    (const GValue *value);

Gets the numerator of the fraction specified by value.

gst_value_get_fraction_denominator ()

gint                gst_value_get_fraction_denominator  (const GValue *value);

Gets the denominator of the fraction specified by value.

gst_value_fraction_multiply ()

gboolean            gst_value_fraction_multiply         (GValue *product,
                                                         const GValue *factor1,
                                                         const GValue *factor2);

Multiplies the two GValues containing a GstFraction and sets product to the product of the two fractions.

gst_value_fraction_subtract ()

gboolean            gst_value_fraction_subtract         (GValue *dest,
                                                         const GValue *minuend,
                                                         const GValue *subtrahend);

Subtracts the subtrahend from the minuend and sets dest to the result.

GST_VALUE_HOLDS_FRACTION_RANGE()

#define GST_VALUE_HOLDS_FRACTION_RANGE(x)    (G_VALUE_HOLDS((x), gst_fraction_range_get_type ()))

Checks if the given GValue contains a GST_TYPE_FRACTION_RANGE value.

GST_TYPE_FRACTION_RANGE

#define GST_TYPE_FRACTION_RANGE            gst_fraction_range_get_type ()

a GValue type that represents a GstFraction range

gst_value_set_fraction_range ()

void                gst_value_set_fraction_range        (GValue *value,
                                                         const GValue *start,
                                                         const GValue *end);

Sets value to the range specified by start and end.

gst_value_get_fraction_range_min ()

const GValue*       gst_value_get_fraction_range_min    (const GValue *value);

Gets the minimum of the range specified by value.

gst_value_get_fraction_range_max ()

const GValue*       gst_value_get_fraction_range_max    (const GValue *value);

Gets the maximum of the range specified by value.

gst_value_set_fraction_range_full ()

void                gst_value_set_fraction_range_full   (GValue *value,
                                                         gint numerator_start,
                                                         gint denominator_start,
                                                         gint numerator_end,
                                                         gint denominator_end);

Sets value to the range specified by numerator_start/denominator_start and numerator_end/denominator_end.

GST_VALUE_HOLDS_DATE()

#define GST_VALUE_HOLDS_DATE(x)         (G_VALUE_HOLDS((x), gst_date_get_type ()))

Checks if the given GValue contains a GST_TYPE_DATE value.

GST_TYPE_DATE

#define GST_TYPE_DATE                    gst_date_get_type ()

a boxed GValue type for GDate that represents a date.

gst_value_set_date ()

void                gst_value_set_date                  (GValue *value,
                                                         const GDate *date);

Sets the contents of value to coorespond to date. The actual GDate structure is copied before it is used.

gst_value_get_date ()

const GDate*        gst_value_get_date                  (const GValue *value);

Gets the contents of value.

GST_VALUE_HOLDS_CAPS()

#define GST_VALUE_HOLDS_CAPS(x)		(G_VALUE_HOLDS((x), GST_TYPE_CAPS))

Checks if the given GValue contains a GST_TYPE_CAPS value.

gst_value_set_caps ()

void                gst_value_set_caps                  (GValue *value,
                                                         const GstCaps *caps);

Sets the contents of value to caps. The actual GstCaps structure is copied before it is used.

gst_value_get_caps ()

const GstCaps*      gst_value_get_caps                  (const GValue *value);

Gets the contents of value.

GST_VALUE_HOLDS_STRUCTURE()

#define GST_VALUE_HOLDS_STRUCTURE(x)		(G_VALUE_HOLDS((x), GST_TYPE_STRUCTURE))

Checks if the given GValue contains a GST_TYPE_STRUCTURE value.

Since 0.10.15

gst_value_set_structure ()

void                gst_value_set_structure             (GValue *value,
                                                         const GstStructure *structure);

Sets the contents of value to structure. The actual

Since 0.10.15

gst_value_get_structure ()

const GstStructure* gst_value_get_structure             (const GValue *value);

Gets the contents of value.

Since 0.10.15

GST_VALUE_HOLDS_MINI_OBJECT()

#define GST_VALUE_HOLDS_MINI_OBJECT(value)  (G_VALUE_HOLDS(value, GST_TYPE_MINI_OBJECT))

Checks if the given GValue contains a GST_TYPE_MINI_OBJECT value.

GST_VALUE_HOLDS_BUFFER()

#define GST_VALUE_HOLDS_BUFFER(x)       (G_VALUE_HOLDS((x), GST_TYPE_BUFFER))

Checks if the given GValue contains a GST_TYPE_BUFFER value.

gst_value_get_buffer()

#define         gst_value_get_buffer(v)         GST_BUFFER_CAST (gst_value_get_mini_object(v))

Receives a GstBuffer as the value of v. Does not return a reference to the buffer, so the pointer is only valid for as long as the caller owns a reference to v.

gst_value_set_buffer()

#define         gst_value_set_buffer(v,b)       gst_value_set_mini_object(v, GST_MINI_OBJECT_CAST(b))

Sets b as the value of v. Caller retains reference to buffer.

gst_value_take_buffer()

#define         gst_value_take_buffer(v,b)      gst_value_take_mini_object(v, GST_MINI_OBJECT_CAST(b))

Sets b as the value of v. Caller gives away reference to buffer.

GST_VALUE_LESS_THAN

#define GST_VALUE_LESS_THAN              (-1)

Indicates that the first value provided to a comparison function (gst_value_compare()) is lesser than the second one.

GST_VALUE_EQUAL

#define GST_VALUE_EQUAL                   0

Indicates that the first value provided to a comparison function (gst_value_compare()) is equal to the second one.

GST_VALUE_GREATER_THAN

#define GST_VALUE_GREATER_THAN            1

Indicates that the first value provided to a comparison function (gst_value_compare()) is greater than the second one.

GST_VALUE_UNORDERED

#define GST_VALUE_UNORDERED               2

Indicates that the comparison function (gst_value_compare()) can not determine a order for the two provided values.

GstValueCompareFunc ()

gint                (*GstValueCompareFunc)              (const GValue *value1,
                                                         const GValue *value2);

Used together with gst_value_compare() to compare GValues.

GstValueSerializeFunc ()

gchar*              (*GstValueSerializeFunc)            (const GValue *value1);

Used by gst_value_serialize() to obtain a non-binary form of the GValue.

GstValueDeserializeFunc ()

gboolean            (*GstValueDeserializeFunc)          (GValue *dest,
                                                         const gchar *s);

Used by gst_value_deserialize() to parse a non-binary form into the GValue.

GstValueUnionFunc ()

gboolean            (*GstValueUnionFunc)                (GValue *dest,
                                                         const GValue *value1,
                                                         const GValue *value2);

Used by gst_value_union() to perform unification for a specific GValue type. Register a new implementation with gst_value_register_union_func().

GstValueIntersectFunc ()

gboolean            (*GstValueIntersectFunc)            (GValue *dest,
                                                         const GValue *value1,
                                                         const GValue *value2);

Used by gst_value_intersect() to perform intersection for a specific GValue type. If the intersection is non-empty, the result is placed in dest and TRUE is returned. If the intersection is empty, dest is unmodified and FALSE is returned. Register a new implementation with gst_value_register_intersection_func().

GstValueSubtractFunc ()

gboolean            (*GstValueSubtractFunc)             (GValue *dest,
                                                         const GValue *minuend,
                                                         const GValue *subtrahend);

Used by gst_value_subtract() to perform subtraction for a specific GValue type. Register a new implementation with gst_value_register_subtract_func().

GstValueTable

typedef struct {
  GType type;
  GstValueCompareFunc compare;
  GstValueSerializeFunc serialize;
  GstValueDeserializeFunc deserialize;
} GstValueTable;

VTable for the GValue type.

gst_value_is_fixed ()

gboolean            gst_value_is_fixed                  (const GValue *value);

Tests if the given GValue, if available in a GstStructure (or any other container) contains a "fixed" (which means: one value) or an "unfixed" (which means: multiple possible values, such as data lists or data ranges) value.

gst_value_register ()

void                gst_value_register                  (const GstValueTable *table);

Registers functions to perform calculations on GValues of a given type. Each type can only be added once.

gst_value_init_and_copy ()

void                gst_value_init_and_copy             (GValue *dest,
                                                         const GValue *src);

Initialises the target value to be of the same type as source and then copies the contents from source to target.

gst_value_serialize ()

gchar*              gst_value_serialize                 (const GValue *value);

tries to transform the given value into a string representation that allows getting back this string later on using gst_value_deserialize().

gst_value_deserialize ()

gboolean            gst_value_deserialize               (GValue *dest,
                                                         const gchar *src);

Tries to deserialize a string into the type specified by the given GValue. If the operation succeeds, TRUE is returned, FALSE otherwise.

gst_value_compare ()

gint                gst_value_compare                   (const GValue *value1,
                                                         const GValue *value2);

Compares value1 and value2. If value1 and value2 cannot be compared, the function returns GST_VALUE_UNORDERED. Otherwise, if value1 is greater than value2, GST_VALUE_GREATER_THAN is returned. If value1 is less than value2, GST_VALUE_LESS_THAN is returned. If the values are equal, GST_VALUE_EQUAL is returned.

gst_value_can_compare ()

gboolean            gst_value_can_compare               (const GValue *value1,
                                                         const GValue *value2);

Determines if value1 and value2 can be compared.

gst_value_union ()

gboolean            gst_value_union                     (GValue *dest,
                                                         const GValue *value1,
                                                         const GValue *value2);

Creates a GValue corresponding to the union of value1 and value2.

gst_value_can_union ()

gboolean            gst_value_can_union                 (const GValue *value1,
                                                         const GValue *value2);

Determines if value1 and value2 can be non-trivially unioned. Any two values can be trivially unioned by adding both of them to a GstValueList. However, certain types have the possibility to be unioned in a simpler way. For example, an integer range and an integer can be unioned if the integer is a subset of the integer range. If there is the possibility that two values can be unioned, this function returns TRUE.

gst_value_register_union_func ()

void                gst_value_register_union_func       (GType type1,
                                                         GType type2,
                                                         GstValueUnionFunc func);

Registers a union function that can create a union between GValues of the type type1 and type2.

Union functions should be registered at startup before any pipelines are started, as gst_value_register_union_func() is not thread-safe and cannot be used at the same time as gst_value_union() or gst_value_can_union().

gst_value_subtract ()

gboolean            gst_value_subtract                  (GValue *dest,
                                                         const GValue *minuend,
                                                         const GValue *subtrahend);

Subtracts subtrahend from minuend and stores the result in dest. Note that this means subtraction as in sets, not as in mathematics.

gst_value_can_subtract ()

gboolean            gst_value_can_subtract              (const GValue *minuend,
                                                         const GValue *subtrahend);

Checks if it's possible to subtract subtrahend from minuend.

gst_value_register_subtract_func ()

void                gst_value_register_subtract_func    (GType minuend_type,
                                                         GType subtrahend_type,
                                                         GstValueSubtractFunc func);

Registers func as a function capable of subtracting the values of subtrahend_type from values of minuend_type.

Subtract functions should be registered at startup before any pipelines are started, as gst_value_register_subtract_func() is not thread-safe and cannot be used at the same time as gst_value_subtract().

gst_value_intersect ()

gboolean            gst_value_intersect                 (GValue *dest,
                                                         const GValue *value1,
                                                         const GValue *value2);

Calculates the intersection of two values. If the values have a non-empty intersection, the value representing the intersection is placed in dest. If the intersection is non-empty, dest is not modified.

gst_value_can_intersect ()

gboolean            gst_value_can_intersect             (const GValue *value1,
                                                         const GValue *value2);

Determines if intersecting two values will produce a valid result. Two values will produce a valid intersection if they have the same type, or if there is a method (registered by gst_value_register_intersection_func()) to calculate the intersection.

gst_value_register_intersect_func ()

void                gst_value_register_intersect_func   (GType type1,
                                                         GType type2,
                                                         GstValueIntersectFunc func);

Registers a function that is called to calculate the intersection of the values having the types type1 and type2.

Intersect functions should be registered at startup before any pipelines are started, as gst_value_register_intersect_func() is not thread-safe and cannot be used at the same time as gst_value_intersect() or gst_value_can_intersect().

gst_value_array_append_value ()

void                gst_value_array_append_value        (GValue *value,
                                                         const GValue *append_value);

Appends append_value to the GstValueArray in value.

gst_value_array_get_size ()

guint               gst_value_array_get_size            (const GValue *value);

Gets the number of values contained in value.

gst_value_array_get_value ()

const GValue*       gst_value_array_get_value           (const GValue *value,
                                                         guint index);

Gets the value that is a member of the array contained in value and has the index index.

gst_value_array_prepend_value ()

void                gst_value_array_prepend_value       (GValue *value,
                                                         const GValue *prepend_value);

Prepends prepend_value to the GstValueArray in value.