GStreamer学习十一（GSteamer常用工具）

最新推荐文章于 2023-08-29 23:12:00 发布

冰山一脚2013

最新推荐文章于 2023-08-29 23:12:00 发布

阅读量1.2k

点赞数

分类专栏： GStreamer

原文链接：https://gstreamer.freedesktop.org/

版权

GStreamer 专栏收录该内容

28 篇文章 23 订阅

订阅专栏

功能

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）

计算值xy的线性回归并将结果放置在m_num，m_denom，b和xbase中，表示函数y（x）= m_num / m_denom *（x-xbase）+ b与所有点的距离最小二乘x和y。

r_squared将包含其余错误。

如果temp不为NULL，它将用作该函数的临时空间，在这种情况下，该函数将在没有任何分配的情况下工作。如果temp为 NULL，则会进行分配。temp至少应分配与xy相同的内存量，即2 n sizeof（GstClockTime）。

此函数假定（x，y）值之间存在合理的较大差异。如果相邻值之间的差异太小（由于无法在计算过程中表示子整数值），它将无法计算出准确的结果。

参数：

xy – 对（x，y）值

temp – 该功能使用的临时暂存空间

n – （x，y）对的数量

m_num （ [ out ] ）– 计算斜率的分子

m_denom （ [ out ] ）– 计算斜率的分母

b （ [ out ] ）– Y轴偏移

xbase （ [ out ] ）– X轴偏移

r_squared （ [ out ] ）– R平方

返回值– 如果成功计算了线性回归，则为TRUE

从：1.12

gst_parse_bin_from_description

GstElement *

gst_parse_bin_from_description（const gchar * bin_description，

gboolean ghost_unlinked_pads，

GError **错误）

这是gst_parse_launch的便捷包装，用于根据gst-launch样式的管道描述创建 GstBin。有关语法的详细信息，请参见 gst_parse_launch和gst-launch手册页。可以自动创建垃圾箱上用于未链接源垫或沉垫的鬼垫（但每个方向最多只能创建一个幻像垫；如果您希望有多个未链接的源垫或多个未链接的沉垫并希望它们全部使用）鬼影，则必须自己创建鬼影垫）。

参数：

bin_description – 命令行描述垃圾桶

ghost_unlinked_pads – 是否自动为垃圾箱中未链接的源极或接收器创建幻像垫

error – 没有可用的描述

返回（ [[ 转移：浮动 ] [ Gst.Bin 类型 ] [ 可为空 ] ）– 一个新创建的bin，如果发生错误，则为NULL。

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）

参数：

bin_description – 命令行描述垃圾桶

ghost_unlinked_pads – 是否自动为垃圾箱中未链接的源极或接收器创建幻像垫

context （ [ 转移：无 ] [ 允许-无 ] ）– 使用gst_parse_context_new分配的解析上下文，或者为NULL

flags – 解析选项，或GST_PARSE_FLAG_NONE

error – 没有可用的描述

返回（ [[ 传递：浮动 ] [ 类型 Gst.Element] [ 可为空 ] ）– 一个新创建的元素，除非已传递GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS，否则保证为bin；如果发生错误，则为 NULL。

gst_state_change_get_name

const gchar *

gst_state_change_get_name（GstStateChange transition）

获取一个表示给定状态转换的字符串。

参数：

transition – 一个GstStateChange得到的名称。

返回（ [ 转移：无 ] ）– 一个带有状态结果名称的字符串。从：1.14

gst_type_is_plugin_api

gboolean

gst_type_is_plugin_api（GType type，

GstPluginAPIFlags *flags）

检查类型是否为插件API。有关详细信息，请参见gst_type_mark_as_plugin_api。

参数：

type – GType

flags （ [ out ] [ nullable ] ）– 插件标记了什么GstPluginAPIFlags

返回 – TRUE，如果类型的插件API或FALSE否则。

从：1.18

gst_type_mark_as_plugin_api

gst_type_mark_as_plugin_api（GType type，

GstPluginAPIFlags flags）

将类型标记为插件API。应该class_init通过属性，信号或填充模板来公开新类型的元素（即，枚举，标志或内部GObject）。

插件公开的类型不会自动添加到文档中，因为它们可能源自另一个库，在这种情况下，应通过该库进行记录。

通过将类型标记为插件API，它将包含在定义它的插件文档中。

参数：

type – GType

flags – 一组GstPluginAPIFlags以进一步通知缓存生成。

从：1.18

gst_util_array_binary_search

gpointer

gst_util_array_binary_search（gpointer array，

guint num_elements，

gsize element_size，

GCompareDataFunc search_func，

GstSearchMode mode，

gconstpointer search_data，

gpointer user_data）

内部搜索阵列用于search_data通过使用比较函数 search_func。数组必须升序排列。

由于总是将search_data作为第二个参数传递给search_func，因此不需要search_data与数组元素具有相同的类型。

此搜索功能的复杂度为O（log（num_elements））。

参数：

array – 排序的输入数组

num_elements – 数组中元素的数量

element_size – 每个元素的大小（以字节为单位）

search_func （ [ 作用域调用 ] ）– 比较两个元素的函数，search_data将始终作为第二个参数传递

mode – 应使用的搜索模式

search_data – 应该找到的元素

user_data （ [ 关闭 ] ）– 数据传递给search_func

返回（ [ 传输：无 ] [ 可为空 ] ）–

找到的元素的地址；如果未找到任何内容，则为NULL

gst_util_double_to_fraction

gst_util_double_to_fraction（gdouble src，

gint * dest_n，

gint * dest_d）

将gdouble转换为分数并简化结果。

参数：

src – gdouble进行转换

dest_n （ [ out ] ）– 指向保存结果分子的gint的指针

dest_d （ [ out ] ）– 指向包含结果分母的gint的指针

gst_util_dump_buffer

gst_util_dump_buffer（GstBuffer * buf）

将缓冲存储器转储为十六进制表示形式。对于调试很有用。

参数：

buf – 一个GstBuffer，其内存转储

从：1.14

gst_util_dump_mem

gst_util_dump_mem（const guchar * mem，

guint size）

将内存块转储为十六进制表示形式。对于调试很有用。

参数：

mem （ [ 数组长度=大小] ）– 指向要转储的内存的指针

size – 要转储的内存块的大小

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）

将分数a_n / @ a_d和b_n / @ b_d相加，并将结果存储在res_n和res_d中。

参数：

a_n – 值的分子

a_d – 第一价值的分母

b_n – 分子第二值

b_d – 分数值的分母

res_n （ [ out ] ）– 指向gint的指针以保存结果分子

res_d （ [ out ] ）– 指向gint的指针以保存结果分母

返回 – 溢出时为FALSE，否则为TRUE。

gst_util_fraction_compare

GINT

gst_util_fraction_compare（GINT A_N，

GINT A_D，

GINT B_N，

GINT B_D）

比较分数a_n / @ a_d 和b_n / @ b_d，如果a <b，则返回-1；如果a = b，则返回0；如果a> b，则返回1。

参数：

a_n – 值的分子

a_d – 第一价值的分母

b_n – 分子第二值

b_d – 分数值的分母

返回 – -1如果a <b; 如果a = b，则为0; 如果a> b，则为1。

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）

将分数a_n / @ a_d和b_n / @ b_d相乘，并将结果存储在res_n和res_d中。

参数：

a_n – 值的分子

a_d – 第一价值的分母

b_n – 分子第二值

b_d – 分数值的分母

res_n （ [ out ] ）– 指向gint的指针以保存结果分子

res_d （ [ out ] ）– 指向gint的指针以保存结果分母

返回 – 溢出时为FALSE，否则为TRUE。

gst_util_fraction_to_double

gst_util_fraction_to_double（gint src_n，

gint src_d，

gdouble * dest）

将小数转换为gdouble。

参数：

src_n – 分数分子为gint

src_d – 分数的分母GINT

dest （ [ out ] ）– 指向结果的gdouble的指针

gst_util_gdouble_to_guint64

guint64

gst_util_gdouble_to_guint64（gdouble value）

参数：

value – 该修正gdouble值转换guint64双

返回 – 值转换为guint64

gst_util_get_object_array

gboolean

gst_util_get_object_array（GObject * object，

const gchar *name，

GValueArray **array）

获取类型为GST_TYPE_ARRAY的属性，并将其转换为 GValueArray。这允许语言绑定获取GST_TYPE_ARRAY属性，否则该属性将不可访问。

参数：

object – 将数组设置为的对象

name – 要设置的属性的名称

array （ [ out ] ）– 返回GValueArray

返回 – 没有可用的描述

从：1.12

gst_util_get_timestamp

GstClockTime

gst_util_get_timestamp（）

获取时间戳作为GstClockTime，用于间隔测量。不应以任何其他方式解释时间戳。

返回 – 时间戳

gst_util_greatest_common_divisor

gint

gst_util_greatest_common_divisor（gint a，

gint b）

计算a 和b的最大公约数。

参数：

a – 第一价值为金光

b – 第二值作为闪光

返回 – a和b的最大公约数

gst_util_greatest_common_divisor_int64

gint64

gst_util_greatest_common_divisor_int64（gint64 a，

gint64 b）

计算a 和b的最大公约数。

参数：

a – 第一个值作为gint64

b – 第二个值是gint64

返回 – a和b的最大公约数

gst_util_group_id_next

guint

gst_util_group_id_next（）

返回一个不断增加的组ID。

此函数用于为流启动事件生成新的组ID。

此函数从不返回GST_GROUP_ID_INVALID（为0）

返回 – 一个不断增加的无符号整数，该整数有时可能溢出到0。

gst_util_guint64_to_gdouble

gdouble

gst_util_guint64_to_gdouble（guint64 value）

参数：

value – 该guint64值转换为加倍

返回 – 赋予gdouble的价值

gst_util_seqnum_compare

gint32

gst_util_seqnum_compare（guint32 s1，

guint32 s2）

比较两个序列号，处理环绕。

当前实现只返回（gint32）（@ s1- s2）。

参数：

s1 – 序列号。

s2 – 另一个序列号。

返回 – 负数如果S1是前S2，0，如果它们相等，或正数，如果S1是后S2。

gst_util_seqnum_next

guint32

gst_util_seqnum_next（）

返回一个不断递增的序列号。

该函数在GStreamer内部使用，能够确定哪些事件和消息“相同”。例如，元素可以将段完成消息上的序列号设置为与上一次查找事件的序列号相同，以指示事件和消息对应于同一段。

此函数从不返回GST_SEQNUM_INVALID（为0）。

返回 – 一个不断增加的32位无符号整数，该整数可能在某个时候溢出。使用gst_util_seqnum_compare确保正确处理环绕。

gst_util_set_object_arg

gst_util_set_object_arg（GObject * object，

const gchar *name，

const gchar *value）

将字符串值转换为objects参数的类型，并为其设置参数。

请注意，如果对象没有名为name的属性，或者无法将value转换为属性的类型，则此函数将静默返回。

参数：

object – 设置参数的对象

name – 要设置的参数名称

value – 要设置的字符串值

gst_util_set_object_array

gboolean

gst_util_set_object_array（GObject * object，

const gchar *name，

const GValueArray *value）

将GValueArray传输到GST_TYPE_ARRAY并在指定的属性名称上设置此值。这允许语言绑定设置GST_TYPE_ARRAY属性，否则该属性将不可访问。

参数：

object – 将数组设置为的对象

name – 要设置的属性的名称

array – 包含值的GValueArray

返回 – 没有可用的描述

从：1.12

gst_util_set_value_from_string

gst_util_set_value_from_string（GValue * value，

const gchar * value_str）

将字符串转换为值的类型并使用它来设置值。

请注意，此函数很危险，因为如果转换成功或无效，它不会返回任何指示。

参数：

value （ [ out ] ）– 要设置的值

value_str – 从中获取值的字符串

gst_util_uint64_scale

guint64

gst_util_uint64_scale（guint64 val，

guint64 num，

guint64 denom）

用有理数num / denom缩放val，避免上溢和下溢，并且不会损失精度。

如果val和num都大于G_MAXUINT32，则此函数可能会非常慢。

参数：

val – 要缩放的数字

num – 缩放比例的分子

denom – 比例比例的分母

返回 – val * num / denom。发生溢出时，此函数返回G_MAXUINT64。如果结果不能精确表示为整数，则将其截断。另请参见 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_ceil

guint64

gst_util_uint64_scale_ceil（guint64 val，

guint64 num，

guint64 denom）

用有理数num / denom缩放val，避免上溢和下溢，并且不会损失精度。

如果val和num都大于G_MAXUINT32，则此函数可能会非常慢。

参数：

val – 要缩放的数字

num – 缩放比例的分子

denom – 比例比例的分母

返回 – val * num / denom。发生溢出时，此函数返回G_MAXUINT64。如果结果不能完全表示为整数，则将其四舍五入。另请参见 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_int

guint64

gst_util_uint64_scale_int（guint64 val，

gint num，

gint denom）

用有理数num / denom缩放val，避免上溢和下溢，并且不会损失精度。 num必须为非负且 denom必须为正。

参数：

val – guint64（例如GstClockTime）进行缩放。

num – 比例因子的分子。

denom – 比例因子的分母。

返回 – val * num / denom。发生溢出时，此函数返回G_MAXUINT64。如果结果不能精确表示为整数，则将其截断。另请参见 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_ceil

guint64

gst_util_uint64_scale_int_ceil（guint64 val，

gint num，

gint denom）

用有理数num / denom缩放val，避免上溢和下溢，并且不会损失精度。 num必须为非负且 denom必须为正。

参数：

val – guint64（例如GstClockTime）进行缩放。

num – 比例因子的分子。

denom – 比例因子的分母。

返回 – val * num / denom。发生溢出时，此函数返回G_MAXUINT64。如果结果不能完全表示为整数，则将其四舍五入。另请参见 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_round

guint64

gst_util_uint64_scale_int_round（guint64 val，

gint num，

gint denom）

用有理数num / denom缩放val，避免上溢和下溢，并且不会损失精度。 num必须为非负且 denom必须为正。

参数：

val – guint64（例如GstClockTime）进行缩放。

num – 比例因子的分子。

denom – 比例因子的分母。

返回 – val * num / denom。发生溢出时，此函数返回G_MAXUINT64。如果结果不能精确表示为整数，则将其舍入为最接近的整数（半数情况将舍入）。另请参见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_round

guint64

gst_util_uint64_scale_round（guint64 val，

guint64 num，

guint64 denom）

用有理数num / denom缩放val，避免上溢和下溢，并且不会损失精度。

如果val和num都大于G_MAXUINT32，则此函数可能会非常慢。

参数：

val – 要缩放的数字

num – 缩放比例的分子

denom – 比例比例的分母

返回 – val * num / denom。发生溢出时，此函数返回G_MAXUINT64。如果结果不能精确表示为整数，则将其舍入为最接近的整数（半数情况将舍入）。另请参见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。

功能宏

GDOUBLE_FROM_BE

＃define GDOUBLE_FROM_BE（val）（GDOUBLE_TO_BE（val））

将64位浮点值（double）从大端字节顺序转换为本机字节顺序。

参数：

val – 值

GDOUBLE_FROM_LE

＃define GDOUBLE_FROM_LE（val）（GDOUBLE_TO_LE（val））

将64位浮点值（双精度）从小尾数字节顺序转换为本机字节顺序。

参数：

val – 值

GDOUBLE_TO_BE

＃define GDOUBLE_TO_BE(val）（GDOUBLE_SWAP_LE_BE（val））

将64位浮点值（双精度）从本机字节顺序转换为大字节序字节顺序。

参数：

val – 值

GDOUBLE_TO_LE

＃define GDOUBLE_TO_LE（val）（（gdouble）（val））

将本机字节顺序的64位浮点值（双精度）转换为小端字节顺序。

参数：

val – 值

GFLOAT_FROM_BE

＃define GFLOAT_FROM_BE（val）（GFLOAT_TO_BE（val））

将32位浮点值（float）从大端字节顺序转换为本机字节顺序。

参数：

val – 值

GFLOAT_FROM_LE

＃define GFLOAT_FROM_LE（val）（GFLOAT_TO_LE（val））

将32位浮点值（float）从小端字节顺序转换为本地字节顺序。

参数：

val – 值

GFLOAT_TO_BE

＃define GFLOAT_TO_BE（val）（GFLOAT_SWAP_LE_BE（val））

将32位浮点值（float）从本机字节顺序转换为大端字节顺序。

参数：

val – 值

GFLOAT_TO_LE

＃define GFLOAT_TO_LE（val）（（gfloat）（val））

将32位浮点值（float）从本机字节顺序转换为小尾数字节顺序。

参数：

val – 值

GST_CALL_PARENT

＃define GST_CALL_PARENT（parent_class_cast，name，option）\

（（（parent_class_cast（parent_class）-> name！= NULL）？

parent_class_cast（parent_class）-> name args：（void）0）

只需调用父处理程序即可。假定存在一个名为parent_class的变量，该变量指向（duh！）父类。请注意，此宏不可用于返回某些内容的事物，请使用_WITH_DEFAULT版本

参数：

parent_class_cast – 父类型的类强制转换宏的名称

name – 调用函数的名称

args – 括在'（）'中的参数

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）

与GST_CALL_PARENT相同，但在没有实现的情况下，其评估结果为def_return。

参数：

parent_class_cast – 父类型的类强制转换宏的名称

name – 调用函数的名称

args – 括在'（）'中的参数

def_return – 默认结果

GST_READ_UINT16_BE

#define GST_READ_UINT16_BE（data）_GST_FAST_READ（16，data）

从内存缓冲区中以大端格式读取16位无符号整数值。

参数：

data –

记忆位置

GST_READ_UINT16_LE

＃define GST_READ_UINT16_LE（data）_GST_FAST_READ_SWAP（16，data）

从内存缓冲区中以Little Endian格式读取16位无符号整数值。

参数：

data – 记忆位置

GST_READ_UINT24_BE

＃define GST_READ_UINT24_BE（data）__gst_slow_read24_be（（const guint8 *）（data））

从内存缓冲区中以大端格式读取24位无符号整数值。

参数：

data – 记忆位置

GST_READ_UINT24_LE

＃define GST_READ_UINT24_LE（data）__gst_slow_read24_le（（const guint8 *）（data））

从内存缓冲区中以Little Endian格式读取24位无符号整数值。

参数：

data – 记忆位置

GST_READ_UINT32_BE

＃define GST_READ_UINT32_BE（data）_GST_FAST_READ（32，data）

从内存缓冲区中读取一个32位无符号整数（big endian格式）。

参数：

data – 记忆位置

GST_READ_UINT32_LE

＃定义GST_READ_UINT32_LE（data）_GST_FAST_READ_SWAP（32，data）

从内存缓冲区中以Little Endian格式读取32位无符号整数值。

参数：

data – 记忆位置

GST_READ_UINT64_BE

＃定义GST_READ_UINT64_BE（data）_GST_FAST_READ（64，data）

从内存缓冲区中以大端格式读取64位无符号整数值。

参数：

data – 记忆位置

GST_READ_UINT64_LE

＃定义GST_READ_UINT64_LE（data）_GST_FAST_READ_SWAP（64，data）

从内存缓冲区中以Little Endian格式读取64位无符号整数值。

参数：

data –

记忆位置

GST_READ_UINT8

＃定义GST_READ_UINT8（data）（_GST_GET（data，0，8，0））

从内存缓冲区读取一个8位无符号整数值。

参数：

data – 记忆位置

GST_ROUND_DOWN_128

＃define GST_ROUND_DOWN_128（num）（（num）＆（〜127））

将整数值四舍五入为下一个128的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_DOWN_16

＃define GST_ROUND_DOWN_16（num）（（num）＆（〜15））

将整数值四舍五入到下一个16的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_DOWN_2

＃define GST_ROUND_DOWN_2（num）（（num）＆（〜1））

将整数值向下舍入为2的下一个倍数。

参数：

num – 整数值四舍五入

GST_ROUND_DOWN_32

＃定义GST_ROUND_DOWN_32（num）（（num）＆（〜31））

将整数值四舍五入到下一个32的倍数。

参数：

num –

整数值四舍五入

GST_ROUND_DOWN_4

＃define GST_ROUND_DOWN_4（num）（（num）＆（〜3））

将整数值四舍五入到下一个4的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_DOWN_64

＃define GST_ROUND_DOWN_64（num）（（num）＆（〜63））

将整数值四舍五入到下一个64的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_DOWN_8

＃define GST_ROUND_DOWN_8（num）（（num）＆（〜7））

将整数值四舍五入到下一个8的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_DOWN_N

#define GST_ROUND_DOWN_N（num，align）（（（num）＆〜（（align）-1））））

将整数值四舍五入为align的下一个倍数。align必须是2的幂。

参数：

num – 整数值四舍五入

align – 取二的幂

GST_ROUND_UP_128

＃define GST_ROUND_UP_128（num）（（（（num）+127）＆〜127）

将整数值四舍五入至下一个128的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_UP_16

＃define GST_ROUND_UP_16（num）（（（（num）+15）＆〜15）

将整数值四舍五入到下一个16的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_UP_2

＃定义GST_ROUND_UP_2（num）（（（（num）+1）＆〜1）

将整数值四舍五入到2的下一个倍数。

参数：

num –

整数值四舍五入

GST_ROUND_UP_32

＃define GST_ROUND_UP_32（num）（（（（num）+31）＆〜31）

将整数值四舍五入至下一个32的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_UP_4

＃define GST_ROUND_UP_4（num）（（（（num）+3）＆〜3）

将整数值四舍五入至下一个4的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_UP_64

＃define GST_ROUND_UP_64（num）（（（（num）+63）＆〜63）

将整数值四舍五入到下一个64的倍数。

参数：

num – 整数值四舍五入

GST_ROUND_UP_8

＃define GST_ROUND_UP_8（num）（（（（num）+7）＆〜7）

将整数值四舍五入到8的下一个倍数。

参数：

num – 整数值四舍五入

GST_ROUND_UP_N

＃define GST_ROUND_UP_N（num，align）（（（（num）+（（align）-1））＆〜（（align）-1））））

将整数值四舍五入到align的下一个倍数。align必须是2的幂。

参数：

num – 整数值四舍五入

align – 取二的幂

GST_WRITE_UINT16_BE

＃define GST_WRITE_UINT16_BE（data，val）_GST_FAST_WRITE（16，data，val）

以大端格式将16位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

val – 储值

GST_WRITE_UINT16_LE

＃define GST_WRITE_UINT16_LE（data，val）_GST_FAST_WRITE_SWAP（16，data，val）

以Little Endian格式将16位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

val – 储值

GST_WRITE_UINT24_BE

#define GST_WRITE_UINT24_BE（data，num）做{\

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）; \

}而（0）

将大尾数格式的24位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

num – 储值

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）

以Little Endian格式将24位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

num – 储值

GST_WRITE_UINT32_BE

＃定义GST_WRITE_UINT32_BE（data，val）_GST_FAST_WRITE（32，data，val）

以大端格式将32位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

val – 储值

GST_WRITE_UINT32_LE

＃define GST_WRITE_UINT32_LE（data，val）_GST_FAST_WRITE_SWAP（32，data，val）

以Little Endian格式将32位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

val – 储值

GST_WRITE_UINT64_BE

＃define GST_WRITE_UINT64_BE（data，val）_GST_FAST_WRITE（64，date，vale）

以大端格式将64位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

val – 储值

GST_WRITE_UINT64_LE

＃定义GST_WRITE_UINT64_LE（data，VAL）_GST_FAST_WRITE_SWAP（64，data，VAL）

以Little Endian格式将64位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

val – 储值

GST_WRITE_UINT8

#define GST_WRITE_UINT8(data, num) do { \

_GST_PUT (data, 0, 8, 0, num); \

} while (0)

将8位无符号整数值存储到内存缓冲区中。

参数：

data – 记忆位置

num – 储值

_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（数据）（_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（数据）（_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）

将值转换为guint64。

参数：

value – 要转换的gdouble值

返回 – 值转换为guint64。

gst_guint64_to_gdouble

＃define gst_guint64_to_gdouble（value）gst_util_guint64_to_gdouble（value）

将值转换为gdouble。

参数：

value – 转换的guint64值

返回 – 值转换为gdouble。

枚举

GstPluginAPIFlags

GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS （1）– 生成插件缓存时忽略枚举成员。如果枚举的成员是动态生成的，以便不向最终用户暴露不正确的文档，这将很有用。

GstSearchMode

不同的搜索模式。

GST_SEARCH_MODE_EXACT （0）– 仅搜索完全匹配。

GST_SEARCH_MODE_BEFORE （1）– 搜索完全匹配或之前的元素。

GST_SEARCH_MODE_AFTER （2）– 搜索完全匹配或紧随其后的元素。

常数

GST_GROUP_ID_INVALID

＃define GST_GROUP_ID_INVALID（0）

保证永远不会由gst_util_group_id_next返回的值。

可以在用于存储group_id的变量中用作默认值。

GST_SEQNUM_INVALID

＃define GST_SEQNUM_INVALID（0）

保证永远不会由gst_util_seqnum_next返回的值。

可以在用于存储seqnum的变量中用作默认值。

冰山一脚2013

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
GStreamer学习十一（GSteamer常用工具）

功能gst_calculate_linear_regressiongbooleangst_calculate_linear_regression（constGstClockTime* xy，GstClockTime* temp，guintn，GstClockTime* m...
复制链接

扫一扫

专栏目录