GstUtils

Functions

gst_calculate_linear_regression

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

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

r_squared will contain the remaining error.

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

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

Parameters:

xy

Pairs of (x,y) values

temp

Temporary scratch space used by the function

n

number of (x,y) pairs

m_num ( [out] ) –

numerator of calculated slope

m_denom ( [out] ) –

denominator of calculated slope

b ( [out] ) –

Offset at Y-axis

xbase ( [out] ) –

Offset at X-axis

r_squared ( [out] ) –

R-squared

Returns

TRUE if the linear regression was successfully calculated

Since : 1.12


gst_parse_bin_from_description

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

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

Parameters:

bin_description

command line describing the bin

ghost_unlinked_pads

whether to automatically create ghost pads for unlinked source or sink pads within the bin

error
No description available
Returns ( [transfer: floating] [type Gst.Bin] [nullable] ) –

a newly-created bin, or NULL if an error occurred.


Gst.parse_bin_from_description

@raises(GLib.GError)
def Gst.parse_bin_from_description (bin_description, ghost_unlinked_pads):
    #python wrapper for 'gst_parse_bin_from_description'

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

Parameters:

bin_description ( str ) –

command line describing the bin

ghost_unlinked_pads ( bool ) –

whether to automatically create ghost pads for unlinked source or sink pads within the bin

Returns ( Gst.Bin ) –

a newly-created bin, or None if an error occurred.


Gst.prototype.parse_bin_from_description

function Gst.prototype.parse_bin_from_description(bin_description: String, ghost_unlinked_pads: Number): {
    // javascript wrapper for 'gst_parse_bin_from_description'
}

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

Parameters:

bin_description ( String ) –

command line describing the bin

ghost_unlinked_pads ( Number ) –

whether to automatically create ghost pads for unlinked source or sink pads within the bin

Returns ( Gst.Bin ) –

a newly-created bin, or null if an error occurred.


gst_parse_bin_from_description_full

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

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

Parameters:

bin_description

command line describing the bin

ghost_unlinked_pads

whether to automatically create ghost pads for unlinked source or sink pads within the bin

context ( [transfer: none] [allow-none] ) –

a parse context allocated with gst_parse_context_new, or NULL

flags

parsing options, or GST_PARSE_FLAG_NONE

error
No description available
Returns ( [transfer: floating] [type Gst.Element] [nullable] ) –

a newly-created element, which is guaranteed to be a bin unless GST_FLAG_NO_SINGLE_ELEMENT_BINS was passed, or NULL if an error occurred.


Gst.parse_bin_from_description_full

@raises(GLib.GError)
def Gst.parse_bin_from_description_full (bin_description, ghost_unlinked_pads, context, flags):
    #python wrapper for 'gst_parse_bin_from_description_full'

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

Parameters:

bin_description ( str ) –

command line describing the bin

ghost_unlinked_pads ( bool ) –

whether to automatically create ghost pads for unlinked source or sink pads within the bin

context ( Gst.ParseContext ) –

a parse context allocated with Gst.ParseContext.new, or None

flags ( Gst.ParseFlags ) –

parsing options, or Gst.ParseFlags.NONE

Returns ( Gst.Element ) –

a newly-created element, which is guaranteed to be a bin unless GST_FLAG_NO_SINGLE_ELEMENT_BINS was passed, or None if an error occurred.


Gst.prototype.parse_bin_from_description_full

function Gst.prototype.parse_bin_from_description_full(bin_description: String, ghost_unlinked_pads: Number, context: Gst.ParseContext, flags: Gst.ParseFlags): {
    // javascript wrapper for 'gst_parse_bin_from_description_full'
}

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

Parameters:

bin_description ( String ) –

command line describing the bin

ghost_unlinked_pads ( Number ) –

whether to automatically create ghost pads for unlinked source or sink pads within the bin

context ( Gst.ParseContext ) –

a parse context allocated with Gst.ParseContext.prototype.new, or null

flags ( Gst.ParseFlags ) –

parsing options, or Gst.ParseFlags.NONE

Returns ( Gst.Element ) –

a newly-created element, which is guaranteed to be a bin unless GST_FLAG_NO_SINGLE_ELEMENT_BINS was passed, or null if an error occurred.


gst_state_change_get_name

const gchar *
gst_state_change_get_name (GstStateChange transition)

Gets a string representing the given state transition.

Parameters:

transition

a GstStateChange to get the name of.

Returns ( [transfer: none] ) –

a string with the name of the state result.

Since : 1.14


Gst.state_change_get_name

def Gst.state_change_get_name (transition):
    #python wrapper for 'gst_state_change_get_name'

Gets a string representing the given state transition.

Parameters:

transition ( Gst.StateChange ) –

a Gst.StateChange to get the name of.

Returns ( str ) –

a string with the name of the state result.

Since : 1.14


Gst.prototype.state_change_get_name

function Gst.prototype.state_change_get_name(transition: Gst.StateChange): {
    // javascript wrapper for 'gst_state_change_get_name'
}

Gets a string representing the given state transition.

Parameters:

transition ( Gst.StateChange ) –

a Gst.StateChange to get the name of.

Returns ( String ) –

a string with the name of the state result.

Since : 1.14


gst_util_double_to_fraction

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

Transforms a gdouble to a fraction and simplifies the result.

Parameters:

src

gdouble to transform

dest_n ( [out] ) –

pointer to a gint to hold the result numerator

dest_d ( [out] ) –

pointer to a gint to hold the result denominator


Gst.util_double_to_fraction

def Gst.util_double_to_fraction (src):
    #python wrapper for 'gst_util_double_to_fraction'

Transforms a float to a fraction and simplifies the result.

Parameters:

src ( float ) –

float to transform


Gst.prototype.util_double_to_fraction

function Gst.prototype.util_double_to_fraction(src: Number): {
    // javascript wrapper for 'gst_util_double_to_fraction'
}

Transforms a Number to a fraction and simplifies the result.

Parameters:

src ( Number ) –

Number to transform


gst_util_dump_buffer

gst_util_dump_buffer (GstBuffer * buf)

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

Parameters:

buf

a GstBuffer whose memory to dump

Since : 1.14


Gst.util_dump_buffer

def Gst.util_dump_buffer (buf):
    #python wrapper for 'gst_util_dump_buffer'

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

Parameters:

buf ( Gst.Buffer ) –

a Gst.Buffer whose memory to dump

Since : 1.14


Gst.prototype.util_dump_buffer

function Gst.prototype.util_dump_buffer(buf: Gst.Buffer): {
    // javascript wrapper for 'gst_util_dump_buffer'
}

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

Parameters:

buf ( Gst.Buffer ) –

a Gst.Buffer whose memory to dump

Since : 1.14


gst_util_dump_mem

gst_util_dump_mem (const guchar * mem,
                   guint size)

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

Parameters:

mem ( [array length=size] ) –

a pointer to the memory to dump

size

the size of the memory block to dump


Gst.util_dump_mem

def Gst.util_dump_mem (mem, size):
    #python wrapper for 'gst_util_dump_mem'

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

Parameters:

mem ( [ int ] ) –

a pointer to the memory to dump

size ( int ) –

the size of the memory block to dump


Gst.prototype.util_dump_mem

function Gst.prototype.util_dump_mem(mem: [ Number ], size: Number): {
    // javascript wrapper for 'gst_util_dump_mem'
}

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

Parameters:

mem ( [ Number ] ) –

a pointer to the memory to dump

size ( Number ) –

the size of the memory block to dump


gst_util_fraction_add

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

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

Parameters:

a_n

Numerator of first value

a_d

Denominator of first value

b_n

Numerator of second value

b_d

Denominator of second value

res_n ( [out] ) –

Pointer to gint to hold the result numerator

res_d ( [out] ) –

Pointer to gint to hold the result denominator

Returns

FALSE on overflow, TRUE otherwise.


Gst.util_fraction_add

def Gst.util_fraction_add (a_n, a_d, b_n, b_d):
    #python wrapper for 'gst_util_fraction_add'

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

Parameters:

a_n ( int ) –

Numerator of first value

a_d ( int ) –

Denominator of first value

b_n ( int ) –

Numerator of second value

b_d ( int ) –

Denominator of second value

Returns a tuple made of:

( bool ) –

False on overflow, True otherwise.

res_n ( int ) –

False on overflow, True otherwise.

res_d ( int ) –

False on overflow, True otherwise.


Gst.prototype.util_fraction_add

function Gst.prototype.util_fraction_add(a_n: Number, a_d: Number, b_n: Number, b_d: Number): {
    // javascript wrapper for 'gst_util_fraction_add'
}

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

Parameters:

a_n ( Number ) –

Numerator of first value

a_d ( Number ) –

Denominator of first value

b_n ( Number ) –

Numerator of second value

b_d ( Number ) –

Denominator of second value

Returns a tuple made of:

( Number ) –

false on overflow, true otherwise.

res_n ( Number ) –

false on overflow, true otherwise.

res_d ( Number ) –

false on overflow, true otherwise.


gst_util_fraction_compare

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

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

Parameters:

a_n

Numerator of first value

a_d

Denominator of first value

b_n

Numerator of second value

b_d

Denominator of second value

Returns

-1 if a < b; 0 if a = b; 1 if a > b.


Gst.util_fraction_compare

def Gst.util_fraction_compare (a_n, a_d, b_n, b_d):
    #python wrapper for 'gst_util_fraction_compare'

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

Parameters:

a_n ( int ) –

Numerator of first value

a_d ( int ) –

Denominator of first value

b_n ( int ) –

Numerator of second value

b_d ( int ) –

Denominator of second value

Returns ( int ) –

-1 if a < b; 0 if a = b; 1 if a > b.


Gst.prototype.util_fraction_compare

function Gst.prototype.util_fraction_compare(a_n: Number, a_d: Number, b_n: Number, b_d: Number): {
    // javascript wrapper for 'gst_util_fraction_compare'
}

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

Parameters:

a_n ( Number ) –

Numerator of first value

a_d ( Number ) –

Denominator of first value

b_n ( Number ) –

Numerator of second value

b_d ( Number ) –

Denominator of second value

Returns ( Number ) –

-1 if a < b; 0 if a = b; 1 if a > b.


gst_util_fraction_multiply

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

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

Parameters:

a_n

Numerator of first value

a_d

Denominator of first value

b_n

Numerator of second value

b_d

Denominator of second value

res_n ( [out] ) –

Pointer to gint to hold the result numerator

res_d ( [out] ) –

Pointer to gint to hold the result denominator

Returns

FALSE on overflow, TRUE otherwise.


Gst.util_fraction_multiply

def Gst.util_fraction_multiply (a_n, a_d, b_n, b_d):
    #python wrapper for 'gst_util_fraction_multiply'

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

Parameters:

a_n ( int ) –

Numerator of first value

a_d ( int ) –

Denominator of first value

b_n ( int ) –

Numerator of second value

b_d ( int ) –

Denominator of second value

Returns a tuple made of:

( bool ) –

False on overflow, True otherwise.

res_n ( int ) –

False on overflow, True otherwise.

res_d ( int ) –

False on overflow, True otherwise.


Gst.prototype.util_fraction_multiply

function Gst.prototype.util_fraction_multiply(a_n: Number, a_d: Number, b_n: Number, b_d: Number): {
    // javascript wrapper for 'gst_util_fraction_multiply'
}

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

Parameters:

a_n ( Number ) –

Numerator of first value

a_d ( Number ) –

Denominator of first value

b_n ( Number ) –

Numerator of second value

b_d ( Number ) –

Denominator of second value

Returns a tuple made of:

( Number ) –

false on overflow, true otherwise.

res_n ( Number ) –

false on overflow, true otherwise.

res_d ( Number ) –

false on overflow, true otherwise.


gst_util_fraction_to_double

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

Transforms a fraction to a gdouble.

Parameters:

src_n

Fraction numerator as gint

src_d

Fraction denominator gint

dest ( [out] ) –

pointer to a gdouble for the result


Gst.util_fraction_to_double

def Gst.util_fraction_to_double (src_n, src_d):
    #python wrapper for 'gst_util_fraction_to_double'

Transforms a fraction to a float.

Parameters:

src_n ( int ) –

Fraction numerator as int

src_d ( int ) –

Fraction denominator int


Gst.prototype.util_fraction_to_double

function Gst.prototype.util_fraction_to_double(src_n: Number, src_d: Number): {
    // javascript wrapper for 'gst_util_fraction_to_double'
}

Transforms a fraction to a Number.

Parameters:

src_n ( Number ) –

Fraction numerator as Number

src_d ( Number ) –

Fraction denominator Number


gst_util_gdouble_to_guint64

guint64
gst_util_gdouble_to_guint64 (gdouble value)

Parameters:

value

The gdouble value to convert guint64 double

Returns

value casted to guint64


Gst.util_gdouble_to_guint64

def Gst.util_gdouble_to_guint64 (value):
    #python wrapper for 'gst_util_gdouble_to_guint64'

Parameters:

value ( float ) –

The float value to convert guint64 double

Returns ( int ) –

value casted to int


Gst.prototype.util_gdouble_to_guint64

function Gst.prototype.util_gdouble_to_guint64(value: Number): {
    // javascript wrapper for 'gst_util_gdouble_to_guint64'
}

Parameters:

value ( Number ) –

The Number value to convert guint64 double

Returns ( Number ) –

value casted to Number


gst_util_get_object_array

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

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

Parameters:

object

the object to set the array to

name

the name of the property to set

array ( [out] ) –

a return GValueArray

Returns
No description available

Since : 1.12


Gst.util_get_object_array

def Gst.util_get_object_array (object, name):
    #python wrapper for 'gst_util_get_object_array'

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

Parameters:

object ( GObject.Object ) –

the object to set the array to

name ( str ) –

the name of the property to set

Returns a tuple made of:

( bool ) –
No description available
array ( GObject.ValueArray ) –
No description available

Since : 1.12


Gst.prototype.util_get_object_array

function Gst.prototype.util_get_object_array(object: GObject.Object, name: String): {
    // javascript wrapper for 'gst_util_get_object_array'
}

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

Parameters:

object ( GObject.Object ) –

the object to set the array to

name ( String ) –

the name of the property to set

Returns a tuple made of:

( Number ) –
No description available
array ( GObject.ValueArray ) –
No description available

Since : 1.12


gst_util_get_timestamp

GstClockTime
gst_util_get_timestamp ()

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

Returns

the timestamp


Gst.util_get_timestamp

def Gst.util_get_timestamp ():
    #python wrapper for 'gst_util_get_timestamp'

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

Returns ( int ) –

the timestamp


Gst.prototype.util_get_timestamp

function Gst.prototype.util_get_timestamp(): {
    // javascript wrapper for 'gst_util_get_timestamp'
}

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

Returns ( Number ) –

the timestamp


gst_util_greatest_common_divisor

gint
gst_util_greatest_common_divisor (gint a,
                                  gint b)

Calculates the greatest common divisor of a and b.

Parameters:

a

First value as gint

b

Second value as gint

Returns

Greatest common divisor of a and b


Gst.util_greatest_common_divisor

def Gst.util_greatest_common_divisor (a, b):
    #python wrapper for 'gst_util_greatest_common_divisor'

Calculates the greatest common divisor of a and b.

Parameters:

a ( int ) –

First value as int

b ( int ) –

Second value as int

Returns ( int ) –

Greatest common divisor of a and b


Gst.prototype.util_greatest_common_divisor

function Gst.prototype.util_greatest_common_divisor(a: Number, b: Number): {
    // javascript wrapper for 'gst_util_greatest_common_divisor'
}

Calculates the greatest common divisor of a and b.

Parameters:

a ( Number ) –

First value as Number

b ( Number ) –

Second value as Number

Returns ( Number ) –

Greatest common divisor of a and b


gst_util_greatest_common_divisor_int64

gint64
gst_util_greatest_common_divisor_int64 (gint64 a,
                                        gint64 b)

Calculates the greatest common divisor of a and b.

Parameters:

a

First value as gint64

b

Second value as gint64

Returns

Greatest common divisor of a and b


Gst.util_greatest_common_divisor_int64

def Gst.util_greatest_common_divisor_int64 (a, b):
    #python wrapper for 'gst_util_greatest_common_divisor_int64'

Calculates the greatest common divisor of a and b.

Parameters:

a ( int ) –

First value as int

b ( int ) –

Second value as int

Returns ( int ) –

Greatest common divisor of a and b


Gst.prototype.util_greatest_common_divisor_int64

function Gst.prototype.util_greatest_common_divisor_int64(a: Number, b: Number): {
    // javascript wrapper for 'gst_util_greatest_common_divisor_int64'
}

Calculates the greatest common divisor of a and b.

Parameters:

a ( Number ) –

First value as Number

b ( Number ) –

Second value as Number

Returns ( Number ) –

Greatest common divisor of a and b


gst_util_group_id_next

guint
gst_util_group_id_next ()

Return a constantly incrementing group id.

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

This function never returns GST_GROUP_ID_INVALID (which is 0)

Returns

A constantly incrementing unsigned integer, which might overflow back to 0 at some point.


Gst.util_group_id_next

def Gst.util_group_id_next ():
    #python wrapper for 'gst_util_group_id_next'

Return a constantly incrementing group id.

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

This function never returns Gst.GROUP_ID_INVALID (which is 0)

Returns ( int ) –

A constantly incrementing unsigned integer, which might overflow back to 0 at some point.


Gst.prototype.util_group_id_next

function Gst.prototype.util_group_id_next(): {
    // javascript wrapper for 'gst_util_group_id_next'
}

Return a constantly incrementing group id.

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

This function never returns Gst.GROUP_ID_INVALID (which is 0)

Returns ( Number ) –

A constantly incrementing unsigned integer, which might overflow back to 0 at some point.


gst_util_guint64_to_gdouble

gdouble
gst_util_guint64_to_gdouble (guint64 value)

Parameters:

value

The guint64 value to convert to double

Returns

value casted to gdouble


Gst.util_guint64_to_gdouble

def Gst.util_guint64_to_gdouble (value):
    #python wrapper for 'gst_util_guint64_to_gdouble'

Parameters:

value ( int ) –

The int value to convert to double

Returns ( float ) –

value casted to float


Gst.prototype.util_guint64_to_gdouble

function Gst.prototype.util_guint64_to_gdouble(value: Number): {
    // javascript wrapper for 'gst_util_guint64_to_gdouble'
}

Parameters:

value ( Number ) –

The Number value to convert to double

Returns ( Number ) –

value casted to Number


gst_util_seqnum_compare

gint32
gst_util_seqnum_compare (guint32 s1,
                         guint32 s2)

Compare two sequence numbers, handling wraparound.

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

Parameters:

s1

A sequence number.

s2

Another sequence number.

Returns

A negative number if s1 is before s2, 0 if they are equal, or a positive number if s1 is after s2.


Gst.util_seqnum_compare

def Gst.util_seqnum_compare (s1, s2):
    #python wrapper for 'gst_util_seqnum_compare'

Compare two sequence numbers, handling wraparound.

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

Parameters:

s1 ( int ) –

A sequence number.

s2 ( int ) –

Another sequence number.

Returns ( int ) –

A negative number if s1 is before s2, 0 if they are equal, or a positive number if s1 is after s2.


Gst.prototype.util_seqnum_compare

function Gst.prototype.util_seqnum_compare(s1: Number, s2: Number): {
    // javascript wrapper for 'gst_util_seqnum_compare'
}

Compare two sequence numbers, handling wraparound.

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

Parameters:

s1 ( Number ) –

A sequence number.

s2 ( Number ) –

Another sequence number.

Returns ( Number ) –

A negative number if s1 is before s2, 0 if they are equal, or a positive number if s1 is after s2.


gst_util_seqnum_next

guint32
gst_util_seqnum_next ()

Return a constantly incrementing sequence number.

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

This function never returns GST_SEQNUM_INVALID (which is 0).

Returns

A constantly incrementing 32-bit unsigned integer, which might overflow at some point. Use gst_util_seqnum_compare to make sure you handle wraparound correctly.


Gst.util_seqnum_next

def Gst.util_seqnum_next ():
    #python wrapper for 'gst_util_seqnum_next'

Return a constantly incrementing sequence number.

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

This function never returns Gst.SEQNUM_INVALID (which is 0).

Returns ( int ) –

A constantly incrementing 32-bit unsigned integer, which might overflow at some point. Use Gst.util_seqnum_compare to make sure you handle wraparound correctly.


Gst.prototype.util_seqnum_next

function Gst.prototype.util_seqnum_next(): {
    // javascript wrapper for 'gst_util_seqnum_next'
}

Return a constantly incrementing sequence number.

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

This function never returns Gst.SEQNUM_INVALID (which is 0).

Returns ( Number ) –

A constantly incrementing 32-bit unsigned integer, which might overflow at some point. Use Gst.prototype.util_seqnum_compare to make sure you handle wraparound correctly.


gst_util_set_object_arg

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

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

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

Parameters:

object

the object to set the argument of

name

the name of the argument to set

value

the string value to set


Gst.util_set_object_arg

def Gst.util_set_object_arg (object, name, value):
    #python wrapper for 'gst_util_set_object_arg'

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

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

Parameters:

object ( GObject.Object ) –

the object to set the argument of

name ( str ) –

the name of the argument to set

value ( str ) –

the string value to set


Gst.prototype.util_set_object_arg

function Gst.prototype.util_set_object_arg(object: GObject.Object, name: String, value: String): {
    // javascript wrapper for 'gst_util_set_object_arg'
}

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

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

Parameters:

object ( GObject.Object ) –

the object to set the argument of

name ( String ) –

the name of the argument to set

value ( String ) –

the string value to set


gst_util_set_object_array

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

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

Parameters:

object

the object to set the array to

name

the name of the property to set

array

a GValueArray containing the values

Returns
No description available

Since : 1.12


Gst.util_set_object_array

def Gst.util_set_object_array (object, name, array):
    #python wrapper for 'gst_util_set_object_array'

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

Parameters:

object ( GObject.Object ) –

the object to set the array to

name ( str ) –

the name of the property to set

array ( GObject.ValueArray ) –

a GObject.ValueArray containing the values

Returns ( bool ) –
No description available

Since : 1.12


Gst.prototype.util_set_object_array

function Gst.prototype.util_set_object_array(object: GObject.Object, name: String, array: GObject.ValueArray): {
    // javascript wrapper for 'gst_util_set_object_array'
}

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

Parameters:

object ( GObject.Object ) –

the object to set the array to

name ( String ) –

the name of the property to set

array ( GObject.ValueArray ) –

a GObject.ValueArray containing the values

Returns ( Number ) –
No description available

Since : 1.12


gst_util_set_value_from_string

gst_util_set_value_from_string (GValue * value,
                                const gchar * value_str)

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

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

Parameters:

value ( [out] ) –

the value to set

value_str

the string to get the value from


Gst.util_set_value_from_string

def Gst.util_set_value_from_string (value_str):
    #python wrapper for 'gst_util_set_value_from_string'

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

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

Parameters:

value_str ( str ) –

the string to get the value from


Gst.prototype.util_set_value_from_string

function Gst.prototype.util_set_value_from_string(value_str: String): {
    // javascript wrapper for 'gst_util_set_value_from_string'
}

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

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

Parameters:

value_str ( String ) –

the string to get the value from


gst_util_uint64_scale

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

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

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

Parameters:

val

the number to scale

num

the numerator of the scale ratio

denom

the denominator of the scale ratio

Returns

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer it is truncated. See also gst_util_uint64_scale_round, gst_util_uint64_scale_ceil, gst_util_uint64_scale_int, gst_util_uint64_scale_int_round, gst_util_uint64_scale_int_ceil.


Gst.util_uint64_scale

def Gst.util_uint64_scale (val, num, denom):
    #python wrapper for 'gst_util_uint64_scale'

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

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

Parameters:

val ( int ) –

the number to scale

num ( int ) –

the numerator of the scale ratio

denom ( int ) –

the denominator of the scale ratio

Returns ( int ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer it is truncated. See also Gst.util_uint64_scale_round, Gst.util_uint64_scale_ceil, Gst.util_uint64_scale_int, Gst.util_uint64_scale_int_round, Gst.util_uint64_scale_int_ceil.


Gst.prototype.util_uint64_scale

function Gst.prototype.util_uint64_scale(val: Number, num: Number, denom: Number): {
    // javascript wrapper for 'gst_util_uint64_scale'
}

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

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

Parameters:

val ( Number ) –

the number to scale

num ( Number ) –

the numerator of the scale ratio

denom ( Number ) –

the denominator of the scale ratio

Returns ( Number ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer it is truncated. See also Gst.prototype.util_uint64_scale_round, Gst.prototype.util_uint64_scale_ceil, Gst.prototype.util_uint64_scale_int, Gst.prototype.util_uint64_scale_int_round, Gst.prototype.util_uint64_scale_int_ceil.


gst_util_uint64_scale_ceil

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

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

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

Parameters:

val

the number to scale

num

the numerator of the scale ratio

denom

the denominator of the scale ratio

Returns

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also gst_util_uint64_scale, gst_util_uint64_scale_round, gst_util_uint64_scale_int, gst_util_uint64_scale_int_round, gst_util_uint64_scale_int_ceil.


Gst.util_uint64_scale_ceil

def Gst.util_uint64_scale_ceil (val, num, denom):
    #python wrapper for 'gst_util_uint64_scale_ceil'

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

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

Parameters:

val ( int ) –

the number to scale

num ( int ) –

the numerator of the scale ratio

denom ( int ) –

the denominator of the scale ratio

Returns ( int ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also Gst.util_uint64_scale, Gst.util_uint64_scale_round, Gst.util_uint64_scale_int, Gst.util_uint64_scale_int_round, Gst.util_uint64_scale_int_ceil.


Gst.prototype.util_uint64_scale_ceil

function Gst.prototype.util_uint64_scale_ceil(val: Number, num: Number, denom: Number): {
    // javascript wrapper for 'gst_util_uint64_scale_ceil'
}

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

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

Parameters:

val ( Number ) –

the number to scale

num ( Number ) –

the numerator of the scale ratio

denom ( Number ) –

the denominator of the scale ratio

Returns ( Number ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also Gst.prototype.util_uint64_scale, Gst.prototype.util_uint64_scale_round, Gst.prototype.util_uint64_scale_int, Gst.prototype.util_uint64_scale_int_round, Gst.prototype.util_uint64_scale_int_ceil.


gst_util_uint64_scale_int

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

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

Parameters:

val

guint64 (such as a GstClockTime) to scale.

num

numerator of the scale factor.

denom

denominator of the scale factor.

Returns

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is truncated. See also gst_util_uint64_scale_int_round, gst_util_uint64_scale_int_ceil, gst_util_uint64_scale, gst_util_uint64_scale_round, gst_util_uint64_scale_ceil.


Gst.util_uint64_scale_int

def Gst.util_uint64_scale_int (val, num, denom):
    #python wrapper for 'gst_util_uint64_scale_int'

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

Parameters:

val ( int ) –

guint64 (such as a int) to scale.

num ( int ) –

numerator of the scale factor.

denom ( int ) –

denominator of the scale factor.

Returns ( int ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is truncated. See also Gst.util_uint64_scale_int_round, Gst.util_uint64_scale_int_ceil, Gst.util_uint64_scale, Gst.util_uint64_scale_round, Gst.util_uint64_scale_ceil.


Gst.prototype.util_uint64_scale_int

function Gst.prototype.util_uint64_scale_int(val: Number, num: Number, denom: Number): {
    // javascript wrapper for 'gst_util_uint64_scale_int'
}

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

Parameters:

val ( Number ) –

guint64 (such as a Number) to scale.

num ( Number ) –

numerator of the scale factor.

denom ( Number ) –

denominator of the scale factor.

Returns ( Number ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is truncated. See also Gst.prototype.util_uint64_scale_int_round, Gst.prototype.util_uint64_scale_int_ceil, Gst.prototype.util_uint64_scale, Gst.prototype.util_uint64_scale_round, Gst.prototype.util_uint64_scale_ceil.


gst_util_uint64_scale_int_ceil

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

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

Parameters:

val

guint64 (such as a GstClockTime) to scale.

num

numerator of the scale factor.

denom

denominator of the scale factor.

Returns

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also gst_util_uint64_scale_int, gst_util_uint64_scale_int_round, gst_util_uint64_scale, gst_util_uint64_scale_round, gst_util_uint64_scale_ceil.


Gst.util_uint64_scale_int_ceil

def Gst.util_uint64_scale_int_ceil (val, num, denom):
    #python wrapper for 'gst_util_uint64_scale_int_ceil'

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

Parameters:

val ( int ) –

guint64 (such as a int) to scale.

num ( int ) –

numerator of the scale factor.

denom ( int ) –

denominator of the scale factor.

Returns ( int ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also Gst.util_uint64_scale_int, Gst.util_uint64_scale_int_round, Gst.util_uint64_scale, Gst.util_uint64_scale_round, Gst.util_uint64_scale_ceil.


Gst.prototype.util_uint64_scale_int_ceil

function Gst.prototype.util_uint64_scale_int_ceil(val: Number, num: Number, denom: Number): {
    // javascript wrapper for 'gst_util_uint64_scale_int_ceil'
}

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

Parameters:

val ( Number ) –

guint64 (such as a Number) to scale.

num ( Number ) –

numerator of the scale factor.

denom ( Number ) –

denominator of the scale factor.

Returns ( Number ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also Gst.prototype.util_uint64_scale_int, Gst.prototype.util_uint64_scale_int_round, Gst.prototype.util_uint64_scale, Gst.prototype.util_uint64_scale_round, Gst.prototype.util_uint64_scale_ceil.


gst_util_uint64_scale_int_round

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

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

Parameters:

val

guint64 (such as a GstClockTime) to scale.

num

numerator of the scale factor.

denom

denominator of the scale factor.

Returns

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also gst_util_uint64_scale_int, gst_util_uint64_scale_int_ceil, gst_util_uint64_scale, gst_util_uint64_scale_round, gst_util_uint64_scale_ceil.


Gst.util_uint64_scale_int_round

def Gst.util_uint64_scale_int_round (val, num, denom):
    #python wrapper for 'gst_util_uint64_scale_int_round'

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

Parameters:

val ( int ) –

guint64 (such as a int) to scale.

num ( int ) –

numerator of the scale factor.

denom ( int ) –

denominator of the scale factor.

Returns ( int ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also Gst.util_uint64_scale_int, Gst.util_uint64_scale_int_ceil, Gst.util_uint64_scale, Gst.util_uint64_scale_round, Gst.util_uint64_scale_ceil.


Gst.prototype.util_uint64_scale_int_round

function Gst.prototype.util_uint64_scale_int_round(val: Number, num: Number, denom: Number): {
    // javascript wrapper for 'gst_util_uint64_scale_int_round'
}

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

Parameters:

val ( Number ) –

guint64 (such as a Number) to scale.

num ( Number ) –

numerator of the scale factor.

denom ( Number ) –

denominator of the scale factor.

Returns ( Number ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also Gst.prototype.util_uint64_scale_int, Gst.prototype.util_uint64_scale_int_ceil, Gst.prototype.util_uint64_scale, Gst.prototype.util_uint64_scale_round, Gst.prototype.util_uint64_scale_ceil.


gst_util_uint64_scale_round

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

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

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

Parameters:

val

the number to scale

num

the numerator of the scale ratio

denom

the denominator of the scale ratio

Returns

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also gst_util_uint64_scale, gst_util_uint64_scale_ceil, gst_util_uint64_scale_int, gst_util_uint64_scale_int_round, gst_util_uint64_scale_int_ceil.


Gst.util_uint64_scale_round

def Gst.util_uint64_scale_round (val, num, denom):
    #python wrapper for 'gst_util_uint64_scale_round'

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

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

Parameters:

val ( int ) –

the number to scale

num ( int ) –

the numerator of the scale ratio

denom ( int ) –

the denominator of the scale ratio

Returns ( int ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also Gst.util_uint64_scale, Gst.util_uint64_scale_ceil, Gst.util_uint64_scale_int, Gst.util_uint64_scale_int_round, Gst.util_uint64_scale_int_ceil.


Gst.prototype.util_uint64_scale_round

function Gst.prototype.util_uint64_scale_round(val: Number, num: Number, denom: Number): {
    // javascript wrapper for 'gst_util_uint64_scale_round'
}

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

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

Parameters:

val ( Number ) –

the number to scale

num ( Number ) –

the numerator of the scale ratio

denom ( Number ) –

the denominator of the scale ratio

Returns ( Number ) –

val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also Gst.prototype.util_uint64_scale, Gst.prototype.util_uint64_scale_ceil, Gst.prototype.util_uint64_scale_int, Gst.prototype.util_uint64_scale_int_round, Gst.prototype.util_uint64_scale_int_ceil.


Function Macros

GDOUBLE_FROM_BE

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

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

Parameters:

val

value


GDOUBLE_FROM_LE

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

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

Parameters:

val

value


GDOUBLE_TO_BE

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

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

Parameters:

val

value


GDOUBLE_TO_LE

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

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

Parameters:

val

value


GFLOAT_FROM_BE

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

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

Parameters:

val

value


GFLOAT_FROM_LE

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

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

Parameters:

val

value


GFLOAT_TO_BE

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

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

Parameters:

val

value


GFLOAT_TO_LE

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

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

Parameters:

val

value


GST_CALL_PARENT

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

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

Parameters:

parent_class_cast

the name of the class cast macro for the parent type

name

name of the function to call

args

arguments enclosed in '( )'


GST_CALL_PARENT_WITH_DEFAULT

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

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

Parameters:

parent_class_cast

the name of the class cast macro for the parent type

name

name of the function to call

args

arguments enclosed in '( )'

def_return

default result


GST_READ_UINT16_BE

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

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

Parameters:

data

memory location


GST_READ_UINT16_LE

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

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

Parameters:

data

memory location


GST_READ_UINT24_BE

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

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

Parameters:

data

memory location


GST_READ_UINT24_LE

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

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

Parameters:

data

memory location


GST_READ_UINT32_BE

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

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

Parameters:

data

memory location


GST_READ_UINT32_LE

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

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

Parameters:

data

memory location


GST_READ_UINT64_BE

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

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

Parameters:

data

memory location


GST_READ_UINT64_LE

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

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

Parameters:

data

memory location


GST_READ_UINT8

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

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

Parameters:

data

memory location


GST_ROUND_DOWN_128

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_16

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_2

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_32

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_4

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_64

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_8

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

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

Parameters:

num

integer value to round down


GST_ROUND_DOWN_N

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

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

Parameters:

num

integrer value to round down

align

a power of two to round down to


GST_ROUND_UP_128

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_16

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_2

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_32

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_4

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_64

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_8

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

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

Parameters:

num

integer value to round up


GST_ROUND_UP_N

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

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

Parameters:

num

integrer value to round up

align

a power of two to round up to


GST_WRITE_UINT16_BE

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

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

Parameters:

data

memory location

val

value to store


GST_WRITE_UINT16_LE

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

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

Parameters:

data

memory location

val

value to store


GST_WRITE_UINT24_BE

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

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

Parameters:

data

memory location

num

value to store


GST_WRITE_UINT24_LE

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

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

Parameters:

data

memory location

num

value to store


GST_WRITE_UINT32_BE

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

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

Parameters:

data

memory location

val

value to store


GST_WRITE_UINT32_LE

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

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

Parameters:

data

memory location

val

value to store


GST_WRITE_UINT64_BE

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

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

Parameters:

data

memory location

val

value to store


GST_WRITE_UINT64_LE

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

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

Parameters:

data

memory location

val

value to store


GST_WRITE_UINT8

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

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

Parameters:

data

memory location

num

value to store


_GST_FAST_READ

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

_GST_FAST_READ_SWAP

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

_GST_FAST_WRITE

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

_GST_FAST_WRITE_SWAP

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

_GST_GET

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

_GST_PUT

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

_GST_READ_UINT16_BE

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

_GST_READ_UINT16_LE

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

_GST_READ_UINT24_BE

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

_GST_READ_UINT24_LE

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

_GST_READ_UINT32_BE

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

_GST_READ_UINT32_LE

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

_GST_READ_UINT64_BE

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

_GST_READ_UINT64_LE

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

gst_gdouble_to_guint64

#define gst_gdouble_to_guint64(value)   gst_util_gdouble_to_guint64(value)

Convert value to a guint64.

Parameters:

value

the gdouble value to convert

Returns

value converted to a guint64.


gst_guint64_to_gdouble

#define gst_guint64_to_gdouble(value)   gst_util_guint64_to_gdouble(value)

Convert value to a gdouble.

Parameters:

value

the guint64 value to convert

Returns

value converted to a gdouble.


Enumerations

GstSearchMode

The different search modes.

Members

GST_SEARCH_MODE_EXACT (0) –

Only search for exact matches.

GST_SEARCH_MODE_BEFORE (1) –

Search for an exact match or the element just before.

GST_SEARCH_MODE_AFTER (2) –

Search for an exact match or the element just after.


Gst.SearchMode

The different search modes.

Members

Gst.SearchMode.EXACT (0) –

Only search for exact matches.

Gst.SearchMode.BEFORE (1) –

Search for an exact match or the element just before.

Gst.SearchMode.AFTER (2) –

Search for an exact match or the element just after.


Gst.SearchMode

The different search modes.

Members

Gst.SearchMode.EXACT (0) –

Only search for exact matches.

Gst.SearchMode.BEFORE (1) –

Search for an exact match or the element just before.

Gst.SearchMode.AFTER (2) –

Search for an exact match or the element just after.


Constants

GST_GROUP_ID_INVALID

#define GST_GROUP_ID_INVALID (0)

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

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


Gst.GROUP_ID_INVALID

A value which is guaranteed to never be returned by Gst.util_group_id_next.

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


Gst.GROUP_ID_INVALID

A value which is guaranteed to never be returned by Gst.prototype.util_group_id_next.

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


GST_SEQNUM_INVALID

#define GST_SEQNUM_INVALID (0)

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

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


Gst.SEQNUM_INVALID

A value which is guaranteed to never be returned by Gst.util_seqnum_next.

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


Gst.SEQNUM_INVALID

A value which is guaranteed to never be returned by Gst.prototype.util_seqnum_next.

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


The results of the search are