FFmpeg零基础学习(四)——CPU视频解码 重新编码

已于 2024-01-28 17:51:34 修改
阅读量1.3k 收藏 22
点赞数 25
分类专栏： FFmpeg 文章标签： FFmpeg
于 2023-12-16 10:09:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43211060/article/details/135029300
版权

目录

前言

本篇文章的功能在于对视频进行解码，然后重新编码。只不过，本篇文章并没有对获得的解码数据进行任何的操作，后续会有文章，针对这方面的内容，进行完善。

正文

一、核心代码

code

	int ret = 0;
    int err;
    //打开输入文件
    char filename[] = "juren-30s.mp4";
    //动态分配和初始化一个空的AVFormatContext对象，为后续的音视频封装和解封装操作做准备。
    AVFormatContext *fmt_ctx = avformat_alloc_context();

    if (!fmt_ctx)
    {
        qDebug() << "fmt_ctx error code:"<<AVERROR(ENOMEM);
        return;
    }

    //打开文件
    if((err = avformat_open_input(&fmt_ctx, filename,NULL,NULL)) < 0)
    {
        printf("can not open file %d \n",err);
        return;
    }


    //分配并初始化一个 AVCodecContext 结构体，该结构体用于编解码器的相关信息和参数设置。
    AVCodecContext *avctx = avcodec_alloc_context3(NULL);

    //用于将AVCodecParameters结构体的值赋值给AVCodecContext结构体的对应字段
    //参数值的赋值涉及到了编解码器的基本配置，例如编码类型、码率、帧率等等。这样可以方便地将参数信息传递给编解码器上下文，以供后续的编解码操作使用。
    ret = avcodec_parameters_to_context(avctx, fmt_ctx->streams[0]->codecpar);

    if (ret < 0)
    {
        qDebug() << "avcodec_parameters_to_context error code:"<<ret;
        return;
    }

    //查找解码器
    AVCodec *codec = avcodec_find_decoder(avctx->codec_id);

    //打开解码器
    if ((ret = avcodec_open2(avctx, codec, NULL)) < 0)
    {
        qDebug() << "avcodec_open2 error code:"<<ret;
        return;
    }

    //打开输出文件容器
    char filename_out[] = "juren-30s-5.mp4";
    AVFormatContext *fmt_ctx_out = NULL;
    //该函数会尝试通过指定的输出格式来分配一个输出格式上下文
    err = avformat_alloc_output_context2(&fmt_ctx_out, NULL, NULL, filename_out);

    if (!fmt_ctx_out)
    {
        qDebug() << "error code:"<<AVERROR(ENOMEM);
        return;
    }

    //添加一路流到容器上下文
    AVStream *st = avformat_new_stream(fmt_ctx_out, NULL);
    st->time_base = fmt_ctx->streams[0]->time_base;

    //分配帧和包资源
    AVCodecContext *enc_ctx = NULL;
    AVPacket *pkt = av_packet_alloc();
    AVFrame *frame = av_frame_alloc();
    AVPacket *pkt_out = av_packet_alloc();

    int frame_num = 0;
    int read_end = 0;

    while(true)
    {
        if(1 == read_end )
        {
            break;
        }

        ret = av_read_frame(fmt_ctx, pkt);

        //跳过不处理音频包
        if(1 == pkt->stream_index)
        {
            av_packet_unref(pkt);
            continue;
        }

        //读取到文件的结尾了
        if (AVERROR_EOF == ret)
        {
            //读取完文件，这时候 pkt 的 data 跟 size 应该是 null
            avcodec_send_packet(avctx, NULL);
        }
        else
        {
            if( 0 != ret)
            {
                qDebug() << "av_read_frame error code:"<<ret;
                return;
            }
            else
            {
                retry:
                if (avcodec_send_packet(avctx, pkt) == AVERROR(EAGAIN))
                {
                    qDebug() << "Receive_frame and send_packet both returned EAGAIN, which is an API violation";
                    //这里可以考虑休眠 0.1 秒，返回 EAGAIN 通常是 ffmpeg 的内部 api 有bug
                    goto retry;
                }

                //释放 pkt 里面的编码数据
                av_packet_unref(pkt);
            }
        }

        //循环不断从解码器读数据，直到没有数据可读。
        while(true)
        {
            //读取 AVFrame
            ret = avcodec_receive_frame(avctx, frame);
            /* 释放 frame 里面的YUV数据，
             * 由于 avcodec_receive_frame 函数里面会调用 av_frame_unref，所以下面的代码可以注释。
             * 所以我们不需要 手动 unref 这个 AVFrame
             * */
            //av_frame_unref(frame);

            if(AVERROR(EAGAIN) == ret)
            {
                //提示 EAGAIN 代表 解码器 需要 更多的 AVPacket
                //跳出 第一层 for，让 解码器拿到更多的 AVPacket
                break;
            }
            else if( AVERROR_EOF == ret )
            {
                /* 提示 AVERROR_EOF 代表之前已经往 解码器发送了一个 data 跟 size 都是 NULL 的 AVPacket
                 * 发送 NULL 的 AVPacket 是提示解码器把所有的缓存帧全都刷出来。
                 * 通常只有在 读完输入文件才会发送 NULL 的 AVPacket，或者需要用现有的解码器解码另一个的视频流才会这么干。
                 *
                 * */

                /* 往编码器发送 null 的 AVFrame，让编码器把剩下的数据刷出来。*/
                ret = avcodec_send_frame(enc_ctx, NULL);
                for(;;)
                {
                    ret = avcodec_receive_packet(enc_ctx, pkt_out);
                    //这里不可能返回 EAGAIN，如果有直接退出。
                    if (ret == AVERROR(EAGAIN)){
                        printf("avcodec_receive_packet error code %d \n",ret);
                        return;
                    }
                    if ( AVERROR_EOF == ret ){
                        break;
                    }
                    //编码出 AVPacket ，先打印一些信息，然后把它写入文件。
                    printf("pkt_out size : %d \n",pkt_out->size);
                    //设置 AVPacket 的 stream_index ，这样才知道是哪个流的。
                    pkt_out->stream_index = st->index;
                    //转换 AVPacket 的时间基为 输出流的时间基。
                    pkt_out->pts = av_rescale_q_rnd(pkt_out->pts, fmt_ctx->streams[0]->time_base, st->time_base, static_cast<AVRounding>(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
                    pkt_out->dts = av_rescale_q_rnd(pkt_out->dts, fmt_ctx->streams[0]->time_base, st->time_base, static_cast<AVRounding>(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
                    pkt_out->duration = av_rescale_q_rnd(pkt_out->duration, fmt_ctx->streams[0]->time_base, st->time_base, static_cast<AVRounding>(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));


                    ret = av_interleaved_write_frame(fmt_ctx_out, pkt_out);
                    if (ret < 0) {
                        printf("av_interleaved_write_frame faile %d \n",ret);
                        return;
                    }
                    av_packet_unref(pkt_out);
                }
                av_write_trailer(fmt_ctx_out);
                //跳出 第二层 for，文件已经解码完毕。
                read_end = 1;
                break;
            }
            else if(ret >= 0)
            {
                //只有解码出来一个帧，才可以开始初始化编码器。

                if(NULL == enc_ctx)
                {
                    //打开编码器，并且设置 编码信息。
                    AVCodec *encode = avcodec_find_encoder(AV_CODEC_ID_H264);
                    enc_ctx = avcodec_alloc_context3(encode);
                    enc_ctx->codec_type = AVMEDIA_TYPE_VIDEO;
                    enc_ctx->bit_rate = 400000;
                    enc_ctx->framerate = avctx->framerate;
                    enc_ctx->gop_size = 30;
                    enc_ctx->max_b_frames = 10;
                    enc_ctx->profile = FF_PROFILE_H264_MAIN;
                    /*
                     * 其实下面这些信息在容器那里也有，也可以一开始直接在容器那里打开编码器
                     * 我从 AVFrame 里拿这些编码器参数是因为，容器的信息不一样就是最终的信息。
                     * 因为你解码出来的 AVFrame 可能会经过 filter 滤镜，经过滤镜之后信息就会变化，但是本文没有使用滤镜。
                     */
                    //编码器的时间基要取 AVFrame 的时间基，因为 AVFrame 是输入。
                    enc_ctx->time_base = fmt_ctx->streams[0]->time_base;
                    enc_ctx->width = fmt_ctx->streams[0]->codecpar->width;
                    enc_ctx->height = fmt_ctx->streams[0]->codecpar->height;
                    enc_ctx->sample_aspect_ratio = st->sample_aspect_ratio = frame->sample_aspect_ratio;
                    enc_ctx->pix_fmt = static_cast<AVPixelFormat>(frame->format);
                    enc_ctx->color_range            = frame->color_range;
                    enc_ctx->color_primaries        = frame->color_primaries;
                    enc_ctx->color_trc              = frame->color_trc;
                    enc_ctx->colorspace             = frame->colorspace;
                    enc_ctx->chroma_sample_location = frame->chroma_location;

                    /* 注意，这个 field_order 不同的视频的值是不一样的，这里我写死了。
                     * 因为 本文的视频就是 AV_FIELD_PROGRESSIVE
                     * 生产环境要对不同的视频做处理的
                     */
                    enc_ctx->field_order = AV_FIELD_PROGRESSIVE;

                    /* 现在我们需要把 编码器参数复制给流，解码的时候是 从流赋值参数给解码器。
                     * 现在要反着来。
                     * */
                    ret = avcodec_parameters_from_context(st->codecpar,enc_ctx);
                    if (ret < 0)
                    {
                        qDebug() << "avcodec_parameters_from_context codec faile:" << ret;
                        return;
                    }

                    //它用于初始化和打开音频或视频编解码器的上下文。
                    if ((ret = avcodec_open2(enc_ctx, encode, NULL)) < 0) {
                        qDebug() << "avcodec_open2 codec faile:" << ret;
                        return ;
                    }

                    //正式打开输出文件
                    if ((ret = avio_open2(&fmt_ctx_out->pb, filename_out, AVIO_FLAG_WRITE,&fmt_ctx_out->interrupt_callback,NULL)) < 0)
                    {
                        qDebug() << "avio_open2 codec faile:" << ret;
                        return;
                    }

                    //要先写入文件头部。
                    ret = avformat_write_header(fmt_ctx_out,NULL);
                    if (ret < 0)
                    {
                        qDebug() << "avformat_write_header codec faile:" << ret;
                        return;
                    }
                }

                //往编码器发送 AVFrame，然后不断读取 AVPacket
                ret = avcodec_send_frame(enc_ctx, frame);
                if (ret < 0)
                {
                    qDebug() <<  "avcodec_send_frame fail:"<<ret;
                    return;
                }

                for(;;)
                {
                    ret = avcodec_receive_packet(enc_ctx, pkt_out);
                    if (ret == AVERROR(EAGAIN))
                    {
                        break;
                    }
                    if (ret < 0)
                    {
                        qDebug() <<  "avcodec_receive_packet fail:"<<ret;
                        return;
                    }
                    //编码出 AVPacket ，先打印一些信息，然后把它写入文件。
                    qDebug() << "pkt_out size:"<<pkt_out->size;

                    //设置 AVPacket 的 stream_index ，这样才知道是哪个流的。
                    pkt_out->stream_index = st->index;
                    //转换 AVPacket 的时间基为 输出流的时间基。
                    pkt_out->pts = av_rescale_q_rnd(pkt_out->pts, fmt_ctx->streams[0]->time_base, st->time_base, static_cast<AVRounding>(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
                    pkt_out->dts = av_rescale_q_rnd(pkt_out->dts, fmt_ctx->streams[0]->time_base, st->time_base, static_cast<AVRounding>(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
                    pkt_out->duration = av_rescale_q_rnd(pkt_out->duration, fmt_ctx->streams[0]->time_base, st->time_base, static_cast<AVRounding>(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));

                    ret = av_interleaved_write_frame(fmt_ctx_out, pkt_out);
                    if (ret < 0) {
                        qDebug() <<  "av_interleaved_write_frame fail:"<<ret;
                        return;
                    }
                    av_packet_unref(pkt_out);
                }
            }
            else
            {
                qDebug() <<"other fail \n";
                return;
            }
        }
    }
    av_frame_free(&frame);
    av_packet_free(&pkt);
    av_packet_free(&pkt_out);

    //关闭编码器，解码器。
    avcodec_close(avctx);
    avcodec_close(enc_ctx);

    //释放容器内存。
    avformat_free_context(fmt_ctx);

    //必须调 avio_closep ，要不可能会没把数据写进去，会是 0kb
    avio_closep(&fmt_ctx_out->pb);
    avformat_free_context(fmt_ctx_out);
    qDebug() <<"done \n";

二、重要的API

1、avformat_alloc_context

avformat_alloc_context是FFmpeg库中的一个函数，用于动态分配并初始化一个AVFormatContext结构体。它的函数原型如下：

/**
 * Allocate an AVFormatContext.
 * avformat_free_context() can be used to free the context and everything
 * allocated by the framework within it.
 */
AVFormatContext *avformat_alloc_context(void);

该函数会分配一块内存，并将其初始化为一个空的AVFormatContext结构体，然后返回指向该结构体的指针。

使用avformat_alloc_context函数可以创建一个空的AVFormatContext对象，然后可以通过设置不同的字段和参数来配置它，以便进行音视频封装或解封装操作。
总结来说，avformat_alloc_context函数用于动态分配和初始化一个空的AVFormatContext对象，为后续的音视频封装和解封装操作做准备。
所以，分配后，可以对AVFormatContext 对象进行判空，防止初始化失败。

2、avformat_open_input

avformat_open_input是FFmpeg库中的一个函数，用于打开音视频输入文件并初始化相关的输入上下文（AVFormatContext）。它的函数原型如下：

/**
 * Open an input stream and read the header. The codecs are not opened.
 * The stream must be closed with avformat_close_input().
 *
 * @param ps       Pointer to user-supplied AVFormatContext (allocated by
 *                 avformat_alloc_context). May be a pointer to NULL, in
 *                 which case an AVFormatContext is allocated by this
 *                 function and written into ps.
 *                 Note that a user-supplied AVFormatContext will be freed
 *                 on failure.
 *> 传入值为avformat_alloc_context 分配的对象
 * @param url      URL of the stream to open.
 *> 要打开的流的地址
 * @param fmt      If non-NULL, this parameter forces a specific input format.
 *                 Otherwise the format is autodetected.
 * >输入的文件的格式，若为NULL,则自动检测
 * @param options  A dictionary filled with AVFormatContext and demuxer-private
 *                 options.
 *                 On return this parameter will be destroyed and replaced with
 *                 a dict containing options that were not found. May be NULL.
 *
 * @return 0 on success, a negative AVERROR on failure.
 *> 返回值0，为正确，其他值为失败
 * @note If you want to use custom IO, preallocate the format context and set its pb field.
 */
int avformat_open_input(AVFormatContext **ps, const char *url,
                        const AVInputFormat *fmt, AVDictionary **options);

该函数的参数说明如下：
ps：指向指针的指针，用于存储分配的AVFormatContext对象。
url：输入文件的URL或文件名。
fmt：指定输入格式，如果为NULL，则由FFmpeg自动检测输入文件的格式。
options：指向包含附加选项的字典。可以在打开输入文件时提供一些特定的选项，比如设置超时时间、设置输入缓冲大小等。

1、强调关闭使用avformat_close_input。
2、函数返回一个整数值，表示操作的结果。如果返回值小于0，则表示打开输入文件失败，否则返回0表示操作成功。使用avformat_open_input函数可以打开一个音视频输入文件，并将其与一个AVFormatContext对象关联起来，以便后续的音视频解封装操作。
3、avformat_open_input函数用于打开音视频输入文件，并初始化相关的输入上下文。它是进行音视频解封装操作的起点之一。

源码如下：

int avformat_open_input(AVFormatContext **ps, const char *filename,
                        ff_const59 AVInputFormat *fmt, AVDictionary **options)
{
    AVFormatContext *s = *ps;
    int i, ret = 0;
    AVDictionary *tmp = NULL;
    ID3v2ExtraMeta *id3v2_extra_meta = NULL;

    if (!s && !(s = avformat_alloc_context()))
        return AVERROR(ENOMEM);
    if (!s->av_class) {
        av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
        return AVERROR(EINVAL);
    }
    if (fmt)
        s->iformat = fmt;

    if (options)
        av_dict_copy(&tmp, *options, 0);

    if (s->pb) // must be before any goto fail
        s->flags |= AVFMT_FLAG_CUSTOM_IO;

    if ((ret = av_opt_set_dict(s, &tmp)) < 0)
        goto fail;

    if (!(s->url = av_strdup(filename ? filename : ""))) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

#if FF_API_FORMAT_FILENAME
FF_DISABLE_DEPRECATION_WARNINGS
    av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
FF_ENABLE_DEPRECATION_WARNINGS
#endif
    if ((ret = init_input(s, filename, &tmp)) < 0)
        goto fail;
    s->probe_score = ret;

    if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
        s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
        if (!s->protocol_whitelist) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
    }

    if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
        s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
        if (!s->protocol_blacklist) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
    }

    if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
        av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
        ret = AVERROR(EINVAL);
        goto fail;
    }

    avio_skip(s->pb, s->skip_initial_bytes);

    /* Check filename in case an image number is expected. */
    if (s->iformat->flags & AVFMT_NEEDNUMBER) {
        if (!av_filename_number_test(filename)) {
            ret = AVERROR(EINVAL);
            goto fail;
        }
    }

    s->duration = s->start_time = AV_NOPTS_VALUE;

    /* Allocate private data. */
    if (s->iformat->priv_data_size > 0) {
        if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        if (s->iformat->priv_class) {
            *(const AVClass **) s->priv_data = s->iformat->priv_class;
            av_opt_set_defaults(s->priv_data);
            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
                goto fail;
        }
    }

    /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
    if (s->pb)
        ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);

#if FF_API_DEMUXER_OPEN
    if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
#else
    if (s->iformat->read_header)
#endif
        if ((ret = s->iformat->read_header(s)) < 0)
            goto fail;

    if (!s->metadata) {
        s->metadata = s->internal->id3v2_meta;
        s->internal->id3v2_meta = NULL;
    } else if (s->internal->id3v2_meta) {
        av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
        av_dict_free(&s->internal->id3v2_meta);
    }

    if (id3v2_extra_meta) {
        if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
            !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
            if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
                goto close;
            if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
                goto close;
            if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
                goto close;
        } else
            av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
    }
    ff_id3v2_free_extra_meta(&id3v2_extra_meta);

    if ((ret = avformat_queue_attached_pictures(s)) < 0)
        goto close;

#if FF_API_DEMUXER_OPEN
    if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
#else
    if (s->pb && !s->internal->data_offset)
#endif
        s->internal->data_offset = avio_tell(s->pb);

    s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;

    update_stream_avctx(s);

    for (i = 0; i < s->nb_streams; i++)
        s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;

    if (options) {
        av_dict_free(options);
        *options = tmp;
    }
    *ps = s;
    return 0;

close:
    if (s->iformat->read_close)
        s->iformat->read_close(s);
fail:
    ff_id3v2_free_extra_meta(&id3v2_extra_meta);
    av_dict_free(&tmp);
    if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
        avio_closep(&s->pb);
    avformat_free_context(s);
    *ps = NULL;
    return ret;
}

分析可以查看雷神的这篇文章:
FFmpeg源代码简单分析：avformat_open_input()
可以看到，若打开文件失败，或是分配资源失败等等，都会将传入的AVFormatContext的对象置为NULL.

3、avcodec_alloc_context3

avcodec_alloc_context3 是 FFmpeg 库中的一个函数，用于分配并初始化一个 AVCodecContext 结构体，该结构体用于编解码器的相关信息和参数设置。
AVCodecContext 结构体是 FFmpeg 库中最为重要的结构之一，它包含了编解码器的相关信息，例如编码器类型、编码器参数、图像尺寸、音频采样率等。通过 AVCodecContext，你可以对媒体数据进行编解码操作，并设置编解码器的各种参数。
使用 avcodec_alloc_context3 函数可以创建一个空的 AVCodecContext 结构体，并将其内部字段初始化为默认值。
需要注意的是，分配的 AVCodecContext 结构体在使用完毕后，需要通过调用 avcodec_free_context 函数进行释放，以避免内存泄漏。
总而言之，avcodec_alloc_context3 函数用于分配并初始化 AVCodecContext 结构体，为后续的编解码操作提供基础。你可以使用该函数创建一个编解码器上下文，并设置相应的参数，以便进行媒体数据的编解码处理。

4、avcodec_parameters_to_context

1、用于将AVCodecParameters结构体的值赋值给AVCodecContext结构体的对应字段。AVCodecParameters结构体包含了编解码器相关的参数信息，而AVCodecContext结构体则是编解码器的上下文环境。
2、该函数会根据AVCodecParameters结构体中的值，更新AVCodecContext结构体中对应的字段。参数值的赋值涉及到了编解码器的基本配置，例如编码类型、码率、帧率等等。这样可以方便地将参数信息传递给编解码器上下文，以供后续的编解码操作使用。

5、avformat_alloc_output_context2

参数解析：

  • AVFormatContext **ctx: 输出参数，指向分配的输出格式上下文的指针。
  • AVOutputFormat *oformat: 输出参数，指定要分配的输出格式。
  • const char *format_name: 可选参数，用于指定输出格式的短名称。如果为NULL，则根据输出文件的扩展名自动推断。
  • const char *filename: 输出文件的路径或URL。

1、首先，该函数会尝试通过指定的输出格式来分配一个输出格式上下文（AVFormatContext）。如果format_name参数为NULL，函数会尝试根据输出文件的扩展名猜测输出格式。然后，分配的上下文将被赋值给ctx指针。
2、在成功分配输出格式上下文后，我们可以继续设置该上下文的各种参数，如音视频编码器、封装格式的选项等。

6、avformat_new_stream

avformat_new_stream是FFmpeg库中的一个函数，用于创建一个新的音视频流（stream）并将其添加到封装格式上下文（AVFormatContext）中。

7、avcodec_parameters_from_context

用于从已存在的编码器上下文(AVCodecContext)中获取编码器参数。

END、总结的知识与问题

参考

1、FFmpeg写入输出文件—FFmpeg API教程

CoderForge
关注
  • 25
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FFmpeg视频解码器
qq_46470984的博客
05-06 2056
目录视频解码知识VC下FFmpeg开发环境的搭建示例程序运行FFmpeg解码的函数FFmpeg解码的数据结构 视频解码知识 • 纯净的视频解码流程 压缩编码数据->像素数据。 例如解码H.264，就是“H.264码流->YUV”。 • 一般的视频解码流程 视频码流一般存储在一定的封装格式（例如MP4、AVI等）中。封装格式中通常还包含音频码流等内容。 对于封装格式中的视频，需要先从封装格式中提取中视频码流，然后再进行解码。 例如解码MKV格式的视频文件，就是“MKV->H.264码流-&g
FFMPEG实现音频重采样
07-28
FFMPEG实现音频重采样,示例代码实现将PCM的交叉存储方式转换成平行存储方式
【视频格式转换】【ffmepg】对mp4文件进行重新编码输出新的mp4文件
最新发布
随意一局的技术人生
05-09 576
ffmpeg命令 重新解码并编码成mp4文件
使用ffmpeg对视频进行重新编码
we chat：玩转测试开发
01-15 4466
简介：在部分场景中，视频无法进行解析处理，需要对视频重新编码，这时可以使用ffmpeg。 注意事项：过高的版本无法直接重新编码，需要较低版本。 错误范例： ffmpeg -i a.mp4 -c:v h264 -q:v 5 -threads 8 b.mp4 错误范例执行： 错误范例执行完成后：转化的文件无法正常播放，并且文件大小相距甚远 正确范例：使用低版本的ffmpeg ffmpeg -i a.mp4 -c:v h264 -q:v 5 -threads 8 b.mp4 执行结果：正常播放，并且文件大
ffmpeg 录像 (解码后重新编码)
z373248439的博客
01-21 1143
ffmpeg 可以通过直接保存解复用后的packet包实现录像，但这种方法无法改变视频内容，解复用得到的是什么，保存的就是什么。如果希望在视频上叠加字符或其他内容就不能用这种方法。直接保存packet包将在下一篇文章中介绍。本文主要介绍接收RTSP网络视频流，重新编码解码后的视频帧。 首先创建输出文件： int open_output_file(const char *filename, int enctype, int width, int height) { AVStream *out_stre
ffmpeg 编译cpu--cpu_清华学霸直博简历：CPU、操作系统、编译器全自主写
weixin_42509847的博客
12-27 162
最近，知乎上有一条帖子火了，该帖子题为“清华大学计算机专业本科这位在“自己写的 CPU 上运行自己写的操作系统”的同学是什么水平？”，提问者对清华大学计算机系副教授、博士生导师刘知远(主要研究方向为表示学习、知识图谱和社会计算)的一条微博感兴趣，在知乎上进行了提问。具体情况是清华大学某位计算机专业的本科生，在院系直博面试的简历上，有一个“在自己写的 CPU 上运行自己写的操作系统”的 Rust 语...
NDK开发——FFmpeg在Linux下编译、移植命令行、合并音视频.zip
02-11
FFmpeg是一款开源的跨平台多媒体处理工具，广泛用于音频、视频的编码、解码、转换、流媒体处理等任务。在Android NDK环境下，开发者可以利用FFmpeg进行原生的音视频处理，提高效率和性能。本文将详细介绍如何在Linux...
安卓Android源码——rockplayer_ffmpeg.rar
10-11
在RockPlayer中，ffmpeg主要负责视频和音频的解码工作，它的引入大大增强了RockPlayer对各种编码格式的支持。 1. **ffmpeg的核心组件** - libavcodec：这是ffmpeg的核心组件，包含了各种编解码器，用于处理音频和...
安卓Android源码——基于SDL、FFmpeg的播放器源码.zip
10-11
这个压缩包“安卓Android源码——基于SDL、FFmpeg的播放器源码.zip”包含了一个使用这两个库实现的视频播放器的源代码。以下是对这些知识点的详细说明： 1. **SDL (Simple DirectMedia Layer)**: SDL是一个跨平台的...
ffmpeg_x64库.zip
12-01
在你提供的"ffmpeg_x64库.zip"中，包含的三个主要目录——bin、include 和 lib——分别对应于可执行文件、头文件和库文件，这些都是构建和运行FFmpeg相关应用的基础。 **bin** 目录： 这个目录通常包含了FFmpeg的可...
安卓Android源码——基于SDL、FFmpeg的android播放器源码.zip
10-10
本项目中的“安卓Android源码——基于SDL、FFmpeg的android播放器源码.zip”是一个示例，它展示了如何利用这两个库在Android设备上实现音视频播放功能。 **SDL（Simple DirectMedia Layer）** 是一个跨平台的开发库...
【FFmpeg】ffmpeg 命令行参数 ⑤ ( 使用 ffmpeg 命令提取 音视频 数据 | 保留封装格式 | 保留编码格式 | 重新编码 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
03-09 2411
一、使用 ffmpeg 命令提取 音视频 数据 1、提取音频数据 - 保留封装格式 2、提取视频数据 - 保留封装格式 3、提取视频数据 - 保留编码格式 4、提取视频数据 - 重新编码 5、提取音频数据 - 保留编码格式 6、提取音频数据 - 重新编码
Linux实现ffmpeg H.265视频编码
liveweb视频汇聚平台
11-22 212
或者，这意味着可以以相同的比特率显着改善视频的质量，这对于非常高的清晰度是非常重要的（即，即4K和8K）显示。MPEG-1来源于MPEG-2，被选为DVD视频的视频压缩标准。MPEG-2也被国际电信联盟（ITU）批准为H.262.DVD光盘后，支持MPEG-2编码的视频也支持H.264或MPEG-4第10部分，高级视频编码（MPEG-4 AVC）正式公布。Linux用户的好消息是，H.265编解码器在流行的编码套件中可用265编译获取最新和功能最强大的ffmpeg版本的最简单的方法是下载静态链接的构建。
获取ffmpeg占cpu使用率
caoqinghua的专栏
04-10 2418
Module Module1 Sub Main() Dim cpu As New PerformanceCounter("Processor", "% Processor Time", "_Total") Dim pros As Process() While True pros = Process.GetPro...
ffmpeg转换视频编码
数字人生
03-09 5085
1.运行ffmpeg -codecs查看支持的编码器 # ffmpeg -codecs ffmpeg version N-103222-gf040c1e Copyright (c) 2000-2021 the FFmpeg developers built with gcc 4.9.2 (Debian 4.9.2-10+deb8u2) configuration: --enable-libx265 --enable-libx264 --enable-gpl libavutil 57
FFmpeg编解码处理3-视频编码
yinshipin007的博客
04-10 348
做一个实验，修改 5.1.2 节 frame_flt->pict_type 值和 5.1.1 节 enc_ctx->gop_size 和 enc_ctx->max_b_frames，将编码后视频帧 I/B/P 类型打印出来，观察实验结果。
FFmpeg音视频处理详解及实战
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
06-10 2823
FFmpeg项目由 Fabrice Bellard在2000年创立。到目前为止，FFmpeg项目的开发者仍然与VLC、MPV、dav1d、x264等多媒体开源项目有着广泛的重叠。Ffmpeg（FastForward Mpeg）是一款遵循GPL的开源软件，在音视频处理方面表现十分优秀，几乎囊括了现存所有的视音频格式的编码，解码、转码、混合、过滤及播放。作为最受欢迎的视频和图像处理软件，它被来自各行各业的不同公司所广泛使用。同时也是一款跨平台的软件，完美兼容Linux、Windows、Mac OSX等平台。
FFmpeg编码扩展之————编码库的扩展（libfdk-aac）
05-25
FFmpeg是一个用于处理多媒体数据的开源框架，其中包含了众多的编解码库，可以支持各种音视频格式的转码、处理和播放。其中，libfdk-aac是一个高质量的AAC音频编码库，它的优势在于输出的音频质量非常高，而且编码速度也比其他编码库要快。 在使用FFmpeg进行音频编码时，默认情况下使用的是libmp3lame编码库，但是在有些情况下，比如需要输出更高质量的音频数据时，就可以考虑使用libfdk-aac编码库，以获得更好的音频输出效果。 下面是使用FFmpeg编译安装libfdk-aac编码库的步骤： 1. 下载libfdk-aac源代码 可以在官网（https://github.com/mstorsjo/fdk-aac）下载最新的libfdk-aac源代码，也可以选择在其他开源镜像网站上下载。 2. 编译安装libfdk-aac 通过以下命令进入libfdk-aac源代码目录，执行configure和make命令进行编译和安装： ``` $ cd /path/to/libfdk-aac $ ./configure --prefix=/usr/local --enable-shared $ make && sudo make install ``` 其中，--prefix=/usr/local表示将libfdk-aac安装到系统默认的库目录下，--enable-shared表示编译生成共享库文件。 3. 配置FFmpeg编译选项 在FFmpeg编译时，需要指定使用libfdk-aac编码库，可以通过以下命令进行配置： ``` $ ./configure --enable-gpl --enable-libfdk-aac --enable-nonfree $ make && sudo make install ``` 其中，--enable-gpl表示启用GPL协议，--enable-libfdk-aac表示启用libfdk-aac编码库，--enable-nonfree表示启用非免费的编码库。 4. 使用libfdk-aac进行音频编码 在FFmpeg进行音频编码时，需要指定使用libfdk-aac编码库，可以通过以下命令进行操作： ``` $ ffmpeg -i input.wav -c:a libfdk_aac -b:a 128k output.aac ``` 其中，-c:a libfdk_aac表示使用libfdk-aac编码库进行音频编码，-b:a 128k表示设置输出音频的比特率为128kbps。 通过以上步骤，就可以成功地使用libfdk-aac扩展FFmpeg的编码功能，获得更高质量的音频输出效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值