用ffmpeg给视频添加水印的命令为：

    1.             ffmpeg -i in.mp4 -i xxx.png -filter_complex "overlay=5:5"  out.mp4

    代码实现如下, 主要是用了参考了ffmpeg.c里面的filter_complex的代码:

    1. #include <unistd.h>
    2. #include <stdio.h>
    3. #include <assert.h>
    5. #include <libavcodec/avcodec.h>
    6. #include <libavformat/avformat.h>
    7. #include <libavfilter/avfiltergraph.h>
    8. #include <libavfilter/avcodec.h>
    9. #include <libavfilter/buffersink.h>
    10. #include <libavfilter/buffersrc.h>
    11. #include <libswscale/swscale.h>
    13. const char *filter_descr = "overlay=5:5"; 
    15. #define ENABLE_YUV_FILE 1
    17. AVFormatContext *input_fmt_ctx;
    18. AVCodecContext *input_dec_ctx;
    20. AVFormatContext *overlay_fmt_ctx;
    21. AVCodecContext *overlay_dec_ctx;
    23. int input_video_stream_idx, overlay_video_stream_idx;
    25. AVFilterGraph *filter_graph;
    27. AVFilterInOut *inputs;
    28. AVFilterInOut *outputs;
    30. AVFilterContext *buffersrc_ctx;
    31. AVFilterContext *bufferoverlay_ctx;
    32. AVFilterContext *buffersink_ctx;
    34. int ret;
    35. int got_frame;
    37. int video_eof_reached = 0;
    38. int overlay_eof_reached = 0;
    40. int active_stream_index = -1;
    42. FILE* fp_yuv;
    44. void yuv420p_save(AVFrame *pFrame);
    45. int video_transcode_step(AVFrame* mVideoFrame);
    46. int overlay_transcode_step(AVFrame* mOverlayFrame);
    47. int video_output_eof_packet(const char* tag, 
    48.     AVStream* ist, AVFilterContext* ifilter);
    50. static int open_input_file(const char *filename)
    51. {
    52.     int ret;
    53.     AVCodec *dec;
    55.     if ((ret = avformat_open_input(&input_fmt_ctx, filename, NULL, NULL)) < 0) {
    56.         av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
    57.         return ret;
    58.     }
    60.     if ((ret = avformat_find_stream_info(input_fmt_ctx, NULL)) < 0) {
    61.         av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
    62.         return ret;
    63.     }
    65.     /* select the video stream */
    66.     ret = av_find_best_stream(input_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
    67.     if (ret < 0) {
    68.         av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");
    69.         return ret;
    70.     }
    71.     input_video_stream_idx = ret;
    72.     input_dec_ctx = input_fmt_ctx->streams[input_video_stream_idx]->codec;
    74.     /* init the video decoder */
    75.     if ((ret = avcodec_open2(input_dec_ctx, dec, NULL)) < 0) {
    76.         av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");
    77.         return ret;
    78.     }
    80.     return 0;
    81. }
    84. static int open_overlay_file(const char *filename)
    85. {
    86.     int ret;
    87.     AVCodec *dec;
    89.     if ((ret = avformat_open_input(&overlay_fmt_ctx, filename, NULL, NULL)) < 0) {
    90.         av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
    91.         return ret;
    92.     }
    94.     if ((ret = avformat_find_stream_info(overlay_fmt_ctx, NULL)) < 0) {
    95.         av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
    96.         return ret;
    97.     }
    99.     /* select the video stream */
    100.     ret = av_find_best_stream(overlay_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
    101.     if (ret < 0) {
    102.         av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");
    103.         return ret;
    104.     }
    105.     overlay_video_stream_idx = ret;
    106.     overlay_dec_ctx = overlay_fmt_ctx->streams[overlay_video_stream_idx]->codec;
    108.     /* init the video decoder */
    109.     if ((ret = avcodec_open2(overlay_dec_ctx, dec, NULL)) < 0) {
    110.         av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");
    111.         return ret;
    112.     }
    114.     printf("overlay format = %s\n", overlay_fmt_ctx->iformat->name);
    116.     return 0;
    117. }
    120. static int video_config_input_filter(AVFilterInOut* inputs, AVFilterContext** input_filter_ctx)
    121. {
    122.     char args[512];
    123.     memset(args, 0, sizeof(args));
    125.     AVFilterContext *first_filter = inputs->filter_ctx;
    126.     int pad_idx = inputs->pad_idx;
    128.     AVFilter *filter = avfilter_get_by_name("buffer");
    129. //    AVRational time_base = input_dec_ctx->time_base;
    130.     AVStream* video_st = input_fmt_ctx->streams[input_video_stream_idx];
    131.     AVRational time_base = video_st->time_base;
    133.     snprintf(args, sizeof(args),
    134.             "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d:sws_param=flags=%d:frame_rate=%d/%d",
    135.             input_dec_ctx->width, input_dec_ctx->height, input_dec_ctx->pix_fmt,
    136.             input_dec_ctx->time_base.num, input_dec_ctx->time_base.den,
    137.             input_dec_ctx->sample_aspect_ratio.num, input_dec_ctx->sample_aspect_ratio.den,
    138.         SWS_BILINEAR + ((video_st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0),
    139.         video_st->r_frame_rate.num, video_st->r_frame_rate.den);
    141.        printf("input args = %s\n", args);
    143.     ret = avfilter_graph_create_filter(input_filter_ctx, filter, "src_in", args, NULL, filter_graph);
    145.     if (ret < 0 ) {
    146.         printf("video config input filter fail.\n");
    147.         return -1;
    148.     }
    149.     ret = avfilter_link(*input_filter_ctx, 0, first_filter, pad_idx);
    150.     assert(ret >= 0);
    152.     printf("video_config_input_filter avfilter_link ret = %d\n", ret);
    154.     return ret;
    156. }
    158. static int video_config_overlay_filter(AVFilterInOut* inputs, AVFilterContext** overlay_filter_ctx )
    159. {
    160.     char args[512];
    161.     memset(args, 0, sizeof(args));
    163.     AVFilterContext *first_filter = inputs->filter_ctx;
    165.     int pad_idx = inputs->pad_idx;
    167.     AVFilter *filter = avfilter_get_by_name("buffer");
    169.     //AVRational time_base = overlay_dec_ctx->time_base;
    170.     AVStream* overlay_st = overlay_fmt_ctx->streams[overlay_video_stream_idx];
    171.     AVRational time_base = overlay_st->time_base;
    173.     snprintf(args, sizeof(args),
    174.             "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d:sws_param=flags=%d:frame_rate=%d/%d",
    175.             overlay_dec_ctx->width, overlay_dec_ctx->height, overlay_dec_ctx->pix_fmt,
    176.             time_base.num, time_base.den,
    177.         overlay_dec_ctx->sample_aspect_ratio.num, overlay_dec_ctx->sample_aspect_ratio.den,
    178.         SWS_BILINEAR + ((overlay_st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0),
    179.             overlay_st->r_frame_rate.num, overlay_st->r_frame_rate.den);
    181.        printf("overlay args = %s\n", args);
    183.     ret = avfilter_graph_create_filter(overlay_filter_ctx, filter, "overlay_in", args, NULL, filter_graph);
    185.     if (ret < 0 ) {
    186.         printf("video config overlay filter fail.\n");
    187.         return -1;
    188.     }
    190.     ret = avfilter_link(*overlay_filter_ctx, 0, first_filter, pad_idx);
    191.     assert(ret >= 0);
    193.     printf("video_config_overlay_filter ret = %d\n", ret);
    195.     avfilter_inout_free(&inputs);
    197.     return ret;
    199. }
    201. static int video_config_output_filter(AVFilterInOut* outputs, AVFilterContext** out_filter_ctx)
    202. {
    203.     char args[512];
    205.     AVFilterContext *last_filter = outputs->filter_ctx;
    206.     int pad_idx  = outputs->pad_idx;
    207.     AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");
    209.     int ret = avfilter_graph_create_filter(out_filter_ctx, buffersink, "video_out", NULL, NULL, filter_graph);
    210.     assert(ret >= 0);
    212.     if (ret < 0)
    213.         return ret;
    215.     ret = avfilter_link(last_filter, pad_idx, *out_filter_ctx, 0);
    216.     assert(ret >= 0);
    217.     if (ret < 0)
    218.         return ret;
    220.     avfilter_inout_free(&outputs);
    222.     return 0;
    224. }
    226. static int init_input_filters()
    227. {
    228.     filter_graph->scale_sws_opts = av_strdup("flags=0x4");
    229.         av_opt_set(filter_graph, "aresample_swr_opts", "", 0);
    231.     ret = avfilter_graph_parse2(filter_graph, filter_descr, &inputs, &outputs);
    233.     assert(inputs && inputs->next && !inputs->next->next);    
    235.     ret = video_config_input_filter(inputs, &buffersrc_ctx);
    237.     ret = video_config_overlay_filter(inputs->next, &bufferoverlay_ctx);
    239.     return ret;
    240. }
    242. static int init_output_filters()
    243. {
    244.     return video_config_output_filter(outputs, &buffersink_ctx);
    245. }
    247. int reap_filters() {
    248.     AVFilterBufferRef *picref;
    250.     while (1) {
    251.         ret = av_buffersink_get_buffer_ref(buffersink_ctx, &picref, AV_BUFFERSINK_FLAG_NO_REQUEST);
    252.         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
    253.             //printf("reap_filters fail ret = %d\n", ret);
    254.             return 0; // no frame filtered.
    255.         }    
    257.         printf("samplesref -------------------\n");
    259.         AVFrame* filtered_frame = avcodec_alloc_frame();
    260.         avcodec_get_frame_defaults(filtered_frame);
    262.         avfilter_copy_buf_props(filtered_frame, picref);
    264.         yuv420p_save(filtered_frame);
    266.         avfilter_unref_bufferp(&picref);
    267.     }
    269. }
    271. int transcode_from_filter(AVFilterContext** ifilters, int* eof_reached_arr, int* active_stream_indext) {
    272.     int ret = 0;
    274.     ret = avfilter_graph_request_oldest(filter_graph);
    276.     if (ret >= 0) {
    277.         return ret;
    278.         }
    279.     if (ret == AVERROR_EOF) {
    280.         return ret;
    281.     }
    282.     if (ret != AVERROR(EAGAIN)) {
    283.         return ret;
    284.     }
    286.     int nb_requests_max = 0;
    287.     int i;
    288.     for (i = 0; i < 2; i++) {
    289.         int eof_reached = eof_reached_arr[i];
    290.         if (eof_reached) {
    291.             continue;
    292.         }
    293.         AVFilterContext* ifilter = ifilters[i];
    294.         int nb_requests = av_buffersrc_get_nb_failed_requests(ifilter);
    295.         if (nb_requests > nb_requests_max) {
    296.             nb_requests_max = nb_requests;
    297.             *active_stream_indext = i;
    298.         }
    299.     }
    301.     return ret;
    303. }
    306. int main()
    307. {
    308.     avcodec_register_all();
    309.     av_register_all();
    310.     avfilter_register_all();
    311.     avformat_network_init();
    314.     char* video_file = "outFileSrc.mp4";
    315.     char* overlay_video_file = "my_logo.png"; // light1.mp4 
    318. #if ENABLE_YUV_FILE
    319.     const char* yuvFile = "outWater.yuv";
    321.     fp_yuv = fopen(yuvFile, "wb");
    323. #endif
    325.     open_input_file(video_file);
    326.     open_overlay_file(overlay_video_file);
    328.     filter_graph = avfilter_graph_alloc();
    329.     if (!filter_graph) {
    330.         printf("filter graph alloc fail.\n");
    331.         return -1;
    332.     }
    334.     init_input_filters();
    335.     init_output_filters();    
    337.     if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
    338.             return ret;
    340.     AVFrame* mVideoFrame = avcodec_alloc_frame();
    341.     AVFrame* mOverlayFrame = avcodec_alloc_frame();
    343.     while(1) {
    344.         if (video_eof_reached && overlay_eof_reached) {
    345.                 printf("stream EOF.\n");
    346.             break;
    347.         }
    349.         AVFilterContext* ifilters[] = {buffersrc_ctx, bufferoverlay_ctx};
    350.         int eof_reacheds[] = {video_eof_reached, overlay_eof_reached};
    352.         ret = transcode_from_filter(ifilters, eof_reacheds, &active_stream_index);
    354.         if (ret >= 0) {
    355.             ret = reap_filters();
    356.             assert(ret >= 0);
    357.             continue;
    358.             }
    359.         if (ret == AVERROR_EOF) {
    360.             ret = reap_filters();
    361.             assert(ret >= 0);
    362.             continue;
    363.         }
    365.         if (ret == AVERROR(EAGAIN) && active_stream_index < 0) {
    366.             continue;
    367.         }
    368.         assert(active_stream_index >= 0);
    370.         printf("active_stream_index = %d\n", active_stream_index);
    372.         if (active_stream_index == 0) {
    373.             video_transcode_step(mVideoFrame);
    374.             continue;
    375.         }
    377.         overlay_transcode_step(mOverlayFrame);
    379.     }
    381.     if (input_dec_ctx)
    382.         avcodec_close(input_dec_ctx);
    383.     avformat_close_input(&input_fmt_ctx);
    385.     if (overlay_dec_ctx)
    386.         avcodec_close(overlay_dec_ctx);
    387.     avformat_close_input(&overlay_fmt_ctx);
    391.     printf("my_filtering_video3 end -------\n");
    392.     return 0;
    393. }
    395. int video_transcode_step(AVFrame* mVideoFrame) {
    396.     int ret = 0;
    397.     AVPacket pkt;
    399.     ret = av_read_frame(input_fmt_ctx, &pkt);
    400.     if (ret == AVERROR(EAGAIN)) {
    401.         return 0;
    402.     }
    403.     if (ret < 0) {
    404.         video_eof_reached = 1;
    405.         assert(ret == AVERROR_EOF);
    406.         ret = video_output_eof_packet("video_eof", input_fmt_ctx->streams[input_video_stream_idx], buffersrc_ctx);
    407.         assert (ret >= 0);
    408.         return ret;
    410.     }
    412.     if (pkt.stream_index != input_video_stream_idx) {
    413. //        av_free(&pkt);
    414.         return ret;
    415.     }
    417.     ret = avcodec_decode_video2(input_dec_ctx, mVideoFrame, &got_frame, &pkt);
    418.     if (ret < 0) {
    419.         printf("Error decoding input video\n");
    420.     }
    422.     if (got_frame) {
    423.         int64_t best_effort_timestamp = av_frame_get_best_effort_timestamp(mVideoFrame);
    424.             mVideoFrame->pts = best_effort_timestamp;
    426.         if (av_buffersrc_add_frame(buffersrc_ctx, mVideoFrame, AV_BUFFERSRC_FLAG_PUSH) < 0) {
    427.             av_log(NULL, AV_LOG_ERROR, "Error while feeding the video filtergraph\n");
    428.             return -1;
    429.         }
    430.         reap_filters();
    431.     }
    433.     return 0;
    435. }
    437. int overlay_transcode_step(AVFrame* mOverlayFrame) {
    438.     int ret = 0;
    439.     AVPacket pkt;
    441.     ret = av_read_frame(overlay_fmt_ctx, &pkt);
    442.     if (ret == AVERROR(EAGAIN)) {
    443.         return 0;
    444.     }
    446.     if (ret < 0) {
    447.         overlay_eof_reached = 1;
    448.         ret = video_output_eof_packet("overlay_eof", overlay_fmt_ctx->streams[input_video_stream_idx], bufferoverlay_ctx);
    449.         assert(ret >=0 );
    450.         return ret;
    451.     }
    453.     if (pkt.stream_index != overlay_video_stream_idx) {
    454.         av_free_packet(&pkt);
    455.         return ret;
    456.     }
    458.     ret = avcodec_decode_video2(overlay_dec_ctx, mOverlayFrame, &got_frame, &pkt);
    459.     if (ret < 0) {
    460.         printf("Error decoding overlay video\n");
    461.     }
    463.     if (got_frame) {
    464.         int64_t best_effort_timestamp = av_frame_get_best_effort_timestamp(mOverlayFrame);
    466.             mOverlayFrame->pts = best_effort_timestamp;
    468.         if (av_buffersrc_add_frame(bufferoverlay_ctx, mOverlayFrame, AV_BUFFERSRC_FLAG_PUSH) < 0) {
    469.             av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");
    470.             return -1;
    471.         }
    472.     }
    473.     return 0;
    475. }
    477. /**
    478. * output EOF packet to filter to flush
    479. */
    480. int video_output_eof_packet(const char* tag, 
    481.     AVStream* ist, AVFilterContext* ifilter)
    482. {
    483.     int ret = 0;
    485.     // alloc frame if NULL
    486.     AVFrame* decoded_frame = avcodec_alloc_frame();
    488.     AVPacket pkt;
    489.     av_init_packet(&pkt);
    490.     pkt.data = NULL;
    491.     pkt.size = 0;
    493.     int got_frame = 0;
    494.     ret = avcodec_decode_video2(ist->codec, decoded_frame, &got_frame, &pkt);
    495.     // EOF, assert got nothing and ret is 0.
    496.     // TODO: here we still got frame, different to ffmpeg.
    497.     assert(ret >= 0);
    499.     // flush filter
    500.     av_buffersrc_add_ref(ifilter, NULL, 0);
    502.     printf("[%s] filter -> eof packet.\n", tag);
    504.     return ret;
    505. }
    508. /** 
    509.  * save yuv420p frame [YUV] 
    510.  */  
    511. void yuv420p_save(AVFrame *pFrame)  
    512. {  
    513.     int i = 0;  
    515.     int width = pFrame->width, height = pFrame->height;  
    516.     int height_half = height / 2, width_half = width / 2;  
    517.     int y_wrap = pFrame->linesize[0];  
    518.     int u_wrap = pFrame->linesize[1];  
    519.     int v_wrap = pFrame->linesize[2];  
    521.     unsigned char *y_buf = pFrame->data[0];  
    522.     unsigned char *u_buf = pFrame->data[1];  
    523.     unsigned char *v_buf = pFrame->data[2];  
    525.     //save y  
    526.     for (i = 0; i < height; i++)  
    527.         fwrite(y_buf + i * y_wrap, 1, width, fp_yuv);  
    529.     //save u  
    530.     for (i = 0; i < height_half; i++)  
    531.         fwrite(u_buf + i * u_wrap, 1, width_half, fp_yuv);  
    533.     //save v  
    534.     for (i = 0; i < height_half; i++)  
    535.         fwrite(v_buf + i * v_wrap, 1, width_half, fp_yuv);  
    537.     fflush(fp_yuv);  
    538. }

    ffmpeg 代码实现视频添加水印功能 - 图1