^-^
音视频开发_过滤器串实现图像叠加
最近更新：2024-09-23   |   字数总计：1.1k   |   阅读估时：6分钟   |   阅读量：次
  1. 功能分析
  2. 功能一
    1. Parse过滤器串
    2. 混合图像
  3. 功能二
    1. 解复用及解码
    2. 过滤器
    3. 编码器
    4. main test

功能分析

  1. 功能一：两个jpg图片通过过滤器合成一张jpg
  2. 功能二：给视频添加水印

功能一

Parse过滤器串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
AVFilterContext *mainsrc_ctx = NULL;
AVFilterContext *logosrc_ctx = NULL;
AVFilterContext *resultsink_ctx = NULL;
AVFilterGraph *filter_graph = NULL;

int init_filters(const AVFrame* main_frame, const AVFrame* logo_frame, int x, int y)
{
    int ret = 0;
    AVFilterInOut *inputs = NULL;
    AVFilterInOut *outputs = NULL;
    char filter_args[1024] = { 0 };

    filter_graph = avfilter_graph_alloc();
    if (!filter_graph) {
        printf("Error: allocate filter graph failed\n");
        return -1;
    }

    snprintf(filter_args, sizeof(filter_args),
             "buffer=video_size=%dx%d:pix_fmt=%d:time_base=1/25:pixel_aspect=%d/%d[main];" // Parsed_buffer_0
             "buffer=video_size=%dx%d:pix_fmt=%d:time_base=1/25:pixel_aspect=%d/%d[logo];" // Parsed_bufer_1
             "[main][logo]overlay=%d:%d[result];" // Parsed_overlay_2
             "[result]buffersink", // Parsed_buffer_sink_3
             main_frame->width, main_frame->height, main_frame->format, main_frame->sample_aspect_ratio.num, main_frame->sample_aspect_ratio.den,
             logo_frame->width, logo_frame->height, logo_frame->format, logo_frame->sample_aspect_ratio.num, logo_frame->sample_aspect_ratio.den,
             x, y);

    ret = avfilter_graph_parse2(filter_graph, filter_args, &inputs, &outputs);
    if (ret < 0) {
        printf("Cannot parse graph\n");
        return ret;
    }

    ret = avfilter_graph_config(filter_graph, NULL);
    if (ret < 0) {
        printf("Cannot configure graph\n");
        return ret;
    }

    // Get AVFilterContext from AVFilterGraph parsing from string
    mainsrc_ctx = avfilter_graph_get_filter(filter_graph, "Parsed_buffer_0");
    logosrc_ctx = avfilter_graph_get_filter(filter_graph, "Parsed_buffer_1");
    resultsink_ctx = avfilter_graph_get_filter(filter_graph, "Parsed_buffersink_3");

    return 0;
}

混合图像

1
2
3
4
5
6
7
8
9
10
11
12
13
int main_picture_mix_logo(AVFrame *main_frame, AVFrame *logo_frame, AVFrame *result_frame)
{
    int ret = 0;
    // Fill data to buffer filter context(main, logo)
    ret = av_buffersrc_add_frame(mainsrc_ctx, main_frame);      // 输入0
    if(ret < 0)
        return ret;
    ret = av_buffersrc_add_frame(logosrc_ctx, logo_frame);      // 输入1
    if(ret < 0)
        return ret;
    ret = av_buffersink_get_frame(resultsink_ctx, result_frame);
    return ret;
}

功能二

  • 完成一个flv视频解封装、解码、过滤器、编码h264的过程

解复用及解码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static int open_input_file(const char *filename)
{
    int ret;
    AVCodec *dec;
    if((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0){
        return ret;
    }
    if((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0){
        return ret;
    }

    ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
    if(ret < 0)
        return ret;
    video_stream_index = ret;
    dec_ctx = fmt_ctx->streams[video_stream_index]->codec;
    av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);
    if((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0)
    {
        return ret;
    }
    return 0;
}

过滤器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
const char *filter_descr = "movie=logo.jpg[overlog];[in][overlog]overlay=10:main_h-overlay_h-10";
static int init_filter(const char*filter_descr)
{
    char args[512];
    int ret = 0;
    AVFilter *buffersrc = avfilter_get_by_name("buffer");
    AVFilter *buffersink = avfilter_get_by_name("buffersink");
    AVFilterInOut *outputs = avfilter_inout_alloc();
    AVFilterInOut *inputs = avfilter_inout_alloc();
    AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;
    enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };

    filter_graph = avfilter_graph_alloc();
    if (!outputs || !inputs || !filter_graph) {
        ret = AVERROR(ENOMEM);
        goto end;
    }

    // 输入filter
    snprintf(args, sizeof(args),
        "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
        dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
        time_base.num, time_base.den,
        dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
        ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
        args, NULL, filter_graph);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
        goto end;
    }

    // 输出filter
    /* buffer video sink: to terminate the filter chain. */
    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
        NULL, NULL, filter_graph);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
        goto end;
    }

    ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
        AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
        goto end;
    }
    outputs->name = av_strdup("in");
    outputs->filter_ctx = buffersrc_ctx;
    outputs->pad_idx = 0;
    outputs->next = NULL;
    inputs->name = av_strdup("out");
    inputs->filter_ctx = buffersink_ctx;
    inputs->pad_idx = 0;
    inputs->next = NULL;

    if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
        &inputs, &outputs, NULL)) < 0)
        goto end;
    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
        goto end;
end:
    avfilter_inout_free(&inputs);
    avfilter_inout_free(&outputs);

    return ret;
}

编码器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
static int open_output_file()
{
    int ret = 0;
    AVDictionary *options = NULL;
    AVCodec* enc_codec = avcodec_find_encoder_by_name("libx264");
    enc_ctx = avcodec_alloc_context3(enc_codec);
    if(!enc_ctx)
        return AVERROR(ENOMEM);
    enc_ctx->time_base.num = dec_ctx->time_base.num;
    enc_ctx->time_base.den = dec_ctx->time_base.den;
    enc_ctx->pix_fmt = dec_ctx->pix_fmt;
    enc_ctx->width = dec_ctx->width;
    enc_ctx->height = dec_ctx->height;
    enc_ctx->has_b_frames = dec_ctx->has_b_frames;
    enc_ctx->bit_rate = 1500 * 1024;
    enc_ctx->gop_size = 250;
    av_dict_set(&options, "profile", "main",0);
    av_dict_set(&options, "tune", "zerolatency",0);
    av_dict_set(&options, "preset", "medium", 0);
    ret = avcodec_open2(enc_ctx, enc_codec, &options);
    if (ret){
        av_log(NULL, AV_LOG_ERROR, "open2 error\n");
        av_dict_free(&options);
        return ret;
    }
    av_dict_free(&options);
    out_file = fopen("test.h264", "wb");
    if (!out_file)
        return -1;
    return ret;
}

main test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
int ret;
AVPacket packet;
AVFrame *frame = av_frame_alloc();
AVFrame *filt_frame = av_frame_alloc();

const char* input_file = "time1.flv";

if (!frame || !filt_frame) {
    perror("Could not allocate frame");
    exit(1);
}


if ((ret = open_input_file(input_file)) < 0)
    goto end;
if ((ret = init_filters(filter_descr)) < 0)
    goto end;

if ((ret = open_output_file()) < 0)
    goto end;

/* read all packets */
while (1) {
    if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)
        break;

    if (packet.stream_index == video_stream_index) {
        ret = avcodec_send_packet(dec_ctx, &packet); // 送去解码
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error decoding video\n");
            break;
        }
        ret = avcodec_receive_frame(dec_ctx, frame); // 获得已解码的帧
        if (ret == AVERROR(EAGAIN))
            continue;
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error decoding video\n");
            break;
        }

        frame->pts = av_frame_get_best_effort_timestamp(frame); // 送去过滤器

        /* push the decoded frame into the filtergraph */
        if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
            break;
        }

        /* pull filtered frames from the filtergraph */
        while (1) {
            AVPacket pkt;
            av_init_packet(&pkt);
            ret = av_buffersink_get_frame(buffersink_ctx, filt_frame); // 过滤器后结果
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                break;
            if (ret < 0)
                goto end;
            //  display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);
            ret = avcodec_send_frame(enc_ctx, filt_frame); // 送去编码
            if (ret < 0) {
                av_log(NULL, AV_LOG_ERROR, "Error send_frame video\n");
                av_packet_unref(&pkt);
                av_frame_unref(filt_frame);
                break;
            }
            ret = avcodec_receive_packet(enc_ctx, &pkt); // 接受编码帧
            if (ret < 0) {
                av_log(NULL, AV_LOG_ERROR, "Error receive_packet video\n");
                av_packet_unref(&pkt);
                av_frame_unref(filt_frame);
                break;
            }
            fwrite(pkt.data, 1, pkt.size, out_file); // 写入h264文件
            av_packet_unref(&pkt);
            av_frame_unref(filt_frame);
        }
        av_frame_unref(frame);
    }
    av_packet_unref(&packet);
}

//should flush ignore here
end:
avfilter_graph_free(&filter_graph);
avcodec_close(dec_ctx);
avformat_close_input(&fmt_ctx);
av_frame_free(&frame);
av_frame_free(&filt_frame);

avcodec_close(enc_ctx);
if (out_file)
{
    fclose(out_file);
    out_file = NULL;
}
printf("finish\n");
if (ret < 0 && ret != AVERROR_EOF) {
    fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
    exit(1);
}

exit(0);
2023-12-13 该篇文章被 Cleofwine 归为分类: 音视频

上一篇：音视频开发_FFmpeg QT 播放器实现 下一篇：音视频开发_PCM 音频混流
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题