# GstValue

GValue implementations specific to GStreamer.

Note that operations on the same GValue from multiple threads may lead to undefined behaviour.

## GstBitmask

A fundamental type that describes a 64-bit bitmask

## Gst.Bitmask

A fundamental type that describes a 64-bit bitmask

## Gst.Bitmask

A fundamental type that describes a 64-bit bitmask

## GstDoubleRange

A fundamental type that describes a gdouble range

## Gst.DoubleRange

A fundamental type that describes a Number range

## Gst.DoubleRange

A fundamental type that describes a float range

## GstFlagSet

A fundamental type that describes a 32-bit flag bitfield, with 32-bit mask indicating which of the bits in the field are explicitly set.

## Gst.FlagSet

A fundamental type that describes a 32-bit flag bitfield, with 32-bit mask indicating which of the bits in the field are explicitly set.

## Gst.FlagSet

A fundamental type that describes a 32-bit flag bitfield, with 32-bit mask indicating which of the bits in the field are explicitly set.

### Functions

#### gst_flagset_register

    GType
    gst_flagset_register (GType flags_type)

Create a new sub-class of GST_TYPE_FLAG_SET which will pretty-print the human-readable flags when serializing, for easier debugging.

Parameters:

`flags_type` –

a GType of a G_TYPE_FLAGS type.

Returns –
No description available

Since : 1.6

#### Gst.FlagSet.prototype.register

    function Gst.FlagSet.prototype.register(flags_type: GObject.Type): {
        // javascript wrapper for 'gst_flagset_register'
    }

Create a new sub-class of GST_TYPE_FLAG_SET (not introspectable) which will pretty-print the human-readable flags when serializing, for easier debugging.

Parameters:

`flags_type` (GObject.Type) –

a GObject.Type of a G_TYPE_FLAGS (not introspectable) type.

Returns (GObject.Type) –
No description available

Since : 1.6

#### Gst.FlagSet.register

    def Gst.FlagSet.register (flags_type):
        #python wrapper for 'gst_flagset_register'

Create a new sub-class of GST_TYPE_FLAG_SET (not introspectable) which will pretty-print the human-readable flags when serializing, for easier debugging.

Parameters:

`flags_type` (GObject.Type) –

a GObject.Type of a G_TYPE_FLAGS (not introspectable) type.

Returns (GObject.Type) –
No description available

Since : 1.6

## GstFraction

A fundamental type that describes a fraction of an integer numerator over an integer denominator

## Gst.Fraction

A fundamental type that describes a fraction of an integer numerator over an integer denominator

## Gst.Fraction

A fundamental type that describes a fraction of an integer numerator over an integer denominator

## GstFractionRange

A fundamental type that describes a GstFractionRange range

## Gst.FractionRange

A fundamental type that describes a Gst.FractionRange range

## Gst.FractionRange

A fundamental type that describes a Gst.FractionRange range

## GstInt64Range

A fundamental type that describes a gint64 range

## Gst.Int64Range

A fundamental type that describes a Number range

## Gst.Int64Range

A fundamental type that describes a int range

## GstIntRange

A fundamental type that describes a gint range

## Gst.IntRange

A fundamental type that describes a Number range

## Gst.IntRange

A fundamental type that describes a int range

## GstValueArray

A fundamental type that describes an ordered list of GValue

## Gst.ValueArray

A fundamental type that describes an ordered list of GObject.Value

## Gst.ValueArray

A fundamental type that describes an ordered list of GObject.Value

### Functions

#### gst_value_array_append_and_take_value

    gst_value_array_append_and_take_value (GValue * value,
                                           GValue * append_value)

Appends append_value to the GstValueArray in value.

Parameters:

`value` –

a GValue of type GST_TYPE_ARRAY

`append_value` ( [transfer: full]) –

the value to append

Since : 1.2

#### Gst.ValueArray.prototype.append_and_take_value

    function Gst.ValueArray.prototype.append_and_take_value(value: GObject.Value, append_value: GObject.Value): {
        // javascript wrapper for 'gst_value_array_append_and_take_value'
    }

Appends append_value to the GstValueArray in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`append_value` (GObject.Value) –

the value to append

Since : 1.2

#### Gst.ValueArray.append_and_take_value

    def Gst.ValueArray.append_and_take_value (value, append_value):
        #python wrapper for 'gst_value_array_append_and_take_value'

Appends append_value to the GstValueArray in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`append_value` (GObject.Value) –

the value to append

Since : 1.2

#### gst_value_array_append_value

    gst_value_array_append_value (GValue * value,
                                  const GValue * append_value)

Appends append_value to the GstValueArray in value.

Parameters:

`value` –

a GValue of type GST_TYPE_ARRAY

`append_value` –

the value to append

#### Gst.ValueArray.prototype.append_value

    function Gst.ValueArray.prototype.append_value(value: GObject.Value, append_value: GObject.Value): {
        // javascript wrapper for 'gst_value_array_append_value'
    }

Appends append_value to the GstValueArray in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`append_value` (GObject.Value) –

the value to append

#### Gst.ValueArray.append_value

    def Gst.ValueArray.append_value (value, append_value):
        #python wrapper for 'gst_value_array_append_value'

Appends append_value to the GstValueArray in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`append_value` (GObject.Value) –

the value to append

#### gst_value_array_get_size

    guint
    gst_value_array_get_size (const GValue * value)

Gets the number of values contained in value.

Parameters:

`value` –

a GValue of type GST_TYPE_ARRAY

Returns –

the number of values

#### Gst.ValueArray.prototype.get_size

    function Gst.ValueArray.prototype.get_size(value: GObject.Value): {
        // javascript wrapper for 'gst_value_array_get_size'
    }

Gets the number of values contained in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

Returns (Number) –

the number of values

#### Gst.ValueArray.get_size

    def Gst.ValueArray.get_size (value):
        #python wrapper for 'gst_value_array_get_size'

Gets the number of values contained in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

Returns (int) –

the number of values

#### 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.

Parameters:

`value` –

a GValue of type GST_TYPE_ARRAY

`index` –

index of value to get from the array

Returns ( [transfer: none]) –

the value at the given index

#### Gst.ValueArray.prototype.get_value

    function Gst.ValueArray.prototype.get_value(value: GObject.Value, index: Number): {
        // javascript wrapper for 'gst_value_array_get_value'
    }

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

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`index` (Number) –

index of value to get from the array

Returns (GObject.Value) –

the value at the given index

#### Gst.ValueArray.get_value

    def Gst.ValueArray.get_value (value, index):
        #python wrapper for 'gst_value_array_get_value'

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

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`index` (int) –

index of value to get from the array

Returns (GObject.Value) –

the value at the given index

#### gst_value_array_init

    GValue *
    gst_value_array_init (GValue * value,
                          guint prealloc)

Initializes and pre-allocates a GValue of type GST_TYPE_ARRAY.

Parameters:

`value` –

A zero-filled (uninitialized) GValue structure

`prealloc` –

The number of entries to pre-allocate in the array

Returns ( [transfer: none]) –

The GValue structure that has been passed in

Since : 1.18

#### Gst.ValueArray.prototype.init

    function Gst.ValueArray.prototype.init(value: GObject.Value, prealloc: Number): {
        // javascript wrapper for 'gst_value_array_init'
    }

Initializes and pre-allocates a GObject.Value of type GST_TYPE_ARRAY (not introspectable).

Parameters:

`value` (GObject.Value) –

A zero-filled (uninitialized) GObject.Value structure

`prealloc` (Number) –

The number of entries to pre-allocate in the array

Returns (GObject.Value) –

The GObject.Value structure that has been passed in

Since : 1.18

#### Gst.ValueArray.init

    def Gst.ValueArray.init (value, prealloc):
        #python wrapper for 'gst_value_array_init'

Initializes and pre-allocates a GObject.Value of type GST_TYPE_ARRAY (not introspectable).

Parameters:

`value` (GObject.Value) –

A zero-filled (uninitialized) GObject.Value structure

`prealloc` (int) –

The number of entries to pre-allocate in the array

Returns (GObject.Value) –

The GObject.Value structure that has been passed in

Since : 1.18

#### gst_value_array_prepend_value

    gst_value_array_prepend_value (GValue * value,
                                   const GValue * prepend_value)

Prepends prepend_value to the GstValueArray in value.

Parameters:

`value` –

a GValue of type GST_TYPE_ARRAY

`prepend_value` –

the value to prepend

#### Gst.ValueArray.prototype.prepend_value

    function Gst.ValueArray.prototype.prepend_value(value: GObject.Value, prepend_value: GObject.Value): {
        // javascript wrapper for 'gst_value_array_prepend_value'
    }

Prepends prepend_value to the GstValueArray in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`prepend_value` (GObject.Value) –

the value to prepend

#### Gst.ValueArray.prepend_value

    def Gst.ValueArray.prepend_value (value, prepend_value):
        #python wrapper for 'gst_value_array_prepend_value'

Prepends prepend_value to the GstValueArray in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_ARRAY (not introspectable)

`prepend_value` (GObject.Value) –

the value to prepend

## GstValueList

A fundamental type that describes an unordered list of GValue

## Gst.ValueList

A fundamental type that describes an unordered list of GObject.Value

## Gst.ValueList

A fundamental type that describes an unordered list of GObject.Value

### Functions

#### gst_value_list_append_and_take_value

    gst_value_list_append_and_take_value (GValue * value,
                                          GValue * append_value)

Appends append_value to the GstValueList in value.

Parameters:

`value` –

a GValue of type GST_TYPE_LIST

`append_value` ( [transfer: full]) –

the value to append

Since : 1.2

#### Gst.ValueList.prototype.append_and_take_value

    function Gst.ValueList.prototype.append_and_take_value(value: GObject.Value, append_value: GObject.Value): {
        // javascript wrapper for 'gst_value_list_append_and_take_value'
    }

Appends append_value to the GstValueList in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`append_value` (GObject.Value) –

the value to append

Since : 1.2

#### Gst.ValueList.append_and_take_value

    def Gst.ValueList.append_and_take_value (value, append_value):
        #python wrapper for 'gst_value_list_append_and_take_value'

Appends append_value to the GstValueList in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`append_value` (GObject.Value) –

the value to append

Since : 1.2

#### gst_value_list_append_value

    gst_value_list_append_value (GValue * value,
                                 const GValue * append_value)

Appends append_value to the GstValueList in value.

Parameters:

`value` –

a GValue of type GST_TYPE_LIST

`append_value` ( [transfer: none]) –

the value to append

#### Gst.ValueList.prototype.append_value

    function Gst.ValueList.prototype.append_value(value: GObject.Value, append_value: GObject.Value): {
        // javascript wrapper for 'gst_value_list_append_value'
    }

Appends append_value to the GstValueList in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`append_value` (GObject.Value) –

the value to append

#### Gst.ValueList.append_value

    def Gst.ValueList.append_value (value, append_value):
        #python wrapper for 'gst_value_list_append_value'

Appends append_value to the GstValueList in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`append_value` (GObject.Value) –

the value to append

#### gst_value_list_concat

    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.

Parameters:

`dest` ( [out]) –

an uninitialized GValue to take the result

`value1` –

a GValue

`value2` –

a GValue

#### Gst.ValueList.prototype.concat

    function Gst.ValueList.prototype.concat(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_list_concat'
    }

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

Parameters:

`value1` (GObject.Value) –

a GObject.Value

`value2` (GObject.Value) –

a GObject.Value

#### Gst.ValueList.concat

    def Gst.ValueList.concat (value1, value2):
        #python wrapper for 'gst_value_list_concat'

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

Parameters:

`value1` (GObject.Value) –

a GObject.Value

`value2` (GObject.Value) –

a GObject.Value

#### gst_value_list_get_size

    guint
    gst_value_list_get_size (const GValue * value)

Gets the number of values contained in value.

Parameters:

`value` –

a GValue of type GST_TYPE_LIST

Returns –

the number of values

#### Gst.ValueList.prototype.get_size

    function Gst.ValueList.prototype.get_size(value: GObject.Value): {
        // javascript wrapper for 'gst_value_list_get_size'
    }

Gets the number of values contained in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

Returns (Number) –

the number of values

#### Gst.ValueList.get_size

    def Gst.ValueList.get_size (value):
        #python wrapper for 'gst_value_list_get_size'

Gets the number of values contained in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

Returns (int) –

the number of values

#### 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.

Parameters:

`value` –

a GValue of type GST_TYPE_LIST

`index` –

index of value to get from the list

Returns ( [transfer: none]) –

the value at the given index

#### Gst.ValueList.prototype.get_value

    function Gst.ValueList.prototype.get_value(value: GObject.Value, index: Number): {
        // javascript wrapper for 'gst_value_list_get_value'
    }

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

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`index` (Number) –

index of value to get from the list

Returns (GObject.Value) –

the value at the given index

#### Gst.ValueList.get_value

    def Gst.ValueList.get_value (value, index):
        #python wrapper for 'gst_value_list_get_value'

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

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`index` (int) –

index of value to get from the list

Returns (GObject.Value) –

the value at the given index

#### gst_value_list_init

    GValue *
    gst_value_list_init (GValue * value,
                         guint prealloc)

Initializes and pre-allocates a GValue of type GST_TYPE_LIST.

Parameters:

`value` –

A zero-filled (uninitialized) GValue structure

`prealloc` –

The number of entries to pre-allocate in the list

Returns ( [transfer: none]) –

The GValue structure that has been passed in

Since : 1.18

#### Gst.ValueList.prototype.init

    function Gst.ValueList.prototype.init(value: GObject.Value, prealloc: Number): {
        // javascript wrapper for 'gst_value_list_init'
    }

Initializes and pre-allocates a GObject.Value of type GST_TYPE_LIST (not introspectable).

Parameters:

`value` (GObject.Value) –

A zero-filled (uninitialized) GObject.Value structure

`prealloc` (Number) –

The number of entries to pre-allocate in the list

Returns (GObject.Value) –

The GObject.Value structure that has been passed in

Since : 1.18

#### Gst.ValueList.init

    def Gst.ValueList.init (value, prealloc):
        #python wrapper for 'gst_value_list_init'

Initializes and pre-allocates a GObject.Value of type GST_TYPE_LIST (not introspectable).

Parameters:

`value` (GObject.Value) –

A zero-filled (uninitialized) GObject.Value structure

`prealloc` (int) –

The number of entries to pre-allocate in the list

Returns (GObject.Value) –

The GObject.Value structure that has been passed in

Since : 1.18

#### gst_value_list_merge

    gst_value_list_merge (GValue * dest,
                          const GValue * value1,
                          const GValue * value2)

Merges copies of value1 and value2. Values that are not of type GST_TYPE_LIST are treated as if they were lists of length 1.

The result will be put into dest and will either be a list that will not contain any duplicates, or a non-list type (if value1 and value2 were equal).

Parameters:

`dest` ( [out]) –

an uninitialized GValue to take the result

`value1` –

a GValue

`value2` –

a GValue

#### Gst.ValueList.prototype.merge

    function Gst.ValueList.prototype.merge(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_list_merge'
    }

Merges copies of value1 and value2. Values that are not of type GST_TYPE_LIST (not introspectable) are treated as if they were lists of length 1.

The result will be put into dest and will either be a list that will not contain any duplicates, or a non-list type (if value1 and value2 were equal).

Parameters:

`value1` (GObject.Value) –

a GObject.Value

`value2` (GObject.Value) –

a GObject.Value

#### Gst.ValueList.merge

    def Gst.ValueList.merge (value1, value2):
        #python wrapper for 'gst_value_list_merge'

Merges copies of value1 and value2. Values that are not of type GST_TYPE_LIST (not introspectable) are treated as if they were lists of length 1.

The result will be put into dest and will either be a list that will not contain any duplicates, or a non-list type (if value1 and value2 were equal).

Parameters:

`value1` (GObject.Value) –

a GObject.Value

`value2` (GObject.Value) –

a GObject.Value

#### gst_value_list_prepend_value

    gst_value_list_prepend_value (GValue * value,
                                  const GValue * prepend_value)

Prepends prepend_value to the GstValueList in value.

Parameters:

`value` –

a GValue of type GST_TYPE_LIST

`prepend_value` –

the value to prepend

#### Gst.ValueList.prototype.prepend_value

    function Gst.ValueList.prototype.prepend_value(value: GObject.Value, prepend_value: GObject.Value): {
        // javascript wrapper for 'gst_value_list_prepend_value'
    }

Prepends prepend_value to the GstValueList in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`prepend_value` (GObject.Value) –

the value to prepend

#### Gst.ValueList.prepend_value

    def Gst.ValueList.prepend_value (value, prepend_value):
        #python wrapper for 'gst_value_list_prepend_value'

Prepends prepend_value to the GstValueList in value.

Parameters:

`value` (GObject.Value) –

a GObject.Value of type GST_TYPE_LIST (not introspectable)

`prepend_value` (GObject.Value) –

the value to prepend

## GstValueTable

VTable for the GValue type.

### Members

`type` (GType) –

a GType

`compare` (GstValueCompareFunc) –

a GstValueCompareFunc

`serialize` (GstValueSerializeFunc) –

a GstValueSerializeFunc

`deserialize` (GstValueDeserializeFunc) –

a GstValueDeserializeFunc

`deserialize_with_pspec` (GstValueDeserializeWithPSpecFunc) –

a GstValueDeserializeWithPSpecFunc

## Gst.ValueTable

VTable for the GObject.Value type.

### Members

`type` (GObject.Type) –

a GObject.Type

`compare` (Gst.ValueCompareFunc) –

a Gst.ValueCompareFunc

`serialize` (Gst.ValueSerializeFunc) –

a Gst.ValueSerializeFunc

`deserialize` (Gst.ValueDeserializeFunc) –

a Gst.ValueDeserializeFunc

`deserialize_with_pspec` (Gst.ValueDeserializeWithPSpecFunc) –

a Gst.ValueDeserializeWithPSpecFunc

## Gst.ValueTable

VTable for the GObject.Value type.

### Members

`type` (GObject.Type) –

a GObject.Type

`compare` (Gst.ValueCompareFunc) –

a Gst.ValueCompareFunc

`serialize` (Gst.ValueSerializeFunc) –

a Gst.ValueSerializeFunc

`deserialize` (Gst.ValueDeserializeFunc) –

a Gst.ValueDeserializeFunc

`deserialize_with_pspec` (Gst.ValueDeserializeWithPSpecFunc) –

a Gst.ValueDeserializeWithPSpecFunc

## Functions

### gst_value_can_compare

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

Determines if value1 and value2 can be compared.

Parameters:

`value1` –

a value to compare

`value2` –

another value to compare

Returns –

TRUE if the values can be compared

### Gst.prototype.value_can_compare

    function Gst.prototype.value_can_compare(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_can_compare'
    }

Determines if value1 and value2 can be compared.

Parameters:

`value1` (GObject.Value) –

a value to compare

`value2` (GObject.Value) –

another value to compare

Returns (Number) –

true if the values can be compared

### Gst.value_can_compare

    def Gst.value_can_compare (value1, value2):
        #python wrapper for 'gst_value_can_compare'

Determines if value1 and value2 can be compared.

Parameters:

`value1` (GObject.Value) –

a value to compare

`value2` (GObject.Value) –

another value to compare

Returns (bool) –

True if the values can be compared

### 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.

Parameters:

`value1` –

a value to intersect

`value2` –

another value to intersect

Returns –

TRUE if the values can intersect

### Gst.prototype.value_can_intersect

    function Gst.prototype.value_can_intersect(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_can_intersect'
    }

Determines if intersecting two values will produce a valid result. Two values will produce a valid intersection if they have the same type.

Parameters:

`value1` (GObject.Value) –

a value to intersect

`value2` (GObject.Value) –

another value to intersect

Returns (Number) –

true if the values can intersect

### Gst.value_can_intersect

    def Gst.value_can_intersect (value1, value2):
        #python wrapper for 'gst_value_can_intersect'

Determines if intersecting two values will produce a valid result. Two values will produce a valid intersection if they have the same type.

Parameters:

`value1` (GObject.Value) –

a value to intersect

`value2` (GObject.Value) –

another value to intersect

Returns (bool) –

True if the values can intersect

### 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.

Parameters:

`minuend` –

the value to subtract from

`subtrahend` –

the value to subtract

Returns –

TRUE if a subtraction is possible

### Gst.prototype.value_can_subtract

    function Gst.prototype.value_can_subtract(minuend: GObject.Value, subtrahend: GObject.Value): {
        // javascript wrapper for 'gst_value_can_subtract'
    }

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

Parameters:

`minuend` (GObject.Value) –

the value to subtract from

`subtrahend` (GObject.Value) –

the value to subtract

Returns (Number) –

true if a subtraction is possible

### Gst.value_can_subtract

    def Gst.value_can_subtract (minuend, subtrahend):
        #python wrapper for 'gst_value_can_subtract'

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

Parameters:

`minuend` (GObject.Value) –

the value to subtract from

`subtrahend` (GObject.Value) –

the value to subtract

Returns (bool) –

True if a subtraction is possible

### 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.

Parameters:

`value1` –

a value to union

`value2` –

another value to union

Returns –

TRUE if there is a function allowing the two values to be unioned.

### Gst.prototype.value_can_union

    function Gst.prototype.value_can_union(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_can_union'
    }

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.

Parameters:

`value1` (GObject.Value) –

a value to union

`value2` (GObject.Value) –

another value to union

Returns (Number) –

true if there is a function allowing the two values to be unioned.

### Gst.value_can_union

    def Gst.value_can_union (value1, value2):
        #python wrapper for 'gst_value_can_union'

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.

Parameters:

`value1` (GObject.Value) –

a value to union

`value2` (GObject.Value) –

another value to union

Returns (bool) –

True if there is a function allowing the two values to be unioned.

### 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.

Parameters:

`value1` –

a value to compare

`value2` –

another value to compare

Returns –

comparison result

### Gst.prototype.value_compare

    function Gst.prototype.value_compare(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_compare'
    }

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.

Parameters:

`value1` (GObject.Value) –

a value to compare

`value2` (GObject.Value) –

another value to compare

Returns (Number) –

comparison result

### Gst.value_compare

    def Gst.value_compare (value1, value2):
        #python wrapper for 'gst_value_compare'

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.

Parameters:

`value1` (GObject.Value) –

a value to compare

`value2` (GObject.Value) –

another value to compare

Returns (int) –

comparison result

### 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.

Parameters:

`dest` ( [out]) –

GValue to fill with contents of deserialization

`src` –

string to deserialize

Returns –

TRUE on success

### Gst.prototype.value_deserialize

    function Gst.prototype.value_deserialize(src: String): {
        // javascript wrapper for 'gst_value_deserialize'
    }

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

Parameters:

`src` (String) –

string to deserialize

Returns a tuple made of:

(Number ) –

true on success

`dest` (GObject.Value ) –

true on success

### Gst.value_deserialize

    def Gst.value_deserialize (src):
        #python wrapper for 'gst_value_deserialize'

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

Parameters:

`src` (str) –

string to deserialize

Returns a tuple made of:

(bool ) –

True on success

`dest` (GObject.Value ) –

True on success

### gst_value_deserialize_with_pspec

    gboolean
    gst_value_deserialize_with_pspec (GValue * dest,
                                      const gchar * src,
                                      GParamSpec * pspec)

Tries to deserialize a string into the type specified by the given GValue. pspec may be used to guide the deserializing of nested members. If the operation succeeds, TRUE is returned, FALSE otherwise.

Parameters:

`dest` ( [out]) –

GValue to fill with contents of deserialization

`src` –

string to deserialize

`pspec` ( [nullable]) –

the GParamSpec describing the expected value

Returns –

TRUE on success

Since : 1.20

### Gst.prototype.value_deserialize_with_pspec

    function Gst.prototype.value_deserialize_with_pspec(src: String, pspec: GObject.ParamSpec): {
        // javascript wrapper for 'gst_value_deserialize_with_pspec'
    }

Tries to deserialize a string into the type specified by the given GValue. pspec may be used to guide the deserializing of nested members. If the operation succeeds, true is returned, false otherwise.

Parameters:

`src` (String) –

string to deserialize

`pspec` (GObject.ParamSpec) –

the GObject.ParamSpec describing the expected value

Returns a tuple made of:

(Number ) –

true on success

`dest` (GObject.Value ) –

true on success

Since : 1.20

### Gst.value_deserialize_with_pspec

    def Gst.value_deserialize_with_pspec (src, pspec):
        #python wrapper for 'gst_value_deserialize_with_pspec'

Tries to deserialize a string into the type specified by the given GValue. pspec may be used to guide the deserializing of nested members. If the operation succeeds, True is returned, False otherwise.

Parameters:

`src` (str) –

string to deserialize

`pspec` (GObject.ParamSpec) –

the GObject.ParamSpec describing the expected value

Returns a tuple made of:

(bool ) –

True on success

`dest` (GObject.Value ) –

True on success

Since : 1.20

### gst_value_fixate

    gboolean
    gst_value_fixate (GValue * dest,
                      const GValue * src)

Fixate src into a new value dest. For ranges, the first element is taken. For lists and arrays, the first item is fixated and returned. If src is already fixed, this function returns FALSE.

Parameters:

`dest` –

the GValue destination

`src` –

the GValue to fixate

Returns –

TRUE if dest contains a fixated version of src.

### Gst.prototype.value_fixate

    function Gst.prototype.value_fixate(dest: GObject.Value, src: GObject.Value): {
        // javascript wrapper for 'gst_value_fixate'
    }

Fixate src into a new value dest. For ranges, the first element is taken. For lists and arrays, the first item is fixated and returned. If src is already fixed, this function returns false.

Parameters:

`dest` (GObject.Value) –

the GObject.Value destination

`src` (GObject.Value) –

the GObject.Value to fixate

Returns (Number) –

true if dest contains a fixated version of src.

### Gst.value_fixate

    def Gst.value_fixate (dest, src):
        #python wrapper for 'gst_value_fixate'

Fixate src into a new value dest. For ranges, the first element is taken. For lists and arrays, the first item is fixated and returned. If src is already fixed, this function returns False.

Parameters:

`dest` (GObject.Value) –

the GObject.Value destination

`src` (GObject.Value) –

the GObject.Value to fixate

Returns (bool) –

True if dest contains a fixated version of src.

### gst_value_fraction_multiply

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

Multiplies the two GValue items containing a GST_TYPE_FRACTION and sets product to the product of the two fractions.

Parameters:

`product` –

a GValue initialized to GST_TYPE_FRACTION

`factor1` –

a GValue initialized to GST_TYPE_FRACTION

`factor2` –

a GValue initialized to GST_TYPE_FRACTION

Returns –

FALSE in case of an error (like integer overflow), TRUE otherwise.

### Gst.prototype.value_fraction_multiply

    function Gst.prototype.value_fraction_multiply(product: GObject.Value, factor1: GObject.Value, factor2: GObject.Value): {
        // javascript wrapper for 'gst_value_fraction_multiply'
    }

Multiplies the two GObject.Value items containing a GST_TYPE_FRACTION (not introspectable) and sets product to the product of the two fractions.

Parameters:

`product` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`factor1` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`factor2` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (Number) –

false in case of an error (like integer overflow), true otherwise.

### Gst.value_fraction_multiply

    def Gst.value_fraction_multiply (product, factor1, factor2):
        #python wrapper for 'gst_value_fraction_multiply'

Multiplies the two GObject.Value items containing a GST_TYPE_FRACTION (not introspectable) and sets product to the product of the two fractions.

Parameters:

`product` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`factor1` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`factor2` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (bool) –

False in case of an error (like integer overflow), True otherwise.

### 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.

Parameters:

`dest` –

a GValue initialized to GST_TYPE_FRACTION

`minuend` –

a GValue initialized to GST_TYPE_FRACTION

`subtrahend` –

a GValue initialized to GST_TYPE_FRACTION

Returns –

FALSE in case of an error (like integer overflow), TRUE otherwise.

### Gst.prototype.value_fraction_subtract

    function Gst.prototype.value_fraction_subtract(dest: GObject.Value, minuend: GObject.Value, subtrahend: GObject.Value): {
        // javascript wrapper for 'gst_value_fraction_subtract'
    }

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

Parameters:

`dest` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`minuend` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`subtrahend` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (Number) –

false in case of an error (like integer overflow), true otherwise.

### Gst.value_fraction_subtract

    def Gst.value_fraction_subtract (dest, minuend, subtrahend):
        #python wrapper for 'gst_value_fraction_subtract'

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

Parameters:

`dest` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`minuend` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`subtrahend` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (bool) –

False in case of an error (like integer overflow), True otherwise.

### gst_value_get_bitmask

    guint64
    gst_value_get_bitmask (const GValue * value)

Gets the bitmask specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_BITMASK

Returns –

the bitmask.

### Gst.prototype.value_get_bitmask

    function Gst.prototype.value_get_bitmask(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_bitmask'
    }

Gets the bitmask specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_BITMASK (not introspectable)

Returns (Number) –

the bitmask.

### Gst.value_get_bitmask

    def Gst.value_get_bitmask (value):
        #python wrapper for 'gst_value_get_bitmask'

Gets the bitmask specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_BITMASK (not introspectable)

Returns (int) –

the bitmask.

### gst_value_get_caps

    const GstCaps *
    gst_value_get_caps (const GValue * value)

Gets the contents of value. The reference count of the returned GstCaps will not be modified, therefore the caller must take one before getting rid of the value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_CAPS

Returns ( [transfer: none]) –

the contents of value

### Gst.prototype.value_get_caps

    function Gst.prototype.value_get_caps(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_caps'
    }

Gets the contents of value. The reference count of the returned Gst.Caps will not be modified, therefore the caller must take one before getting rid of the value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS

Returns (Gst.Caps) –

the contents of value

### Gst.value_get_caps

    def Gst.value_get_caps (value):
        #python wrapper for 'gst_value_get_caps'

Gets the contents of value. The reference count of the returned Gst.Caps will not be modified, therefore the caller must take one before getting rid of the value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS

Returns (Gst.Caps) –

the contents of value

### gst_value_get_caps_features

    const GstCapsFeatures *
    gst_value_get_caps_features (const GValue * value)

Gets the contents of value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_CAPS_FEATURES

Returns ( [transfer: none]) –

the contents of value

### Gst.prototype.value_get_caps_features

    function Gst.prototype.value_get_caps_features(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_caps_features'
    }

Gets the contents of value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS_FEATURES

Returns (Gst.CapsFeatures) –

the contents of value

### Gst.value_get_caps_features

    def Gst.value_get_caps_features (value):
        #python wrapper for 'gst_value_get_caps_features'

Gets the contents of value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS_FEATURES

Returns (Gst.CapsFeatures) –

the contents of 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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

Returns –

the maximum of the range

### Gst.prototype.value_get_double_range_max

    function Gst.prototype.value_get_double_range_max(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_double_range_max'
    }

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

Returns (Number) –

the maximum of the range

### Gst.value_get_double_range_max

    def Gst.value_get_double_range_max (value):
        #python wrapper for 'gst_value_get_double_range_max'

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

Returns (float) –

the maximum of the range

### 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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

Returns –

the minimum of the range

### Gst.prototype.value_get_double_range_min

    function Gst.prototype.value_get_double_range_min(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_double_range_min'
    }

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

Returns (Number) –

the minimum of the range

### Gst.value_get_double_range_min

    def Gst.value_get_double_range_min (value):
        #python wrapper for 'gst_value_get_double_range_min'

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

Returns (float) –

the minimum of the range

### gst_value_get_flagset_flags

    guint
    gst_value_get_flagset_flags (const GValue * value)

Retrieve the flags field of a GstFlagSet value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FLAG_SET

Returns –

the flags field of the flagset instance.

Since : 1.6

### Gst.prototype.value_get_flagset_flags

    function Gst.prototype.value_get_flagset_flags(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_flagset_flags'
    }

Retrieve the flags field of a GstFlagSet value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FLAG_SET (not introspectable)

Returns (Number) –

the flags field of the flagset instance.

Since : 1.6

### Gst.value_get_flagset_flags

    def Gst.value_get_flagset_flags (value):
        #python wrapper for 'gst_value_get_flagset_flags'

Retrieve the flags field of a GstFlagSet value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FLAG_SET (not introspectable)

Returns (int) –

the flags field of the flagset instance.

Since : 1.6

### gst_value_get_flagset_mask

    guint
    gst_value_get_flagset_mask (const GValue * value)

Retrieve the mask field of a GstFlagSet value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FLAG_SET

Returns –

the mask field of the flagset instance.

Since : 1.6

### Gst.prototype.value_get_flagset_mask

    function Gst.prototype.value_get_flagset_mask(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_flagset_mask'
    }

Retrieve the mask field of a GstFlagSet value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FLAG_SET (not introspectable)

Returns (Number) –

the mask field of the flagset instance.

Since : 1.6

### Gst.value_get_flagset_mask

    def Gst.value_get_flagset_mask (value):
        #python wrapper for 'gst_value_get_flagset_mask'

Retrieve the mask field of a GstFlagSet value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FLAG_SET (not introspectable)

Returns (int) –

the mask field of the flagset instance.

Since : 1.6

### gst_value_get_fraction_denominator

    gint
    gst_value_get_fraction_denominator (const GValue * value)

Gets the denominator of the fraction specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION

Returns –

the denominator of the fraction.

### Gst.prototype.value_get_fraction_denominator

    function Gst.prototype.value_get_fraction_denominator(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_fraction_denominator'
    }

Gets the denominator of the fraction specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (Number) –

the denominator of the fraction.

### Gst.value_get_fraction_denominator

    def Gst.value_get_fraction_denominator (value):
        #python wrapper for 'gst_value_get_fraction_denominator'

Gets the denominator of the fraction specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (int) –

the denominator of the fraction.

### gst_value_get_fraction_numerator

    gint
    gst_value_get_fraction_numerator (const GValue * value)

Gets the numerator of the fraction specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION

Returns –

the numerator of the fraction.

### Gst.prototype.value_get_fraction_numerator

    function Gst.prototype.value_get_fraction_numerator(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_fraction_numerator'
    }

Gets the numerator of the fraction specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (Number) –

the numerator of the fraction.

### Gst.value_get_fraction_numerator

    def Gst.value_get_fraction_numerator (value):
        #python wrapper for 'gst_value_get_fraction_numerator'

Gets the numerator of the fraction specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

Returns (int) –

the numerator of the fraction.

### 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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION_RANGE

Returns ( [nullable]) –

the maximum of the range

### Gst.prototype.value_get_fraction_range_max

    function Gst.prototype.value_get_fraction_range_max(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_fraction_range_max'
    }

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

Returns (GObject.Value) –

the maximum of the range

### Gst.value_get_fraction_range_max

    def Gst.value_get_fraction_range_max (value):
        #python wrapper for 'gst_value_get_fraction_range_max'

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

Returns (GObject.Value) –

the maximum of the range

### 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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION_RANGE

Returns ( [nullable]) –

the minimum of the range

### Gst.prototype.value_get_fraction_range_min

    function Gst.prototype.value_get_fraction_range_min(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_fraction_range_min'
    }

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

Returns (GObject.Value) –

the minimum of the range

### Gst.value_get_fraction_range_min

    def Gst.value_get_fraction_range_min (value):
        #python wrapper for 'gst_value_get_fraction_range_min'

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

Returns (GObject.Value) –

the minimum of the range

### gst_value_get_int64_range_max

    gint64
    gst_value_get_int64_range_max (const GValue * value)

Gets the maximum of the range specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns –

the maximum of the range

### Gst.prototype.value_get_int64_range_max

    function Gst.prototype.value_get_int64_range_max(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_int64_range_max'
    }

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns (Number) –

the maximum of the range

### Gst.value_get_int64_range_max

    def Gst.value_get_int64_range_max (value):
        #python wrapper for 'gst_value_get_int64_range_max'

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns (int) –

the maximum of the range

### gst_value_get_int64_range_min

    gint64
    gst_value_get_int64_range_min (const GValue * value)

Gets the minimum of the range specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns –

the minimum of the range

### Gst.prototype.value_get_int64_range_min

    function Gst.prototype.value_get_int64_range_min(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_int64_range_min'
    }

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns (Number) –

the minimum of the range

### Gst.value_get_int64_range_min

    def Gst.value_get_int64_range_min (value):
        #python wrapper for 'gst_value_get_int64_range_min'

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns (int) –

the minimum of the range

### gst_value_get_int64_range_step

    gint64
    gst_value_get_int64_range_step (const GValue * value)

Gets the step of the range specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns –

the step of the range

### Gst.prototype.value_get_int64_range_step

    function Gst.prototype.value_get_int64_range_step(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_int64_range_step'
    }

Gets the step of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns (Number) –

the step of the range

### Gst.value_get_int64_range_step

    def Gst.value_get_int64_range_step (value):
        #python wrapper for 'gst_value_get_int64_range_step'

Gets the step of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

Returns (int) –

the step of the range

### 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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT_RANGE

Returns –

the maximum of the range

### Gst.prototype.value_get_int_range_max

    function Gst.prototype.value_get_int_range_max(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_int_range_max'
    }

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

Returns (Number) –

the maximum of the range

### Gst.value_get_int_range_max

    def Gst.value_get_int_range_max (value):
        #python wrapper for 'gst_value_get_int_range_max'

Gets the maximum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

Returns (int) –

the maximum of the range

### 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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT_RANGE

Returns –

the minimum of the range

### Gst.prototype.value_get_int_range_min

    function Gst.prototype.value_get_int_range_min(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_int_range_min'
    }

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

Returns (Number) –

the minimum of the range

### Gst.value_get_int_range_min

    def Gst.value_get_int_range_min (value):
        #python wrapper for 'gst_value_get_int_range_min'

Gets the minimum of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

Returns (int) –

the minimum of the range

### gst_value_get_int_range_step

    gint
    gst_value_get_int_range_step (const GValue * value)

Gets the step of the range specified by value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT_RANGE

Returns –

the step of the range

### Gst.prototype.value_get_int_range_step

    function Gst.prototype.value_get_int_range_step(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_int_range_step'
    }

Gets the step of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

Returns (Number) –

the step of the range

### Gst.value_get_int_range_step

    def Gst.value_get_int_range_step (value):
        #python wrapper for 'gst_value_get_int_range_step'

Gets the step of the range specified by value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

Returns (int) –

the step of the range

### gst_value_get_structure

    const GstStructure *
    gst_value_get_structure (const GValue * value)

Gets the contents of value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_STRUCTURE

Returns ( [transfer: none]) –

the contents of value

### Gst.prototype.value_get_structure

    function Gst.prototype.value_get_structure(value: GObject.Value): {
        // javascript wrapper for 'gst_value_get_structure'
    }

Gets the contents of value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_STRUCTURE

Returns (Gst.Structure) –

the contents of value

### Gst.value_get_structure

    def Gst.value_get_structure (value):
        #python wrapper for 'gst_value_get_structure'

Gets the contents of value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_STRUCTURE

Returns (Gst.Structure) –

the contents of value

### gst_value_init_and_copy

    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.

Parameters:

`dest` ( [out]) –

the target value

`src` –

the source value

### Gst.prototype.value_init_and_copy

    function Gst.prototype.value_init_and_copy(src: GObject.Value): {
        // javascript wrapper for 'gst_value_init_and_copy'
    }

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

Parameters:

`src` (GObject.Value) –

the source value

### Gst.value_init_and_copy

    def Gst.value_init_and_copy (src):
        #python wrapper for 'gst_value_init_and_copy'

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

Parameters:

`src` (GObject.Value) –

the source value

### 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, unless NULL. If the intersection is non-empty, dest is not modified.

Parameters:

`dest` –

(out caller-allocates) (transfer full) (allow-none): a uninitialized GValue that will hold the calculated intersection value. May be NULL if the resulting set if not needed.

`value1` –

a value to intersect

`value2` –

another value to intersect

Returns –

TRUE if the intersection is non-empty

### Gst.prototype.value_intersect

    function Gst.prototype.value_intersect(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_intersect'
    }

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

Parameters:

`value1` (GObject.Value) –

a value to intersect

`value2` (GObject.Value) –

another value to intersect

Returns a tuple made of:

(Number ) –

true if the intersection is non-empty

`dest` (GObject.Value ) –

true if the intersection is non-empty

### Gst.value_intersect

    def Gst.value_intersect (value1, value2):
        #python wrapper for 'gst_value_intersect'

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

Parameters:

`value1` (GObject.Value) –

a value to intersect

`value2` (GObject.Value) –

another value to intersect

Returns a tuple made of:

(bool ) –

True if the intersection is non-empty

`dest` (GObject.Value ) –

True if the intersection is non-empty

### 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.

Parameters:

`value` –

the GValue to check

Returns –

true if the value is "fixed".

### Gst.prototype.value_is_fixed

    function Gst.prototype.value_is_fixed(value: GObject.Value): {
        // javascript wrapper for 'gst_value_is_fixed'
    }

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.

Parameters:

`value` (GObject.Value) –

the GObject.Value to check

Returns (Number) –

true if the value is "fixed".

### Gst.value_is_fixed

    def Gst.value_is_fixed (value):
        #python wrapper for 'gst_value_is_fixed'

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.

Parameters:

`value` (GObject.Value) –

the GObject.Value to check

Returns (bool) –

true if the value is "fixed".

### gst_value_is_subset

    gboolean
    gst_value_is_subset (const GValue * value1,
                         const GValue * value2)

Check that value1 is a subset of value2.

Return: TRUE is value1 is a subset of value2

Parameters:

`value1` –

a GValue

`value2` –

a GValue

Returns –
No description available

### Gst.prototype.value_is_subset

    function Gst.prototype.value_is_subset(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_is_subset'
    }

Check that value1 is a subset of value2.

Return: true is value1 is a subset of value2

Parameters:

`value1` (GObject.Value) –

a GObject.Value

`value2` (GObject.Value) –

a GObject.Value

Returns (Number) –
No description available

### Gst.value_is_subset

    def Gst.value_is_subset (value1, value2):
        #python wrapper for 'gst_value_is_subset'

Check that value1 is a subset of value2.

Return: True is value1 is a subset of value2

Parameters:

`value1` (GObject.Value) –

a GObject.Value

`value2` (GObject.Value) –

a GObject.Value

Returns (bool) –
No description available

### gst_value_register

    gst_value_register (const GstValueTable * table)

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

Parameters:

`table` –

structure containing functions to register

### Gst.prototype.value_register

    function Gst.prototype.value_register(table: Gst.ValueTable): {
        // javascript wrapper for 'gst_value_register'
    }

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

Parameters:

`table` (Gst.ValueTable) –

structure containing functions to register

### Gst.value_register

    def Gst.value_register (table):
        #python wrapper for 'gst_value_register'

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

Parameters:

`table` (Gst.ValueTable) –

structure containing functions to register

### 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.

Free-function: g_free

Parameters:

`value` –

a GValue to serialize

Returns ( [transfer: full][nullable]) –

the serialization for value or NULL if none exists

### Gst.prototype.value_serialize

    function Gst.prototype.value_serialize(value: GObject.Value): {
        // javascript wrapper for 'gst_value_serialize'
    }

tries to transform the given value into a string representation that allows getting back this string later on using Gst.prototype.value_deserialize.

Free-function: g_free

Parameters:

`value` (GObject.Value) –

a GObject.Value to serialize

Returns (String) –

the serialization for value or null if none exists

### Gst.value_serialize

    def Gst.value_serialize (value):
        #python wrapper for 'gst_value_serialize'

tries to transform the given value into a string representation that allows getting back this string later on using Gst.value_deserialize.

Free-function: g_free

Parameters:

`value` (GObject.Value) –

a GObject.Value to serialize

Returns (str) –

the serialization for value or None if none exists

### gst_value_set_bitmask

    gst_value_set_bitmask (GValue * value,
                           guint64 bitmask)

Sets value to the bitmask specified by bitmask.

Parameters:

`value` –

a GValue initialized to GST_TYPE_BITMASK

`bitmask` –

the bitmask

### Gst.prototype.value_set_bitmask

    function Gst.prototype.value_set_bitmask(value: GObject.Value, bitmask: Number): {
        // javascript wrapper for 'gst_value_set_bitmask'
    }

Sets value to the bitmask specified by bitmask.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_BITMASK (not introspectable)

`bitmask` (Number) –

the bitmask

### Gst.value_set_bitmask

    def Gst.value_set_bitmask (value, bitmask):
        #python wrapper for 'gst_value_set_bitmask'

Sets value to the bitmask specified by bitmask.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_BITMASK (not introspectable)

`bitmask` (int) –

the bitmask

### gst_value_set_caps

    gst_value_set_caps (GValue * value,
                        const GstCaps * caps)

Sets the contents of value to caps. A reference to the provided caps will be taken by the value.

Parameters:

`value` –

a GValue initialized to GST_TYPE_CAPS

`caps` ( [transfer: none]) –

the caps to set the value to

### Gst.prototype.value_set_caps

    function Gst.prototype.value_set_caps(value: GObject.Value, caps: Gst.Caps): {
        // javascript wrapper for 'gst_value_set_caps'
    }

Sets the contents of value to caps. A reference to the provided caps will be taken by the value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS

`caps` (Gst.Caps) –

the caps to set the value to

### Gst.value_set_caps

    def Gst.value_set_caps (value, caps):
        #python wrapper for 'gst_value_set_caps'

Sets the contents of value to caps. A reference to the provided caps will be taken by the value.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS

`caps` (Gst.Caps) –

the caps to set the value to

### gst_value_set_caps_features

    gst_value_set_caps_features (GValue * value,
                                 const GstCapsFeatures * features)

Sets the contents of value to features.

Parameters:

`value` –

a GValue initialized to GST_TYPE_CAPS_FEATURES

`features` –

the features to set the value to

### Gst.prototype.value_set_caps_features

    function Gst.prototype.value_set_caps_features(value: GObject.Value, features: Gst.CapsFeatures): {
        // javascript wrapper for 'gst_value_set_caps_features'
    }

Sets the contents of value to features.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS_FEATURES

`features` (Gst.CapsFeatures) –

the features to set the value to

### Gst.value_set_caps_features

    def Gst.value_set_caps_features (value, features):
        #python wrapper for 'gst_value_set_caps_features'

Sets the contents of value to features.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_CAPS_FEATURES

`features` (Gst.CapsFeatures) –

the features to set the value to

### gst_value_set_double_range

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

Sets value to the range specified by start and end.

Parameters:

`value` –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

`start` –

the start of the range

`end` –

the end of the range

### Gst.prototype.value_set_double_range

    function Gst.prototype.value_set_double_range(value: GObject.Value, start: Number, end: Number): {
        // javascript wrapper for 'gst_value_set_double_range'
    }

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

`start` (Number) –

the start of the range

`end` (Number) –

the end of the range

### Gst.value_set_double_range

    def Gst.value_set_double_range (value, start, end):
        #python wrapper for 'gst_value_set_double_range'

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_DOUBLE_RANGE

`start` (float) –

the start of the range

`end` (float) –

the end of the range

### gst_value_set_flagset

    gst_value_set_flagset (GValue * value,
                           guint flags,
                           guint mask)

Sets value to the flags and mask values provided in flags and mask. The flags value indicates the values of flags, the mask represents which bits in the flag value have been set, and which are "don't care"

Parameters:

`value` –

a GValue initialized to GST_TYPE_FLAG_SET

`flags` –

The value of the flags set or unset

`mask` –

The mask indicate which flags bits must match for comparisons

Since : 1.6

### Gst.prototype.value_set_flagset

    function Gst.prototype.value_set_flagset(value: GObject.Value, flags: Number, mask: Number): {
        // javascript wrapper for 'gst_value_set_flagset'
    }

Sets value to the flags and mask values provided in flags and mask. The flags value indicates the values of flags, the mask represents which bits in the flag value have been set, and which are "don't care"

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FLAG_SET (not introspectable)

`flags` (Number) –

The value of the flags set or unset

`mask` (Number) –

The mask indicate which flags bits must match for comparisons

Since : 1.6

### Gst.value_set_flagset

    def Gst.value_set_flagset (value, flags, mask):
        #python wrapper for 'gst_value_set_flagset'

Sets value to the flags and mask values provided in flags and mask. The flags value indicates the values of flags, the mask represents which bits in the flag value have been set, and which are "don't care"

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FLAG_SET (not introspectable)

`flags` (int) –

The value of the flags set or unset

`mask` (int) –

The mask indicate which flags bits must match for comparisons

Since : 1.6

### gst_value_set_fraction

    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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION

`numerator` –

the numerator of the fraction

`denominator` –

the denominator of the fraction

### Gst.prototype.value_set_fraction

    function Gst.prototype.value_set_fraction(value: GObject.Value, numerator: Number, denominator: Number): {
        // javascript wrapper for 'gst_value_set_fraction'
    }

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.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`numerator` (Number) –

the numerator of the fraction

`denominator` (Number) –

the denominator of the fraction

### Gst.value_set_fraction

    def Gst.value_set_fraction (value, numerator, denominator):
        #python wrapper for 'gst_value_set_fraction'

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.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION (not introspectable)

`numerator` (int) –

the numerator of the fraction

`denominator` (int) –

the denominator of the fraction

### gst_value_set_fraction_range

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

Sets value to the range specified by start and end.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION_RANGE

`start` –

the start of the range (a GST_TYPE_FRACTION GValue)

`end` –

the end of the range (a GST_TYPE_FRACTION GValue)

### Gst.prototype.value_set_fraction_range

    function Gst.prototype.value_set_fraction_range(value: GObject.Value, start: GObject.Value, end: GObject.Value): {
        // javascript wrapper for 'gst_value_set_fraction_range'
    }

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

`start` (GObject.Value) –

the start of the range (a GST_TYPE_FRACTION GValue)

`end` (GObject.Value) –

the end of the range (a GST_TYPE_FRACTION GValue)

### Gst.value_set_fraction_range

    def Gst.value_set_fraction_range (value, start, end):
        #python wrapper for 'gst_value_set_fraction_range'

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

`start` (GObject.Value) –

the start of the range (a GST_TYPE_FRACTION GValue)

`end` (GObject.Value) –

the end of the range (a GST_TYPE_FRACTION GValue)

### gst_value_set_fraction_range_full

    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.

Parameters:

`value` –

a GValue initialized to GST_TYPE_FRACTION_RANGE

`numerator_start` –

the numerator start of the range

`denominator_start` –

the denominator start of the range

`numerator_end` –

the numerator end of the range

`denominator_end` –

the denominator end of the range

### Gst.prototype.value_set_fraction_range_full

    function Gst.prototype.value_set_fraction_range_full(value: GObject.Value, numerator_start: Number, denominator_start: Number, numerator_end: Number, denominator_end: Number): {
        // javascript wrapper for 'gst_value_set_fraction_range_full'
    }

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

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

`numerator_start` (Number) –

the numerator start of the range

`denominator_start` (Number) –

the denominator start of the range

`numerator_end` (Number) –

the numerator end of the range

`denominator_end` (Number) –

the denominator end of the range

### Gst.value_set_fraction_range_full

    def Gst.value_set_fraction_range_full (value, numerator_start, denominator_start, numerator_end, denominator_end):
        #python wrapper for 'gst_value_set_fraction_range_full'

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

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_FRACTION_RANGE

`numerator_start` (int) –

the numerator start of the range

`denominator_start` (int) –

the denominator start of the range

`numerator_end` (int) –

the numerator end of the range

`denominator_end` (int) –

the denominator end of the range

### gst_value_set_int64_range

    gst_value_set_int64_range (GValue * value,
                               gint64 start,
                               gint64 end)

Sets value to the range specified by start and end.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT64_RANGE

`start` –

the start of the range

`end` –

the end of the range

### Gst.prototype.value_set_int64_range

    function Gst.prototype.value_set_int64_range(value: GObject.Value, start: Number, end: Number): {
        // javascript wrapper for 'gst_value_set_int64_range'
    }

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

`start` (Number) –

the start of the range

`end` (Number) –

the end of the range

### Gst.value_set_int64_range

    def Gst.value_set_int64_range (value, start, end):
        #python wrapper for 'gst_value_set_int64_range'

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

`start` (int) –

the start of the range

`end` (int) –

the end of the range

### gst_value_set_int64_range_step

    gst_value_set_int64_range_step (GValue * value,
                                    gint64 start,
                                    gint64 end,
                                    gint64 step)

Sets value to the range specified by start, end and step.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT64_RANGE

`start` –

the start of the range

`end` –

the end of the range

`step` –

the step of the range

### Gst.prototype.value_set_int64_range_step

    function Gst.prototype.value_set_int64_range_step(value: GObject.Value, start: Number, end: Number, step: Number): {
        // javascript wrapper for 'gst_value_set_int64_range_step'
    }

Sets value to the range specified by start, end and step.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

`start` (Number) –

the start of the range

`end` (Number) –

the end of the range

`step` (Number) –

the step of the range

### Gst.value_set_int64_range_step

    def Gst.value_set_int64_range_step (value, start, end, step):
        #python wrapper for 'gst_value_set_int64_range_step'

Sets value to the range specified by start, end and step.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT64_RANGE

`start` (int) –

the start of the range

`end` (int) –

the end of the range

`step` (int) –

the step of the range

### gst_value_set_int_range

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

Sets value to the range specified by start and end.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT_RANGE

`start` –

the start of the range

`end` –

the end of the range

### Gst.prototype.value_set_int_range

    function Gst.prototype.value_set_int_range(value: GObject.Value, start: Number, end: Number): {
        // javascript wrapper for 'gst_value_set_int_range'
    }

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

`start` (Number) –

the start of the range

`end` (Number) –

the end of the range

### Gst.value_set_int_range

    def Gst.value_set_int_range (value, start, end):
        #python wrapper for 'gst_value_set_int_range'

Sets value to the range specified by start and end.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

`start` (int) –

the start of the range

`end` (int) –

the end of the range

### gst_value_set_int_range_step

    gst_value_set_int_range_step (GValue * value,
                                  gint start,
                                  gint end,
                                  gint step)

Sets value to the range specified by start, end and step.

Parameters:

`value` –

a GValue initialized to GST_TYPE_INT_RANGE

`start` –

the start of the range

`end` –

the end of the range

`step` –

the step of the range

### Gst.prototype.value_set_int_range_step

    function Gst.prototype.value_set_int_range_step(value: GObject.Value, start: Number, end: Number, step: Number): {
        // javascript wrapper for 'gst_value_set_int_range_step'
    }

Sets value to the range specified by start, end and step.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

`start` (Number) –

the start of the range

`end` (Number) –

the end of the range

`step` (Number) –

the step of the range

### Gst.value_set_int_range_step

    def Gst.value_set_int_range_step (value, start, end, step):
        #python wrapper for 'gst_value_set_int_range_step'

Sets value to the range specified by start, end and step.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_INT_RANGE

`start` (int) –

the start of the range

`end` (int) –

the end of the range

`step` (int) –

the step of the range

### gst_value_set_structure

    gst_value_set_structure (GValue * value,
                             const GstStructure * structure)

Sets the contents of value to structure.

Parameters:

`value` –

a GValue initialized to GST_TYPE_STRUCTURE

`structure` –

the structure to set the value to

### Gst.prototype.value_set_structure

    function Gst.prototype.value_set_structure(value: GObject.Value, structure: Gst.Structure): {
        // javascript wrapper for 'gst_value_set_structure'
    }

Sets the contents of value to structure.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_STRUCTURE

`structure` (Gst.Structure) –

the structure to set the value to

### Gst.value_set_structure

    def Gst.value_set_structure (value, structure):
        #python wrapper for 'gst_value_set_structure'

Sets the contents of value to structure.

Parameters:

`value` (GObject.Value) –

a GValue initialized to GST_TYPE_STRUCTURE

`structure` (Gst.Structure) –

the structure to set the value to

### 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.

Parameters:

`dest` ( [out][allow-none]) –

the destination value for the result if the subtraction is not empty. May be NULL, in which case the resulting set will not be computed, which can give a fair speedup.

`minuend` –

the value to subtract from

`subtrahend` –

the value to subtract

Returns –

TRUE if the subtraction is not empty

### Gst.prototype.value_subtract

    function Gst.prototype.value_subtract(minuend: GObject.Value, subtrahend: GObject.Value): {
        // javascript wrapper for 'gst_value_subtract'
    }

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

Parameters:

`minuend` (GObject.Value) –

the value to subtract from

`subtrahend` (GObject.Value) –

the value to subtract

Returns a tuple made of:

(Number ) –

true if the subtraction is not empty

`dest` (GObject.Value ) –

true if the subtraction is not empty

### Gst.value_subtract

    def Gst.value_subtract (minuend, subtrahend):
        #python wrapper for 'gst_value_subtract'

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

Parameters:

`minuend` (GObject.Value) –

the value to subtract from

`subtrahend` (GObject.Value) –

the value to subtract

Returns a tuple made of:

(bool ) –

True if the subtraction is not empty

`dest` (GObject.Value ) –

True if the subtraction is not empty

### 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.

Parameters:

`dest` ( [out]) –

the destination value

`value1` –

a value to union

`value2` –

another value to union

Returns –

TRUE if the union succeeded.

### Gst.prototype.value_union

    function Gst.prototype.value_union(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'gst_value_union'
    }

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

Parameters:

`value1` (GObject.Value) –

a value to union

`value2` (GObject.Value) –

another value to union

Returns a tuple made of:

(Number ) –

true if the union succeeded.

`dest` (GObject.Value ) –

true if the union succeeded.

### Gst.value_union

    def Gst.value_union (value1, value2):
        #python wrapper for 'gst_value_union'

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

Parameters:

`value1` (GObject.Value) –

a value to union

`value2` (GObject.Value) –

another value to union

Returns a tuple made of:

(bool ) –

True if the union succeeded.

`dest` (GObject.Value ) –

True if the union succeeded.

## Function Macros

### GST_FOURCC_ARGS

    #define GST_FOURCC_ARGS(fourcc)               \
      __GST_PRINT_CHAR((fourcc) & 0xff),          \
      __GST_PRINT_CHAR(((fourcc) >> 8) & 0xff),   \
      __GST_PRINT_CHAR(((fourcc) >> 16) & 0xff),  \
      __GST_PRINT_CHAR(((fourcc) >> 24) & 0xff)

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

Parameters:

`fourcc` –

a guint32 fourcc value to output

### GST_MAKE_FOURCC

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

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

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

Parameters:

`a` –

the first character

`b` –

the second character

`c` –

the third character

`d` –

the fourth character

### 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");

Parameters:

`f` –

a string with at least four characters

### GST_VALUE_HOLDS_ARRAY

    #define GST_VALUE_HOLDS_ARRAY(x)        ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_value_array_type)

Checks if the given GValue contains a GstValueArray value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_BITMASK

    #define GST_VALUE_HOLDS_BITMASK(x)      ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_bitmask_type)

Checks if the given GValue contains a GstBitmask value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_BUFFER

    #define GST_VALUE_HOLDS_BUFFER(x)       ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_buffer_type)

Checks if the given GValue contains a GstBuffer value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_CAPS

    #define GST_VALUE_HOLDS_CAPS(x)         ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_caps_type)

Checks if the given GValue contains a GstCaps value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_CAPS_FEATURES

    #define GST_VALUE_HOLDS_CAPS_FEATURES(x)  ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_caps_features_type)

Checks if the given GValue contains a GstCapsFeatures value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_DATE_TIME

    #define GST_VALUE_HOLDS_DATE_TIME(x)    ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_date_time_type)

Checks if the given GValue contains a GstDateTime value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_DOUBLE_RANGE

    #define GST_VALUE_HOLDS_DOUBLE_RANGE(x)   ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_double_range_type)

Checks if the given GValue contains a GstDoubleRange value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_FLAG_SET

    #define GST_VALUE_HOLDS_FLAG_SET(x)     (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE ((x))) == GST_TYPE_FLAG_SET)

Checks if the given GValue contains a GstFlagSet value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_FRACTION

    #define GST_VALUE_HOLDS_FRACTION(x)     ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_fraction_type)

Checks if the given GValue contains a GstFraction value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_FRACTION_RANGE

    #define GST_VALUE_HOLDS_FRACTION_RANGE(x) ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_fraction_range_type)

Checks if the given GValue contains a GstFractionRange value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_INT64_RANGE

    #define GST_VALUE_HOLDS_INT64_RANGE(x)    ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_int64_range_type)

Checks if the given GValue contains a GstInt64Range value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_INT_RANGE

    #define GST_VALUE_HOLDS_INT_RANGE(x)      ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_int_range_type)

Checks if the given GValue contains a GstIntRange value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_LIST

    #define GST_VALUE_HOLDS_LIST(x)         ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_value_list_type)

Checks if the given GValue contains a GstValueList value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_SAMPLE

    #define GST_VALUE_HOLDS_SAMPLE(x)       ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_sample_type)

Checks if the given GValue contains a GstSample value.

Parameters:

`x` –

the GValue to check

### GST_VALUE_HOLDS_STRUCTURE

    #define GST_VALUE_HOLDS_STRUCTURE(x)      ((gpointer)(x) != NULL && G_VALUE_TYPE(x) == _gst_structure_type)

Checks if the given GValue contains a GstStructure value.

Parameters:

`x` –

the GValue to check

### __GST_PRINT_CHAR

    #define __GST_PRINT_CHAR(c) \
      g_ascii_isprint(c) ? (c) : '.'

## Constants

### GST_FLAG_SET_MASK_EXACT

    #define GST_FLAG_SET_MASK_EXACT ((guint)(-1))

A mask value with all bits set, for use as a GstFlagSet mask where all flag bits must match exactly

### Gst.FLAG_SET_MASK_EXACT

A mask value with all bits set, for use as a GstFlagSet mask where all flag bits must match exactly

### Gst.FLAG_SET_MASK_EXACT

A mask value with all bits set, for use as a GstFlagSet mask where all flag bits must match exactly

### 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_TYPE_ARRAY

    #define GST_TYPE_ARRAY                   (_gst_value_array_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_TYPE_BITMASK

    #define GST_TYPE_BITMASK                 (_gst_bitmask_type)

a GValue type that represents a 64-bit bitmask.

### GST_TYPE_DOUBLE_RANGE

    #define GST_TYPE_DOUBLE_RANGE            (_gst_double_range_type)

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

### GST_TYPE_FLAG_SET

    #define GST_TYPE_FLAG_SET                   (_gst_flagset_type)

a GValue type that represents a 32-bit flag bitfield, with 32-bit mask indicating which of the bits in the field are explicitly set. Useful for negotiation.

### GST_TYPE_FRACTION

    #define GST_TYPE_FRACTION                (_gst_fraction_type)

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

### GST_TYPE_FRACTION_RANGE

    #define GST_TYPE_FRACTION_RANGE           (_gst_fraction_range_type)

a GValue type that represents a GstFraction range

### GST_TYPE_G_THREAD

    #define GST_TYPE_G_THREAD                gst_g_thread_get_type ()

a boxed GValue type for GThread that represents a thread.

### GST_TYPE_INT64_RANGE

    #define GST_TYPE_INT64_RANGE             (_gst_int64_range_type)

a GValue type that represents an gint64 range

### GST_TYPE_INT_RANGE

    #define GST_TYPE_INT_RANGE               (_gst_int_range_type)

a GValue type that represents an integer range

### GST_TYPE_LIST

    #define GST_TYPE_LIST                    (_gst_value_list_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_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_EQUAL

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

### Gst.VALUE_EQUAL

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_GREATER_THAN

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

### Gst.VALUE_GREATER_THAN

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

### 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_LESS_THAN

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

### Gst.VALUE_LESS_THAN

Indicates that the first value provided to a comparison function (Gst.value_compare) is lesser 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.

### Gst.VALUE_UNORDERED

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

### Gst.VALUE_UNORDERED

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

## Callbacks

### GstValueCompareFunc

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

Used together with gst_value_compare to compare GValue items.

Parameters:

`value1` –

first value for comparison

`value2` –

second value for comparison

Returns –

one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN or GST_VALUE_UNORDERED

### Gst.ValueCompareFunc

    function Gst.ValueCompareFunc(value1: GObject.Value, value2: GObject.Value): {
        // javascript wrapper for 'GstValueCompareFunc'
    }

Used together with Gst.prototype.value_compare to compare GObject.Value items.

Parameters:

`value1` (GObject.Value) –

first value for comparison

`value2` (GObject.Value) –

second value for comparison

Returns (Number) –

one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN or GST_VALUE_UNORDERED

### Gst.ValueCompareFunc

    def Gst.ValueCompareFunc (value1, value2):
        #python wrapper for 'GstValueCompareFunc'

Used together with Gst.value_compare to compare GObject.Value items.

Parameters:

`value1` (GObject.Value) –

first value for comparison

`value2` (GObject.Value) –

second value for comparison

Returns (int) –

one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN or GST_VALUE_UNORDERED

### GstValueDeserializeFunc

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

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

Parameters:

`dest` –

a GValue

`s` –

a string

Returns –

TRUE for success

### Gst.ValueDeserializeFunc

    function Gst.ValueDeserializeFunc(dest: GObject.Value, s: String): {
        // javascript wrapper for 'GstValueDeserializeFunc'
    }

Used by Gst.prototype.value_deserialize to parse a non-binary form into the GObject.Value.

Parameters:

`dest` (GObject.Value) –

a GObject.Value

`s` (String) –

a string

Returns (Number) –

true for success

### Gst.ValueDeserializeFunc

    def Gst.ValueDeserializeFunc (dest, s):
        #python wrapper for 'GstValueDeserializeFunc'

Used by Gst.value_deserialize to parse a non-binary form into the GObject.Value.

Parameters:

`dest` (GObject.Value) –

a GObject.Value

`s` (str) –

a string

Returns (bool) –

True for success

### GstValueDeserializeWithPSpecFunc

    gboolean
    (*GstValueDeserializeWithPSpecFunc) (GValue * dest,
                                         const gchar * s,
                                         GParamSpec * pspec)

Used by gst_value_deserialize_with_pspec to parse a non-binary form into the GValue.

Parameters:

`dest` –

a GValue

`s` –

a string

`pspec` –

a GParamSpec describing the expected value

Returns –

TRUE for success

Since : 1.20

### Gst.ValueDeserializeWithPSpecFunc

    function Gst.ValueDeserializeWithPSpecFunc(dest: GObject.Value, s: String, pspec: GObject.ParamSpec): {
        // javascript wrapper for 'GstValueDeserializeWithPSpecFunc'
    }

Used by Gst.prototype.value_deserialize_with_pspec to parse a non-binary form into the GObject.Value.

Parameters:

`dest` (GObject.Value) –

a GObject.Value

`s` (String) –

a string

`pspec` (GObject.ParamSpec) –

a GObject.ParamSpec describing the expected value

Returns (Number) –

true for success

Since : 1.20

### Gst.ValueDeserializeWithPSpecFunc

    def Gst.ValueDeserializeWithPSpecFunc (dest, s, pspec):
        #python wrapper for 'GstValueDeserializeWithPSpecFunc'

Used by Gst.value_deserialize_with_pspec to parse a non-binary form into the GObject.Value.

Parameters:

`dest` (GObject.Value) –

a GObject.Value

`s` (str) –

a string

`pspec` (GObject.ParamSpec) –

a GObject.ParamSpec describing the expected value

Returns (bool) –

True for success

Since : 1.20

### GstValueSerializeFunc

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

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

Free-function: g_free

Parameters:

`value1` –

a GValue

Returns ( [transfer: full]) –

the string representation of the value

### Gst.ValueSerializeFunc

    function Gst.ValueSerializeFunc(value1: GObject.Value): {
        // javascript wrapper for 'GstValueSerializeFunc'
    }

Used by Gst.prototype.value_serialize to obtain a non-binary form of the GObject.Value.

Free-function: g_free

Parameters:

`value1` (GObject.Value) –

a GObject.Value

Returns (String) –

the string representation of the value

### Gst.ValueSerializeFunc

    def Gst.ValueSerializeFunc (value1):
        #python wrapper for 'GstValueSerializeFunc'

Used by Gst.value_serialize to obtain a non-binary form of the GObject.Value.

Free-function: g_free

Parameters:

`value1` (GObject.Value) –

a GObject.Value

Returns (str) –

the string representation of the value

The results of the search are