AVPacket是存储压缩编码数据相关信息的结构
AVPacket是FFmpeg中很重要的一个数据结构,它保存了解复用之后,解码之前的数据(仍然是压缩后的数据)和关于这些数据的一些附加信息,如显示时间戳(pts)、解码时间戳(dts)、数据时长,所在媒体流的索引等。对于视频来说,AVPacket通常包含一个压缩的Frame,而音频(Audio)则有可能包含多个压缩的Frame。并且,一个Packet有可能是空的,不包含任何压缩数据,只含有side
data(side
data,容器提供的关于Packet的一些附加信息。例如,在编码结束的时候更新一些流的参数)。AVPacket的大小是公共的ABI(public
ABI)一部分,这样的结构体在FFmpeg很少,由此也可见AVPacket的重要性。它可以被分配在栈空间上(可以使用语句AVPacket
packet; 在栈空间定义一个Packet ),并且除非libavcodec 和
libavformat有很大的改动,不然不会在AVPacket中添加新的字段。
AVPacket
avcodec.h
/**
* 该结构用来存储压缩数据. 这是典型的解复合器的输出然后塞入解码器,或者是接收编码器的输出然后塞入复合器
* 解复合器 --> AVPacket --> 解码器 --> YUV/RGB --> 编码器 --> AVPacket -->复合器
* 此结构存储压缩数据。它通常由分路器导出
* 然后作为输入传递给解码器,或作为输出从编码器接收和
* 然后传递给多路复用器。
*
* 对于视频,它通常应包含一个压缩帧。对于音频,它可能
* 包含几个压缩帧。编码器允许输出空
* 数据包,没有压缩数据,只包含边数据
*(例如在编码结束时更新一些流参数)。
*
* AVPacket 是 FFmpeg 中为数不多的结构体之一,其大小是 public 的一部分
* ABI。因此它可以在堆栈上分配并且不能向其中添加新字段
* 没有 libavcodec 和 libavformat 主要问题。
*
* 数据所有权的语义取决于 buf 字段。
* 如果设置,则包数据是动态分配的
* 无限期有效,直到调用 av_packet_unref() 减少
* 引用计数为 0。
*
* 如果未设置 buf 字段,则 av_packet_ref() 将进行复制
* 增加引用计数。
*
* 侧边数据总是用av_malloc()分配,复制
* av_packet_ref() 并由 av_packet_unref() 释放。
*
* @see av_packet_ref
* @see av_packet_unref
*/
typedef struct AVPacket {
/**
* 对数据包数据所在的引用计数缓冲区的引用
* 存储。
* 可能为NULL,则数据包数据不被引用计数。
*/
AVBufferRef *buf;
/**
* 以 AVStream->time_base 为单位的演示时间戳; 的时间
* 解压后的数据包将呈现给用户。
* 如果未存储在文件中,则可以是 AV_NOPTS_VALUE。
* pts 必须大于或等于 dts 因为演示不能在之前发生
* 解压,除非想要查看十六进制转储。 某些格式误用
* 术语 dts 和 pts/cts 表示不同的含义。 这样的时间戳
* 在将它们存储在 AVPacket 中之前,必须将它们转换为真正的 pts/dts。
*/
int64_t pts;
/**
* 以 AVStream->time_base 为单位的解压时间戳; 的时间
* 数据包被解压。
* 如果未存储在文件中,则可以是 AV_NOPTS_VALUE。
*/
int64_t dts;
uint8_t *data;
int size;
int stream_index;
/**
* AV_PKT_FLAG 值的组合
*/
int flags;
/**
* 容器可以提供的额外数据包数据。
* 数据包可以包含多种类型的边信息。
*/
AVPacketSideData *side_data;
int side_data_elems;
/**
* 此数据包的持续时间以 AVStream->time_base 为单位,如果未知则为 0。
* 等于 next_pts - this_pts 按演示顺序。
*/
int64_t duration;
int64_t pos; ///< byte position in stream, -1 if unknown
#if FF_API_CONVERGENCE_DURATION
/**
* @deprecated 与持续时间字段相同,但与 int64_t 相同。 这是必需的
* 对于 Matroska 字幕,其持续时间值可能会在
* 持续时间字段仍然是一个整数。
*/
attribute_deprecated
int64_t convergence_duration;
#endif
} AVPacket;
AVPacket相关API
av_packet_alloc()
/**
* 分配一个 AVPacket 并将其字段设置为默认值。 所结果的
* 必须使用 av_packet_free() 释放结构体。
*
* @return 一个 AVPacket 填充默认值或失败时为 NULL。
*
* @note 这只会分配 AVPacket 本身,而不是数据缓冲区。 那些
* 必须通过av_new_packet等其他方式分配。
*
* @see av_new_packet
*/
AVPacket *av_packet_alloc(void);
//源码:
AVPacket *av_packet_alloc(void)
{
AVPacket *pkt = av_mallocz(sizeof(AVPacket));
if (!pkt)
return pkt;
av_packet_unref(pkt);
return pkt;
}
av_packet_clone
/**
* 创建一个引用与 src 相同数据的新数据包。
*
* 这是 av_packet_alloc()+av_packet_ref() 的快捷方式。
*
* @return 成功时新创建的 AVPacket,错误时为 NULL。
*
* @see av_packet_alloc
* @see av_packet_ref
*/
AVPacket *av_packet_clone(const AVPacket *src);
//源码:
AVPacket *av_packet_clone(const AVPacket *src)
{
AVPacket *ret = av_packet_alloc();
if (!ret)
return ret;
if (av_packet_ref(ret, src))
av_packet_free(&ret);
return ret;
}
av_packet_free
/**
* 释放数据包,如果数据包被引用计数,它将是
* 首先未引用。
*
* @param pkt 数据包被释放。 指针将被设置为 NULL。
* @note 传递 NULL 是空操作。
*/
void av_packet_free(AVPacket **pkt);
//源码:
void av_packet_free(AVPacket **pkt)
{
if (!pkt || !*pkt)
return;
av_packet_unref(*pkt);
av_freep(pkt);
}
av_init_packet
/**
* 使用默认值初始化数据包的可选字段。
*
* 注意,这不会触及数据和大小成员,它们必须是
* 单独初始化。
*
* @param pkt 数据包
*/
void av_init_packet(AVPacket *pkt);
//源码:
void av_init_packet(AVPacket *pkt)
{
pkt->pts = AV_NOPTS_VALUE;
pkt->dts = AV_NOPTS_VALUE;
pkt->pos = -1;
pkt->duration = 0;
#if FF_API_CONVERGENCE_DURATION
FF_DISABLE_DEPRECATION_WARNINGS
pkt->convergence_duration = 0;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
pkt->flags = 0;
pkt->stream_index = 0;
pkt->buf = NULL; //buf设置为NULL
pkt->side_data = NULL;
pkt->side_data_elems = 0;
}
av_new_packet
/**
* 分配一个数据包的有效载荷并初始化它的字段
* 默认值。
*
* @param pkt 数据包
* @param size 想要的有效载荷大小
* @return 0 如果正常,则 AVERROR_xxx 否则
*/
int av_new_packet(AVPacket *pkt, int size);
//定义
int av_new_packet(AVPacket *pkt, int size)
{
AVBufferRef *buf = NULL;
int ret = packet_alloc(&buf, size);
if (ret < 0)
return ret;
av_init_packet(pkt);
pkt->buf = buf;
pkt->data = buf->data;
pkt->size = size;
return 0;
}
av_shrink_packet
/**
*减少数据包大小,正确归零填充
*
* @param pkt 数据包
* @param size 新尺寸
*/
void av_shrink_packet(AVPacket *pkt, int size);
//定义;
void av_shrink_packet(AVPacket *pkt, int size)
{
if (pkt->size <= size)
return;
pkt->size = size;
memset(pkt->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
}
av_grow_packet
/**
* 增加数据包大小,正确清零填充
*
* @param pkt 数据包
* @param grow_by 增加数据包大小的字节数
*/
int av_grow_packet(AVPacket *pkt, int grow_by);
//定义
int av_grow_packet(AVPacket *pkt, int grow_by)
{
int new_size;
av_assert0((unsigned)pkt->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
if ((unsigned)grow_by >
INT_MAX - (pkt->size + AV_INPUT_BUFFER_PADDING_SIZE))
return AVERROR(ENOMEM);
new_size = pkt->size + grow_by + AV_INPUT_BUFFER_PADDING_SIZE;
if (pkt->buf) {
size_t data_offset;
uint8_t *old_data = pkt->data;
if (pkt->data == NULL) {
data_offset = 0;
pkt->data = pkt->buf->data;
} else {
data_offset = pkt->data - pkt->buf->data;
if (data_offset > INT_MAX - new_size)
return AVERROR(ENOMEM);
}
if (new_size + data_offset > pkt->buf->size) {
int ret = av_buffer_realloc(&pkt->buf, new_size + data_offset);
if (ret < 0) {
pkt->data = old_data;
return ret;
}
pkt->data = pkt->buf->data + data_offset;
}
} else {
pkt->buf = av_buffer_alloc(new_size);
if (!pkt->buf)
return AVERROR(ENOMEM);
if (pkt->size > 0)
memcpy(pkt->buf->data, pkt->data, pkt->size);
pkt->data = pkt->buf->data;
}
pkt->size += grow_by;
memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
return 0;
}
av_packet_from_data
/**
* 从 av_malloc()ed 数据初始化引用计数数据包。
*
* @param pkt 数据包被初始化。 此函数将设置数据、大小、
* 和 buf 字段,所有其他字段保持不变。
* @param data 由 av_malloc() 分配的数据,用作数据包数据。 如果这
* 函数返回成功,数据归底层AVBuffer所有。
* 来电者不得通过其他方式访问数据。
* @param size 以字节为单位的数据大小,没有填充。 IE。 完整的缓冲区
* 假定大小为 size + AV_INPUT_BUFFER_PADDING_SIZE。
*
* @return 成功时返回 0,错误时返回负 AVERROR
*/
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
//定义
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
{
if (size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
return AVERROR(EINVAL);
pkt->buf = av_buffer_create(data, size + AV_INPUT_BUFFER_PADDING_SIZE,
av_buffer_default_free, NULL, 0);
if (!pkt->buf)
return AVERROR(ENOMEM);
pkt->data = data;
pkt->size = size;
return 0;
}
av_dup_packet
#if FF_API_AVPACKET_OLD_API
/**
* @warning 这是一个黑客 - 数据包内存分配的东西被破坏了。 这
* 如果数据包没有真正分配,则分配数据包。
*
* @deprecated 使用 av_packet_ref 或 av_packet_make_refcounted
*/
attribute_deprecated
int av_dup_packet(AVPacket *pkt);
//定义
int av_dup_packet(AVPacket *pkt)
{
AVPacket tmp_pkt;
if (!pkt->buf && pkt->data) {
tmp_pkt = *pkt;
return copy_packet_data(pkt, &tmp_pkt, 1);
}
return 0;
}
av_copy_packet
/**
* 复制数据包,包括内容
*
* @return 成功时返回 0,失败时返回负 AVERROR
*
* @deprecated 使用 av_packet_ref
*/
attribute_deprecated
int av_copy_packet(AVPacket *dst, const AVPacket *src);
//定义
int av_copy_packet(AVPacket *dst, const AVPacket *src)
{
*dst = *src;
return copy_packet_data(dst, src, 0);
}
av_copy_packet_side_data
/**
* 复制包端数据
*
* @return 成功时返回 0,失败时返回负 AVERROR
*
* @deprecated 使用 av_packet_copy_props
*/
attribute_deprecated
int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
//定义
int av_copy_packet_side_data(AVPacket *pkt, const AVPacket *src)
{
if (src->side_data_elems) {
int i;
DUP_DATA(pkt->side_data, src->side_data,
src->side_data_elems * sizeof(*src->side_data), 0, ALLOC_MALLOC);
if (src != pkt) {
memset(pkt->side_data, 0,
src->side_data_elems * sizeof(*src->side_data));
}
for (i = 0; i < src->side_data_elems; i++) {
DUP_DATA(pkt->side_data[i].data, src->side_data[i].data,
src->side_data[i].size, 1, ALLOC_MALLOC);
pkt->side_data[i].size = src->side_data[i].size;
pkt->side_data[i].type = src->side_data[i].type;
}
}
pkt->side_data_elems = src->side_data_elems;
return 0;
failed_alloc:
av_packet_unref(pkt);
return AVERROR(ENOMEM);
}
av_free_packet
/**
* 免费一包。
*
* @deprecated 使用 av_packet_unref
*
* @param pkt 数据包释放
*/
attribute_deprecated
void av_free_packet(AVPacket *pkt);
//定义
FF_DISABLE_DEPRECATION_WARNINGS
void av_free_packet(AVPacket *pkt)
{
if (pkt) {
if (pkt->buf)
av_buffer_unref(&pkt->buf);
pkt->data = NULL;
pkt->size = 0;
av_packet_free_side_data(pkt);
}
}
av_packet_new_side_data
#endif
/**
* 分配数据包的新信息。
*
* @param pkt 数据包
* @param type 边信息类型
* @param size 边信息大小
* @return 指向新分配数据的指针,否则为 NULL
*/
uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size);
//定义
uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size)
{
int ret;
uint8_t *data;
if ((unsigned)size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
return NULL;
data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!data)
return NULL;
ret = av_packet_add_side_data(pkt, type, data, size);
if (ret < 0) {
av_freep(&data);
return NULL;
}
return data;
}
av_packet_add_side_data
/**
* 将现有数组包装为数据包端数据。
*
* @param pkt 数据包
* @param type 边信息类型
* @param data 边数据数组。 它必须用 av_malloc() 分配
* 函数族。 数据的所有权转移到
* 包。
* @param size 边信息大小
* @return 成功时为非负数,成功时为负 AVERROR 代码
* 失败。 失败时,数据包不变,数据保持不变
* 由调用者拥有。
*/
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
uint8_t *data, size_t size);
//定义
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
uint8_t *data, size_t size)
{
AVPacketSideData *tmp;
int i, elems = pkt->side_data_elems;
for (i = 0; i < elems; i++) {
AVPacketSideData *sd = &pkt->side_data[i];
if (sd->type == type) {
av_free(sd->data);
sd->data = data;
sd->size = size;
return 0;
}
}
if ((unsigned)elems + 1 > AV_PKT_DATA_NB)
return AVERROR(ERANGE);
tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));
if (!tmp)
return AVERROR(ENOMEM);
pkt->side_data = tmp;
pkt->side_data[elems].data = data;
pkt->side_data[elems].size = size;
pkt->side_data[elems].type = type;
pkt->side_data_elems++;
return 0;
}
av_packet_shrink_side_data
/**
* 缩小已经分配的侧数据缓冲区
*
* @param pkt 数据包
* @param type 边信息类型
* @param size 新的边信息大小
* @return 0 成功,< 0 失败
*/
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size);
//定义
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size)
{
int i;
for (i = 0; i < pkt->side_data_elems; i++) {
if (pkt->side_data[i].type == type) {
if (size > pkt->side_data[i].size)
return AVERROR(ENOMEM);
pkt->side_data[i].size = size;
return 0;
}
}
return AVERROR(ENOENT);
}
av_packet_get_side_data
/**
* 从数据包中获取边信息。
*
* @param pkt 数据包
* @param type 所需的边信息类型
* @param size 用于存储边信息大小的指针(可选)
* @return 指向数据的指针(如果存在,否则为 NULL)
*/
uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
int *size);
//定义
uint8_t *av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
int *size)
{
int i;
for (i = 0; i < pkt->side_data_elems; i++) {
if (pkt->side_data[i].type == type) {
if (size)
*size = pkt->side_data[i].size;
return pkt->side_data[i].data;
}
}
if (size)
*size = 0;
return NULL;
}
#if FF_API_MERGE_SD_API
attribute_deprecated
int av_packet_merge_side_data(AVPacket *pkt);
attribute_deprecated
int av_packet_split_side_data(AVPacket *pkt);
#endif
const char *av_packet_side_data_name(enum AVPacketSideDataType type);
av_paket_pack_dictionary
/**
* 打包用于 side_data 的字典。
*
* @param dict 要打包的字典。
* @param size 指针存储返回数据的大小
* @return 如果成功则返回数据指针,否则为NULL
*/
uint8_t *av_paket_pack_dictionary(AVDictionary *dict, int *size);
//定义
uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size)
{
AVDictionaryEntry *t = NULL;
uint8_t *data = NULL;
*size = 0;
if (!dict)
return NULL;
while ((t = av_dict_get(dict, "", t, AV_DICT_IGNORE_SUFFIX))) {
const size_t keylen = strlen(t->key);
const size_t valuelen = strlen(t->value);
const size_t new_size = *size + keylen + 1 + valuelen + 1;
uint8_t *const new_data = av_realloc(data, new_size);
if (!new_data)
goto fail;
data = new_data;
if (new_size > INT_MAX)
goto fail;
memcpy(data + *size, t->key, keylen + 1);
memcpy(data + *size + keylen + 1, t->value, valuelen + 1);
*size = new_size;
}
return data;
fail:
av_freep(&data);
*size = 0;
return NULL;
}
av_packet_unpack_dictionary
/**
* 从 side_data 解压字典。
*
* @param data 来自 side_data 的数据
* @param size 数据的大小
* @param dict 元数据存储字典
* @return 0 成功,< 0 失败
*/
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
//定义
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict)
{
const uint8_t *end;
int ret = 0;
if (!dict || !data || !size)
return ret;
end = data + size;
if (size && end[-1])
return AVERROR_INVALIDDATA;
while (data < end) {
const uint8_t *key = data;
const uint8_t *val = data + strlen(key) + 1;
if (val >= end || !*key)
return AVERROR_INVALIDDATA;
ret = av_dict_set(dict, key, val, 0);
if (ret < 0)
break;
data = val + strlen(val) + 1;
}
return ret;
}
av_packet_free_side_data
/**
* 方便的功能可以释放所有存储的侧面数据。
* 所有其他字段保持不变。
*
* @param pkt 数据包
*/
void av_packet_free_side_data(AVPacket *pkt);
//定义
void av_packet_free_side_data(AVPacket *pkt)
{
int i;
for (i = 0; i < pkt->side_data_elems; i++)
av_freep(&pkt->side_data[i].data);
av_freep(&pkt->side_data);
pkt->side_data_elems = 0;
}
av_packet_ref
/**
* 设置对给定数据包描述的数据的新引用
*
* 如果 src 是引用计数,则将 dst 设置为对
* src 中的缓冲区。 否则在 dst 中分配一个新缓冲区并复制
* 将数据从 src 导入其中。
*
* 所有其他字段均从 src 复制。
*
* @see av_packet_unref
*
* @param dst 目标包
* @param src 源数据包
*
* @return 成功时返回 0,错误时返回负 AVERROR。
*/
int av_packet_ref(AVPacket *dst, const AVPacket *src);
//定义
int av_packet_ref(AVPacket *dst, const AVPacket *src)
{
int ret;
ret = av_packet_copy_props(dst, src);
if (ret < 0)
return ret;
if (!src->buf) {
ret = packet_alloc(&dst->buf, src->size);
if (ret < 0)
goto fail;
av_assert1(!src->size || src->data);
if (src->size)
memcpy(dst->buf->data, src->data, src->size);
dst->data = dst->buf->data;
} else {
dst->buf = av_buffer_ref(src->buf);
if (!dst->buf) {
ret = AVERROR(ENOMEM);
goto fail;
}
dst->data = src->data;
}
dst->size = src->size;
return 0;
fail:
av_packet_free_side_data(dst);
return ret;
}
av_packet_unref
/**
* 擦拭数据包。
*
* 取消引用数据包引用的缓冲区并重置
* 剩余的数据包字段为其默认值。
*
* @param pkt 要取消引用的数据包。
*/
void av_packet_unref(AVPacket *pkt);
//定义
void av_packet_unref(AVPacket *pkt)
{
av_packet_free_side_data(pkt);
av_buffer_unref(&pkt->buf);
av_init_packet(pkt);
pkt->data = NULL;
pkt->size = 0;
}
av_packet_move_ref
/**
* 将 src 中的每个字段移动到 dst 并重置 src。
*
* @see av_packet_unref
*
* @param src 源数据包,将被重置
* @param dst 目标包
*/
void av_packet_move_ref(AVPacket *dst, AVPacket *src);
//定义
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
{
*dst = *src;
av_init_packet(src);
src->data = NULL;
src->size = 0;
}
av_packet_copy_props
/**
* 仅将“属性”字段从 src 复制到 dst。
*
* 用于此功能的属性是所有字段
* 除了那些与包数据相关的(buf、data、size)
*
* @param dst 目标包
* @param src 源数据包
*
* @return 0 成功 AVERROR 失败。
*/
int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
//定义
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
{
int i;
dst->pts = src->pts;
dst->dts = src->dts;
dst->pos = src->pos;
dst->duration = src->duration;
#if FF_API_CONVERGENCE_DURATION
FF_DISABLE_DEPRECATION_WARNINGS
dst->convergence_duration = src->convergence_duration;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
dst->flags = src->flags;
dst->stream_index = src->stream_index;
dst->side_data = NULL;
dst->side_data_elems = 0;
for (i = 0; i < src->side_data_elems; i++) {
enum AVPacketSideDataType type = src->side_data[i].type;
int size = src->side_data[i].size;
uint8_t *src_data = src->side_data[i].data;
uint8_t *dst_data = av_packet_new_side_data(dst, type, size);
if (!dst_data) {
av_packet_free_side_data(dst);
return AVERROR(ENOMEM);
}
memcpy(dst_data, src_data, size);
}
return 0;
}
av_packet_make_refcounted
/**
* 确保给定数据包描述的数据被引用计数。
*
* @note 这个函数不能保证引用是可写的。
* 为此目的,请改用 av_packet_make_writable。
*
* @see av_packet_ref
* @see av_packet_make_writable
*
* @param pkt 数据包,其数据应进行引用计数。
*
* @return 成功时返回 0,错误时返回负 AVERROR。 失败时,
* 数据包不变。
*/
int av_packet_make_refcounted(AVPacket *pkt);
//定义
int av_packet_make_refcounted(AVPacket *pkt)
{
int ret;
if (pkt->buf)
return 0;
ret = packet_alloc(&pkt->buf, pkt->size);
if (ret < 0)
return ret;
av_assert1(!pkt->size || pkt->data);
if (pkt->size)
memcpy(pkt->buf->data, pkt->data, pkt->size);
pkt->data = pkt->buf->data;
return 0;
}
av_packet_make_writable
/**
* 为给定数据包描述的数据创建一个可写的引用,
* 尽可能避免数据复制。
*
* @param pkt 数据应可写的数据包。
*
* @return 成功时返回 0,失败时返回负的 AVERROR。 失败时,
* 数据包不变。
*/
int av_packet_make_writable(AVPacket *pkt);
//定义
int av_packet_make_writable(AVPacket *pkt)
{
AVBufferRef *buf = NULL;
int ret;
if (pkt->buf && av_buffer_is_writable(pkt->buf))
return 0;
ret = packet_alloc(&buf, pkt->size);
if (ret < 0)
return ret;
av_assert1(!pkt->size || pkt->data);
if (pkt->size)
memcpy(buf->data, pkt->data, pkt->size);
av_buffer_unref(&pkt->buf);
pkt->buf = buf;
pkt->data = buf->data;
return 0;
}
av_packet_rescale_ts
/**
* 将数据包中的有效计时字段(时间戳/持续时间)从一个转换
* 时基到另一个。 具有未知值 (AV_NOPTS_VALUE) 的时间戳将是
* 忽略。
*
* @param pkt 数据包,将在其上执行转换
* @param tb_src 源时基,其中pkt中的时序字段为
* 表达
* @param tb_dst 目标时基,计时字段将指向该时基
* 转换
*/
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
//定义
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
{
if (pkt->pts != AV_NOPTS_VALUE)
pkt->pts = av_rescale_q(pkt->pts, src_tb, dst_tb);
if (pkt->dts != AV_NOPTS_VALUE)
pkt->dts = av_rescale_q(pkt->dts, src_tb, dst_tb);
if (pkt->duration > 0)
pkt->duration = av_rescale_q(pkt->duration, src_tb, dst_tb);
#if FF_API_CONVERGENCE_DURATION
FF_DISABLE_DEPRECATION_WARNINGS
if (pkt->convergence_duration > 0)
pkt->convergence_duration = av_rescale_q(pkt->convergence_duration, src_tb, dst_tb);
FF_ENABLE_DEPRECATION_WARNINGS
#endif
}
测试
#include "avpacket.h"
#define MEM_ITEM_SIZE (20*1024*102)
#define AVPACKET_LOOP_COUNT 1000
// 测试 内存泄漏
/**
* @brief 测试av_packet_alloc和av_packet_free的配对使用
*/
void av_packet_test1()
{
AVPacket *pkt = NULL;
int ret = 0;
pkt = av_packet_alloc(); //分配一个 AVPacket 并将其字段设置为默认值。 所结果的必须使用 av_packet_free() 释放结构体。
ret = av_new_packet(pkt, MEM_ITEM_SIZE); // 引用计数初始化为1
memccpy(pkt->data, (void *)&av_packet_test1, 1, MEM_ITEM_SIZE);
av_packet_unref(pkt); // 要不要调用
av_packet_free(&pkt); // 如果不free将会发生内存泄漏,内部调用了 av_packet_unref
}
/**
* @brief 测试误用av_init_packet将会导致内存泄漏
*/
void av_packet_test2()
{
AVPacket *pkt = NULL;
int ret = 0;
pkt = av_packet_alloc();
ret = av_new_packet(pkt, MEM_ITEM_SIZE);
memccpy(pkt->data, (void *)&av_packet_test1, 1, MEM_ITEM_SIZE);
//av_init_packet(pkt); // 这个时候init就会导致内存无法释放
av_packet_free(&pkt);
}
/**
* @brief 测试av_packet_move_ref后,可以不用av_init_packet
*/
void av_packet_test3()
{
AVPacket *pkt = NULL;
AVPacket *pkt2 = NULL;
int ret = 0;
pkt = av_packet_alloc();
ret = av_new_packet(pkt, MEM_ITEM_SIZE);
memccpy(pkt->data, (void *)&av_packet_test1, 1, MEM_ITEM_SIZE);
pkt2 = av_packet_alloc(); // 必须先alloc
av_packet_move_ref(pkt2, pkt);//内部其实也调用了av_init_packet
av_init_packet(pkt);
av_packet_free(&pkt);
av_packet_free(&pkt2);
}
/**
* @brief 测试av_packet_clone
*/
void av_packet_test4()
{
AVPacket *pkt = NULL;
// av_packet_alloc()没有必要,因为av_packet_clone内部有调用 av_packet_alloc
AVPacket *pkt2 = NULL;
int ret = 0;
pkt = av_packet_alloc();
ret = av_new_packet(pkt, MEM_ITEM_SIZE);
memccpy(pkt->data, (void *)&av_packet_test1, 1, MEM_ITEM_SIZE);
pkt2 = av_packet_clone(pkt); // av_packet_alloc()+av_packet_ref()
av_init_packet(pkt);
av_packet_free(&pkt);
av_packet_free(&pkt2);
}
/**
* @brief 测试av_packet_ref
*/
void av_packet_test5()
{
AVPacket *pkt = NULL;
AVPacket *pkt2 = NULL;
int ret = 0;
pkt = av_packet_alloc(); //分配一个AVPacket空间
if(pkt->buf) // 打印referenc-counted,必须保证传入的是有效指针
{ printf("%s(%d) ref_count(pkt) = %d\n", __FUNCTION__, __LINE__,
av_buffer_get_ref_count(pkt->buf));
}
ret = av_new_packet(pkt, MEM_ITEM_SIZE);//分配一个数据包的有效载荷并初始化它的字段* 默认值。
if(pkt->buf) // 打印referenc-counted,必须保证传入的是有效指针
{ printf("%s(%d) ref_count(pkt) = %d\n", __FUNCTION__, __LINE__,
av_buffer_get_ref_count(pkt->buf));
}
memccpy(pkt->data, (void *)&av_packet_test1, 1, MEM_ITEM_SIZE);
pkt2 = av_packet_alloc(); // 必须先alloc
av_packet_move_ref(pkt2, pkt); // av_packet_move_ref 将 src 中的每个字段移动到 dst 并重置 src。
// av_init_packet(pkt); //av_packet_move_ref
av_packet_ref(pkt, pkt2); //引用计数, 如果 src 是引用计数,则将 dst 设置为对src 中的缓冲区。 否则在 dst 中分配一个新缓冲区并复制将数据从 src 导入其中。
av_packet_ref(pkt, pkt2); // 多次ref如果没有对应多次unref将会内存泄漏
if(pkt->buf) // 打印referenc-counted,必须保证传入的是有效指针
{ printf("%s(%d) ref_count(pkt) = %d\n", __FUNCTION__, __LINE__,
av_buffer_get_ref_count(pkt->buf));
}
if(pkt2->buf) // 打印referenc-counted,必须保证传入的是有效指针
{ printf("%s(%d) ref_count(pkt) = %d\n", __FUNCTION__, __LINE__,
av_buffer_get_ref_count(pkt2->buf));
}
av_packet_unref(pkt); // 将为2 取消引用数据包引用的缓冲区并重置剩余的数据包字段为其默认值。
av_packet_unref(pkt); // 做第二次是没有用的
if(pkt->buf)
printf("pkt->buf没有被置NULL\n");
else
printf("pkt->buf已经被置NULL\n");
if(pkt2->buf) // 打印referenc-counted,必须保证传入的是有效指针
{ printf("%s(%d) ref_count(pkt) = %d\n", __FUNCTION__, __LINE__,
av_buffer_get_ref_count(pkt2->buf));
}
av_packet_unref(pkt2);
av_packet_free(&pkt); //释放数据包
av_packet_free(&pkt2);
}
/**
* @brief 测试AVPacket整个结构体赋值, 和av_packet_move_ref类似
*/
void av_packet_test6()
{
AVPacket *pkt = NULL;
AVPacket *pkt2 = NULL;
int ret = 0;
pkt = av_packet_alloc();
ret = av_new_packet(pkt, MEM_ITEM_SIZE);
memccpy(pkt->data, (void *)&av_packet_test1, 1, MEM_ITEM_SIZE);
pkt2 = av_packet_alloc(); // 必须先alloc
*pkt2 = *pkt; // 有点类似 pkt可以重新分配内存
av_init_packet(pkt);
av_packet_free(&pkt);
av_packet_free(&pkt2);
}
void av_packet_test()
{
// av_packet_test1();
// av_packet_test2();
// av_packet_test3();
// av_packet_test4();
// av_packet_test5();
av_packet_test6();
}