ffmpeg录制视频时添加时间水印

IPcamera录制视频，经常用到时间戳水印。ffmpeg avfilter模块，可以实现水印的添加

• 设置filter

const char *filters_descr = "drawtext=fontfile=DFPGB_Y5.TTF:fontsize=20:fontcolor=white:box=0:boxcolor=black:shadowy=1:alpha=0.8:x=10:y=10:text='2010'";

字段	作用
drawtext	用于添加文字水印
fontfile	字体文件（中文需要支持utf-8）
fontsize	字体大小
fontcolor	字体颜色
box	是否需要添加填充框
boxcolor	填充框颜色
shadowy	阴影偏移
alpha	透明度
x,y	文字坐标
text	文字内容

• 实现

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/opt.h>

typedef struct
{
    
    
	int inited;
    AVFilterContext *filtersink_ctx;
    AVFilterContext *filtersrc_ctx;
    AVFilterGraph *filter_graph;

    AVFilterInOut *outputs;
    AVFilterInOut *inputs;

	AVFilterContext* filter_ctx;	//动态修改文字

	AVFrame *filt_frame;
} frame_filter_t;

const char *filters_descr = "drawtext=fontfile=DFPGB_Y5.TTF:fontsize=20:fontcolor=white:box=0:boxcolor=black:shadowy=1:alpha=0.8:x=10:y=10:text='2010'";

// 初始化filter
int filter_init(frame_filter_t *frame_filter,AVRational time_base1,AVCodecContext *dec_ctx,AVCodecContext *enc_ctx)
{
    
    
    char args[512];
    int ret = 0;
    int video_stream_index = 0;
    // AVFormatContext *fmt_ctx
    AVFilterContext *filtersink_ctx;
    AVFilterContext *filtersrc_ctx;
    AVFilterGraph *filter_graph;

    const AVFilter *buffersrc  = avfilter_get_by_name("buffer");
    const AVFilter *buffersink = avfilter_get_by_name("buffersink");
    AVFilterInOut *outputs = avfilter_inout_alloc();
    AVFilterInOut *inputs  = avfilter_inout_alloc();
    AVRational time_base = time_base1;//fmt_ctx->streams[video_stream_index]->time_base;
    enum AVPixelFormat pix_fmts[] = {
    
     AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE };//{ AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
    
    // 输出格式
    pix_fmts[0] = enc_ctx->pix_fmt;

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

    /* buffer video source: the decoded frames from the decoder will be inserted here. */
    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(&filtersrc_ctx, buffersrc, "in",
                                       args, NULL, filter_graph);
    if (ret < 0) {
    
    
        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
        goto end;
    }

    /* buffer video sink: to terminate the filter chain. */
    ret = avfilter_graph_create_filter(&filtersink_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(filtersink_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;
    }

    /*
     * Set the endpoints for the filter graph. The filter_graph will
     * be linked to the graph described by filters_descr.
     */

    /*
     * The buffer source output must be connected to the input pad of
     * the first filter described by filters_descr; since the first
     * filter input label is not specified, it is set to "in" by
     * default.
     */
    outputs->name       = av_strdup("in");
    outputs->filter_ctx = filtersrc_ctx;
    outputs->pad_idx    = 0;
    outputs->next       = NULL;

    /*
     * The buffer sink input must be connected to the output pad of
     * the last filter described by filters_descr; since the last
     * filter output label is not specified, it is set to "out" by
     * default.
     */
    inputs->name       = av_strdup("out");
    inputs->filter_ctx = filtersink_ctx;
    inputs->pad_idx    = 0;
    inputs->next       = NULL;

    if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
                                    &inputs, &outputs, NULL)) < 0){
    
    
        fprintf(stderr, "[%s](%d) ----\n",__func__,__LINE__);
        goto end;
    }
        

    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
        goto end;


    // 找到text字段，用来动态修改
    int Parsed_drawtext_0_index = -1;
    for (int i = 0; i < filter_graph->nb_filters; i++)
    {
    
    
        AVFilterContext* filter_ctxn = filter_graph->filters[i];

        fprintf(stdout, "[%s](%d) filter_ctxn->name=%s\n",__func__,__LINE__,filter_ctxn->name);

        if(!strcmp(filter_ctxn->name,"Parsed_drawtext_0"))
            Parsed_drawtext_0_index = i;
    }
    if(Parsed_drawtext_0_index == -1)
        fprintf(stderr, "[%s](%d) no Parsed_drawtext_0\n",__func__,__LINE__);

    frame_filter->filter_ctx = filter_graph->filters[Parsed_drawtext_0_index];

    frame_filter->filtersink_ctx = filtersink_ctx;
    frame_filter->filtersrc_ctx = filtersrc_ctx;
    frame_filter->filter_graph = filter_graph;
    frame_filter->inputs = inputs;
    frame_filter->outputs = outputs;

    frame_filter->filt_frame = av_frame_alloc();
    frame_filter->inited = 1;

    fprintf(stdout, "[%s](%d) init done!\n",__func__,__LINE__);
    return 0;
end:
    // avfilter_inout_free(&inputs);
    // avfilter_inout_free(&outputs);
    return ret;
}

// 动态修改水印内容
int set_filter_text(frame_filter_t *frame_filter,char *text)
{
    
    
    int ret=0;

    AVFilterContext* filter_ctx1 = frame_filter->filter_ctx;
    fprintf(stdout, "[%s](%d) text:%s\n",__func__,__LINE__,text);

    ret = av_opt_set(filter_ctx1->priv, "text", text, 0 );
    if(ret < 0)
        goto __end;
        
    return 0;
__end:
    
    return -1;
}
// 对一帧数据添加水印
int do_filter(frame_filter_t *frame_filter,AVFrame *framesrc,AVFrame *framedst)
{
    
    
    int ret=0;
    AVFilterContext *filtersink_ctx = frame_filter->filtersink_ctx;
    AVFilterContext *filtersrc_ctx = frame_filter->filtersrc_ctx;

    AVFrame *filt_frame = frame_filter->filt_frame;
    /* push the decoded frame into the filtergraph */
    if (av_buffersrc_add_frame_flags(filtersrc_ctx, framesrc, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
    
    
        av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
        return -1;
    }

    /* pull filtered frames from the filtergraph */
    while (1) {
    
    
        ret = av_buffersink_get_frame(filtersink_ctx, filt_frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        if (ret < 0)
            goto __end;

        // TODO:
        // framedst = av_frame_clone(filt_frame);
        av_frame_move_ref(framedst,filt_frame);

        av_frame_unref(filt_frame);
    }

__end:
    return ret;
}

void filter_free(frame_filter_t *frame_filter)
{
    
    
    avfilter_graph_free(&frame_filter->filter_graph);
    avfilter_inout_free(&frame_filter->inputs);
    avfilter_inout_free(&frame_filter->outputs);

    av_frame_free(&frame_filter->filt_frame);
    // av_frame_free(&frame);
    // av_frame_free(&filt_frame);
}

• 动态设置时间水印

 // 设置水印
    char sys_time[64];
    time_t ltime;
    time(&ltime);
	struct tm* today = localtime(&ltime);
	// 2020-11-22 日 06:33:15
    strftime(sys_time, sizeof(sys_time), "%Y-%m-%d 周%a %H:%M:%S", today);       //24小时制
    set_filter_text(&frame_filter,sys_time);

• 效果
  

---