h264测试
#include <stdio.h>
#include <libavutil/log.h>
#include <libavformat/avio.h>
#include <libavformat/avformat.h>
static char err_buf[128] = {0};
static char* av_get_err(int errnum)
{
av_strerror(errnum, err_buf, 128);
return err_buf;
}
/*
AvCodecContext->extradata[]中为nalu长度
* codec_extradata:
* 1, 64, 0, 1f, ff, e1, [0, 18], 67, 64, 0, 1f, ac, c8, 60, 78, 1b, 7e,
* 78, 40, 0, 0, fa, 40, 0, 3a, 98, 3, c6, c, 66, 80,
* 1, [0, 5],68, e9, 78, bc, b0, 0,
*/
//ffmpeg -i 2018.mp4 -codec copy -bsf:h264_mp4toannexb -f h264 tmp.h264
//ffmpeg 从mp4上提取H264的nalu h
int main(int argc, char **argv)
{
AVFormatContext *ifmt_ctx = NULL;
int videoindex = -1;
AVPacket *pkt = NULL;
int ret = -1;
int file_end = 0; // 文件是否读取结束
if(argc < 3)
{
printf("usage inputfile outfile\n");
return -1;
}
FILE *outfp=fopen(argv[2],"wb");
printf("in:%s out:%s\n", argv[1], argv[2]);
// 分配解复用器的内存,使用avformat_close_input释放
ifmt_ctx = avformat_alloc_context();
if (!ifmt_ctx)
{
printf("[error] Could not allocate context.\n");
return -1;
}
// 根据url打开码流,并选择匹配的解复用器
ret = avformat_open_input(&ifmt_ctx,argv[1], NULL, NULL);
if(ret != 0)
{
printf("[error]avformat_open_input: %s\n", av_get_err(ret));
return -1;
}
// 读取媒体文件的部分数据包以获取码流信息
ret = avformat_find_stream_info(ifmt_ctx, NULL);
if(ret < 0)
{
printf("[error]avformat_find_stream_info: %s\n", av_get_err(ret));
avformat_close_input(&ifmt_ctx);
return -1;
}
// 查找出哪个码流是video/audio/subtitles
videoindex = -1;
// 推荐的方式, 通过av_find_best_stream()函数来获取流的索引
videoindex = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
if(videoindex == -1)
{
printf("Didn't find a video stream.\n");
avformat_close_input(&ifmt_ctx);
return -1;
}
// 分配数据包
pkt = av_packet_alloc();
av_init_packet(pkt);
// 1 获取相应的比特流过滤器
//FLV/MP4/MKV等结构中,h264需要h264_mp4toannexb处理。添加SPS/PPS等信息。
// FLV封装时,可以把多个NALU放在一个VIDEO TAG中,结构为4B NALU长度+NALU1+4B NALU长度+NALU2+...,
// 需要做的处理把4B长度换成00000001或者000001
const AVBitStreamFilter *bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
AVBSFContext *bsf_ctx = NULL;
//2.过滤器分配内存
av_bsf_alloc(bsfilter, &bsf_ctx); //AVBSFContext;
// 3 添加解码器属性
avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[videoindex]->codecpar);
//4 初始化过滤器上下文
av_bsf_init(bsf_ctx);
file_end = 0;
while (0 == file_end)
{
if((ret = av_read_frame(ifmt_ctx, pkt)) < 0) //判断数据是否读取完
{
// 没有更多包可读
file_end = 1;
printf("read file end: ret:%d\n", ret);
}
if(ret == 0 && pkt->stream_index == videoindex)
{
//#if 0
int input_size = pkt->size;
int out_pkt_count = 0;
if (av_bsf_send_packet(bsf_ctx, pkt) != 0) // bitstreamfilter内部去维护内存空间
{ //发送每个数据包后,过滤器必须完全排空
av_packet_unref(pkt); // 你不用了就把资源释放掉
continue; // 继续送
}
av_packet_unref(pkt); // 释放资源
while(av_bsf_receive_packet(bsf_ctx, pkt) == 0)
{//必须使用av_packet_unref() 释放内存
out_pkt_count++;
// printf("fwrite size:%d\n", pkt->size);
size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
if(size != pkt->size)
{
printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
}
av_packet_unref(pkt);
}
if(out_pkt_count >= 2)
{
printf("cur pkt(size:%d) only get 1 out pkt, it get %d pkts\n",
input_size, out_pkt_count);
}
//#else
// TS流可以直接写入, bitstreamfilter可以自动判别格式,可以做到正常的识别,如果有了startcode就不会在添加statcode了
size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
if(size != pkt->size)
{
printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
}
av_packet_unref(pkt);
//#endif
}
else
{
if(ret == 0)
av_packet_unref(pkt); // 释放内存
}
}
if(outfp)
fclose(outfp);
if(bsf_ctx)
av_bsf_free(&bsf_ctx);
if(pkt)
av_packet_free(&pkt);
if(ifmt_ctx)
avformat_close_input(&ifmt_ctx);
printf("finish\n");
return 0;
}
av_bsf_get_by_name
定义指定比特流过滤器
/**
* @return 具有指定名称的比特流过滤器,如果没有,则返回 NULL
* 存在比特流过滤器。
*/
const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
源码:
const AVBitStreamFilter *av_bsf_get_by_name(const char *name)
{
const AVBitStreamFilter *f = NULL;
void *i = 0;
if (!name)
return NULL;
while ((f = av_bsf_iterate(&i))) {
if (!strcmp(f->name, name))
return f;
}
return NULL;
}
av_bsf_iterate
/**
* 迭代所有注册的比特流过滤器。
*
* @param opaque 一个指针,其中 libavcodec 将存储迭代状态。 必须
* 指向 NULL 开始迭代。
*
* @return 下一个注册的比特流过滤器或迭代时为NULL
* 完成的
*/
const AVBitStreamFilter *av_bsf_iterate(void **opaque);
源码:
const AVBitStreamFilter *av_bsf_iterate(void **opaque)
{
uintptr_t i = (uintptr_t)*opaque;
const AVBitStreamFilter *f = bitstream_filters[i];
if (f)
*opaque = (void*)(i + 1);
return f;
}
av_bsf_alloc()
/**
* 为给定的比特流过滤器分配上下文。 来电者必须填写
* 文档中描述的上下文参数,然后调用
* av_bsf_init() 在向过滤器发送任何数据之前。
*
* @param filter 为其分配实例的过滤器。
* @param ctx 指向新分配上下文的指针
* 将被写入。 它必须在 av_bsf_free() 之后释放
* 过滤完成。
*
* @return 成功时返回 0,失败时返回负的 AVERROR 代码
*/
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
源码:
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
{
AVBSFContext *ctx;
int ret;
ctx = av_mallocz(sizeof(*ctx));
if (!ctx)
return AVERROR(ENOMEM);
ctx->av_class = &bsf_class;
ctx->filter = filter;
ctx->par_in = avcodec_parameters_alloc();
ctx->par_out = avcodec_parameters_alloc();
if (!ctx->par_in || !ctx->par_out) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->internal = av_mallocz(sizeof(*ctx->internal));
if (!ctx->internal) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->internal->buffer_pkt = av_packet_alloc();
if (!ctx->internal->buffer_pkt) {
ret = AVERROR(ENOMEM);
goto fail;
}
av_opt_set_defaults(ctx);
/* allocate priv data and init private options */
if (filter->priv_data_size) {
ctx->priv_data = av_mallocz(filter->priv_data_size);
if (!ctx->priv_data) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (filter->priv_class) {
*(const AVClass **)ctx->priv_data = filter->priv_class;
av_opt_set_defaults(ctx->priv_data);
}
}
*pctx = ctx;
return 0;
fail:
av_bsf_free(&ctx);
return ret;
}
avcodec_parameters_copy
/**
* 将src的内容复制到dst。 dst 中任何分配的字段都被释放并且
* 替换为新分配的 src 中相应字段的重复项。
*
* @return >= 0 成功,失败时返回负的 AVERROR 代码。
*/
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
源码
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
{
codec_parameters_reset(dst);
memcpy(dst, src, sizeof(*dst));
dst->extradata = NULL;
dst->extradata_size = 0;
if (src->extradata) {
dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!dst->extradata)
return AVERROR(ENOMEM);
memcpy(dst->extradata, src->extradata, src->extradata_size);
dst->extradata_size = src->extradata_size;
}
return 0;
}
av_bsf_send_packet
/**
* 提交数据包进行过滤。
*
* 发送每个数据包后,过滤器必须通过调用完全排空
* av_bsf_receive_packet() 重复直到它返回 AVERROR(EAGAIN) 或
* AVERROR_EOF。
*
* @param pkt 要过滤的数据包。 比特流过滤器将拥有
* 包和重置pkt的内容。 如果发生错误,则不会触及 pkt。
* 此参数可能为 NULL,表示流结束(即不再
* 将发送数据包)。 这将导致过滤器输出它的任何数据包
* 可能已在内部缓冲。
*
* @return 成功时返回 0,错误时返回负 AVERROR。
*/
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
av_bsf_receive_packet
/**
* 检索过滤后的数据包。
*
* @param[out] pkt 这个结构体将填充过滤后的内容
* 包。它归调用者所有,必须使用
* av_packet_unref() 不再需要时。
* 这个参数应该是“干净的”(即新分配的
* 使用 av_packet_alloc() 或未使用 av_packet_unref())
* 当这个函数被调用时。如果这个函数返回
* 成功,pkt的内容将完整
* 被返回的数据覆盖。失败时,pkt 不是
* 感动。
*
* @return 0 成功。 AVERROR(EAGAIN) 如果需要将更多数据包发送到
* 过滤器(使用 av_bsf_send_packet())以获得更多输出。 AVERROR_EOF 如果有
* 将不再从过滤器输出。另一个负 AVERROR 值,如果
* 发生错误。
*
* @note 一个输入包可能会产生多个输出包,所以发送后
* 一个带有av_bsf_send_packet()的包,需要调用这个函数
* 重复,直到它停止返回 0。过滤器也可以
* 输出的数据包少于发送给它的数据包,因此此函数可能会返回
* av_bsf_send_packet() 调用成功后立即出现 AVERROR(EAGAIN)。
*/
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);