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

最新推荐文章于 2024-07-14 08:10:57 发布
最新推荐文章于 2024-07-14 08:10:57 发布
阅读量2.5w 收藏 16
点赞数 1
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingdam578/article/details/40747617
版权

备忘:

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


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


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

#include <unistd.h>
#include <stdio.h>
#include <assert.h>

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavfilter/avfiltergraph.h>
#include <libavfilter/avcodec.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libswscale/swscale.h>

const char *filter_descr = "overlay=5:5"; 

#define ENABLE_YUV_FILE 1

AVFormatContext *input_fmt_ctx;
AVCodecContext *input_dec_ctx;

AVFormatContext *overlay_fmt_ctx;
AVCodecContext *overlay_dec_ctx;

int input_video_stream_idx, overlay_video_stream_idx;

AVFilterGraph *filter_graph;

AVFilterInOut *inputs;
AVFilterInOut *outputs;

AVFilterContext *buffersrc_ctx;
AVFilterContext *bufferoverlay_ctx;
AVFilterContext *buffersink_ctx;

int ret;
int got_frame;

int video_eof_reached = 0;
int overlay_eof_reached = 0;

int active_stream_index = -1;

FILE* fp_yuv;

void yuv420p_save(AVFrame *pFrame);
int video_transcode_step(AVFrame* mVideoFrame);
int overlay_transcode_step(AVFrame* mOverlayFrame);
int video_output_eof_packet(const char* tag, 
	AVStream* ist, AVFilterContext* ifilter);

static int open_input_file(const char *filename)
{
    int ret;
    AVCodec *dec;

    if ((ret = avformat_open_input(&input_fmt_ctx, filename, NULL, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
        return ret;
    }

    if ((ret = avformat_find_stream_info(input_fmt_ctx, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
        return ret;
    }

    /* select the video stream */
    ret = av_find_best_stream(input_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");
        return ret;
    }
    input_video_stream_idx = ret;
    input_dec_ctx = input_fmt_ctx->streams[input_video_stream_idx]->codec;

    /* init the video decoder */
    if ((ret = avcodec_open2(input_dec_ctx, dec, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");
        return ret;
    }

    return 0;
}


static int open_overlay_file(const char *filename)
{
    int ret;
    AVCodec *dec;

    if ((ret = avformat_open_input(&overlay_fmt_ctx, filename, NULL, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
        return ret;
    }

    if ((ret = avformat_find_stream_info(overlay_fmt_ctx, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
        return ret;
    }

    /* select the video stream */
    ret = av_find_best_stream(overlay_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");
        return ret;
    }
    overlay_video_stream_idx = ret;
    overlay_dec_ctx = overlay_fmt_ctx->streams[overlay_video_stream_idx]->codec;

    /* init the video decoder */
    if ((ret = avcodec_open2(overlay_dec_ctx, dec, NULL)) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");
        return ret;
    }

    printf("overlay format = %s\n", overlay_fmt_ctx->iformat->name);

    return 0;
}


static int video_config_input_filter(AVFilterInOut* inputs, AVFilterContext** input_filter_ctx)
{
	char args[512];
	memset(args, 0, sizeof(args));

	AVFilterContext *first_filter = inputs->filter_ctx;
	int pad_idx = inputs->pad_idx;

	AVFilter *filter = avfilter_get_by_name("buffer");
//	AVRational time_base = input_dec_ctx->time_base;
	AVStream* video_st = input_fmt_ctx->streams[input_video_stream_idx];
	AVRational time_base = video_st->time_base;

	snprintf(args, sizeof(args),
            "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d:sws_param=flags=%d:frame_rate=%d/%d",
            input_dec_ctx->width, input_dec_ctx->height, input_dec_ctx->pix_fmt,
            input_dec_ctx->time_base.num, input_dec_ctx->time_base.den,
            input_dec_ctx->sample_aspect_ratio.num, input_dec_ctx->sample_aspect_ratio.den,
	    SWS_BILINEAR + ((video_st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0),
	    video_st->r_frame_rate.num, video_st->r_frame_rate.den);

       printf("input args = %s\n", args);

	ret = avfilter_graph_create_filter(input_filter_ctx, filter, "src_in", args, NULL, filter_graph);

	if (ret < 0 ) {
		printf("video config input filter fail.\n");
		return -1;
	}
	ret = avfilter_link(*input_filter_ctx, 0, first_filter, pad_idx);
	assert(ret >= 0);

	printf("video_config_input_filter avfilter_link ret = %d\n", ret);

	return ret;

}

static int video_config_overlay_filter(AVFilterInOut* inputs, AVFilterContext** overlay_filter_ctx )
{
	char args[512];
	memset(args, 0, sizeof(args));

	AVFilterContext *first_filter = inputs->filter_ctx;

	int pad_idx = inputs->pad_idx;

	AVFilter *filter = avfilter_get_by_name("buffer");

	//AVRational time_base = overlay_dec_ctx->time_base;
	AVStream* overlay_st = overlay_fmt_ctx->streams[overlay_video_stream_idx];
	AVRational time_base = overlay_st->time_base;

	snprintf(args, sizeof(args),
            "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d:sws_param=flags=%d:frame_rate=%d/%d",
            overlay_dec_ctx->width, overlay_dec_ctx->height, overlay_dec_ctx->pix_fmt,
            time_base.num, time_base.den,
	    overlay_dec_ctx->sample_aspect_ratio.num, overlay_dec_ctx->sample_aspect_ratio.den,
	    SWS_BILINEAR + ((overlay_st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0),
            overlay_st->r_frame_rate.num, overlay_st->r_frame_rate.den);

       printf("overlay args = %s\n", args);

	ret = avfilter_graph_create_filter(overlay_filter_ctx, filter, "overlay_in", args, NULL, filter_graph);

	if (ret < 0 ) {
		printf("video config overlay filter fail.\n");
		return -1;
	}

	ret = avfilter_link(*overlay_filter_ctx, 0, first_filter, pad_idx);
	assert(ret >= 0);

	printf("video_config_overlay_filter ret = %d\n", ret);

	avfilter_inout_free(&inputs);

	return ret;

}

static int video_config_output_filter(AVFilterInOut* outputs, AVFilterContext** out_filter_ctx)
{
	char args[512];

	AVFilterContext *last_filter = outputs->filter_ctx;
	int pad_idx  = outputs->pad_idx;
	AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");
	
	int ret = avfilter_graph_create_filter(out_filter_ctx, buffersink, "video_out", NULL, NULL, filter_graph);
	assert(ret >= 0);

	if (ret < 0)
		return ret;

	ret = avfilter_link(last_filter, pad_idx, *out_filter_ctx, 0);
	assert(ret >= 0);
	if (ret < 0)
		return ret;

	avfilter_inout_free(&outputs);

	return 0;

}

static int init_input_filters()
{
	filter_graph->scale_sws_opts = av_strdup("flags=0x4");
        av_opt_set(filter_graph, "aresample_swr_opts", "", 0);

	ret = avfilter_graph_parse2(filter_graph, filter_descr, &inputs, &outputs);

	assert(inputs && inputs->next && !inputs->next->next);	

	ret = video_config_input_filter(inputs, &buffersrc_ctx);

	ret = video_config_overlay_filter(inputs->next, &bufferoverlay_ctx);

	return ret;
}

static int init_output_filters()
{
	return video_config_output_filter(outputs, &buffersink_ctx);
}

int reap_filters() {
	AVFilterBufferRef *picref;

	while (1) {
		ret = av_buffersink_get_buffer_ref(buffersink_ctx, &picref, AV_BUFFERSINK_FLAG_NO_REQUEST);
		if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
			//printf("reap_filters fail ret = %d\n", ret);
			return 0; // no frame filtered.
		}	

		printf("samplesref -------------------\n");

		AVFrame* filtered_frame = avcodec_alloc_frame();
		avcodec_get_frame_defaults(filtered_frame);

		avfilter_copy_buf_props(filtered_frame, picref);
	
		yuv420p_save(filtered_frame);
	
		avfilter_unref_bufferp(&picref);
	}

}

int transcode_from_filter(AVFilterContext** ifilters, int* eof_reached_arr, int* active_stream_indext) {
	int ret = 0;

	ret = avfilter_graph_request_oldest(filter_graph);

	if (ret >= 0) {
		return ret;
        }
	if (ret == AVERROR_EOF) {
		return ret;
	}
	if (ret != AVERROR(EAGAIN)) {
		return ret;
	}

	int nb_requests_max = 0;
	int i;
	for (i = 0; i < 2; i++) {
		int eof_reached = eof_reached_arr[i];
		if (eof_reached) {
			continue;
		}
		AVFilterContext* ifilter = ifilters[i];
		int nb_requests = av_buffersrc_get_nb_failed_requests(ifilter);
		if (nb_requests > nb_requests_max) {
		    nb_requests_max = nb_requests;
		    *active_stream_indext = i;
		}
	}

	return ret;

}


int main()
{
	avcodec_register_all();
	av_register_all();
	avfilter_register_all();
	avformat_network_init();


	char* video_file = "outFileSrc.mp4";
	char* overlay_video_file = "my_logo.png"; // light1.mp4 


#if ENABLE_YUV_FILE
	const char* yuvFile = "outWater.yuv";
	
	fp_yuv = fopen(yuvFile, "wb");

#endif

	open_input_file(video_file);
	open_overlay_file(overlay_video_file);

	filter_graph = avfilter_graph_alloc();
	if (!filter_graph) {
		printf("filter graph alloc fail.\n");
		return -1;
	}
	
	init_input_filters();
	init_output_filters();	

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

	AVFrame* mVideoFrame = avcodec_alloc_frame();
	AVFrame* mOverlayFrame = avcodec_alloc_frame();

	while(1) {
		if (video_eof_reached && overlay_eof_reached) {
	            printf("stream EOF.\n");
		    break;
		}

		AVFilterContext* ifilters[] = {buffersrc_ctx, bufferoverlay_ctx};
		int eof_reacheds[] = {video_eof_reached, overlay_eof_reached};

		ret = transcode_from_filter(ifilters, eof_reacheds, &active_stream_index);

		if (ret >= 0) {
			ret = reap_filters();
			assert(ret >= 0);
			continue;
	        }
		if (ret == AVERROR_EOF) {
			ret = reap_filters();
			assert(ret >= 0);
			continue;
		}

		if (ret == AVERROR(EAGAIN) && active_stream_index < 0) {
			continue;
		}
		assert(active_stream_index >= 0);

		printf("active_stream_index = %d\n", active_stream_index);

		if (active_stream_index == 0) {
			video_transcode_step(mVideoFrame);
			continue;
		}

		overlay_transcode_step(mOverlayFrame);
		
	}

	if (input_dec_ctx)
		avcodec_close(input_dec_ctx);
	avformat_close_input(&input_fmt_ctx);

	if (overlay_dec_ctx)
		avcodec_close(overlay_dec_ctx);
	avformat_close_input(&overlay_fmt_ctx);



	printf("my_filtering_video3 end -------\n");
	return 0;
}

int video_transcode_step(AVFrame* mVideoFrame) {
	int ret = 0;
	AVPacket pkt;

	ret = av_read_frame(input_fmt_ctx, &pkt);
	if (ret == AVERROR(EAGAIN)) {
		return 0;
	}
	if (ret < 0) {
		video_eof_reached = 1;
		assert(ret == AVERROR_EOF);
		ret = video_output_eof_packet("video_eof", input_fmt_ctx->streams[input_video_stream_idx], buffersrc_ctx);
		assert (ret >= 0);
		return ret;

	}

	if (pkt.stream_index != input_video_stream_idx) {
//		av_free(&pkt);
		return ret;
	}

	ret = avcodec_decode_video2(input_dec_ctx, mVideoFrame, &got_frame, &pkt);
	if (ret < 0) {
		printf("Error decoding input video\n");
	}

	if (got_frame) {
		int64_t best_effort_timestamp = av_frame_get_best_effort_timestamp(mVideoFrame);
	    	mVideoFrame->pts = best_effort_timestamp;

		if (av_buffersrc_add_frame(buffersrc_ctx, mVideoFrame, AV_BUFFERSRC_FLAG_PUSH) < 0) {
			av_log(NULL, AV_LOG_ERROR, "Error while feeding the video filtergraph\n");
			return -1;
		}
		reap_filters();
	}
	
	return 0;

}

int overlay_transcode_step(AVFrame* mOverlayFrame) {
	int ret = 0;
	AVPacket pkt;

	ret = av_read_frame(overlay_fmt_ctx, &pkt);
	if (ret == AVERROR(EAGAIN)) {
		return 0;
	}

	if (ret < 0) {
		overlay_eof_reached = 1;
		ret = video_output_eof_packet("overlay_eof", overlay_fmt_ctx->streams[input_video_stream_idx], bufferoverlay_ctx);
		assert(ret >=0 );
		return ret;
	}

	if (pkt.stream_index != overlay_video_stream_idx) {
		av_free_packet(&pkt);
		return ret;
	}

	ret = avcodec_decode_video2(overlay_dec_ctx, mOverlayFrame, &got_frame, &pkt);
	if (ret < 0) {
		printf("Error decoding overlay video\n");
	}

	if (got_frame) {
		int64_t best_effort_timestamp = av_frame_get_best_effort_timestamp(mOverlayFrame);

	    	mOverlayFrame->pts = best_effort_timestamp;

		if (av_buffersrc_add_frame(bufferoverlay_ctx, mOverlayFrame, AV_BUFFERSRC_FLAG_PUSH) < 0) {
			av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");
			return -1;
		}
	}
	return 0;

}

/**
* output EOF packet to filter to flush
*/
int video_output_eof_packet(const char* tag, 
	AVStream* ist, AVFilterContext* ifilter)
{
    int ret = 0;
    
    // alloc frame if NULL
    AVFrame* decoded_frame = avcodec_alloc_frame();
    
    AVPacket pkt;
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
    
    int got_frame = 0;
    ret = avcodec_decode_video2(ist->codec, decoded_frame, &got_frame, &pkt);
    // EOF, assert got nothing and ret is 0.
    // TODO: here we still got frame, different to ffmpeg.
    assert(ret >= 0);
    
    // flush filter
    av_buffersrc_add_ref(ifilter, NULL, 0);
    
    printf("[%s] filter -> eof packet.\n", tag);
    
    return ret;
}


/** 
 * save yuv420p frame [YUV] 
 */  
void yuv420p_save(AVFrame *pFrame)  
{  
    int i = 0;  
  
    int width = pFrame->width, height = pFrame->height;  
    int height_half = height / 2, width_half = width / 2;  
    int y_wrap = pFrame->linesize[0];  
    int u_wrap = pFrame->linesize[1];  
    int v_wrap = pFrame->linesize[2];  
  
    unsigned char *y_buf = pFrame->data[0];  
    unsigned char *u_buf = pFrame->data[1];  
    unsigned char *v_buf = pFrame->data[2];  
  
    //save y  
    for (i = 0; i < height; i++)  
        fwrite(y_buf + i * y_wrap, 1, width, fp_yuv);  

    //save u  
    for (i = 0; i < height_half; i++)  
        fwrite(u_buf + i * u_wrap, 1, width_half, fp_yuv);  

    //save v  
    for (i = 0; i < height_half; i++)  
        fwrite(v_buf + i * v_wrap, 1, width_half, fp_yuv);  
  
    fflush(fp_yuv);  
}

PS: 用到avfilter的 ，如果有两个输入 ，不管音频还是视频， 代码基本都是这样 (如 视频的overlay   音频的amix 等等) 



 


                

        

        

    




    

      

        

            

              
                
                  kingdam578
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    16
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  4
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java使用ffmpeg完成视频加水印功能

				
			

			

				

					weixin_43959459的博客
				

				

					02-16
					
					6016
					
				

			

		

		

			
				
实际业务需求：在存储视频文件时先对上传的文件做加水印处理，之前做过通过七牛云服务器加水印的功能，虽然可以完成需求，但是毕竟是收费的呀！

现将ffmpeg加水印的代码献上。紧供参考，希望能帮到你。。。。如下：



   //加水印的请求方法：
   private String toAddLogoVideo() {       
        //本地视频-----待加水印的视频
        String videoLocalPath = "D:\\sjb\processing\\video\\12

			
		

	



                

              
                



	

		

			

				
					
Android studio3.1.3 FFmpeg编译和使用命令给视频添加水印

				
			

			

				

					irainsa的博客
				

				

					02-20
					
					597
					
				

			

		

		

			
				
本人第一次写文章，因为对于一个刚接触ffmpeg的人来说编译SO和在Android studio上编译中遇到了很多坑，所以身心体会了里面的很多坑，所以写这篇文章，希望对大家有用本文中又多个库和单个库的编译，大家可以自由选择首先编译FFmpeg推荐装个虚拟机然后用Ubuntu来编译首先去FFmpeg官网去下载4.0版的，然后在Android官网下载NDK建议使用r14版本，高的版本会出现问题。

			
		

	



                


  
              

                


	

		

			

				
					
音视频开发36-3 FFmpeg 编码- Filter 过滤器 ③ ( 文字水印 - drawtext 过滤器 | drawtext 过滤器支持库编译配置 | drawtext 过滤器

					
最新发布

				
			

			

				

					hunandede的博客
				

				

					07-14
					
					634
					
				

			

		

		

			
				
drawtext 过滤器 是 FFmpeg 中的一个 视频过滤器 , 用于 在 视频画面帧 上绘制文本 , 也就是添加文字水印 , 也可用于添加 标题 , 字幕 等元素;文字水印属性 : drawtext 过滤器 可以 在 视频画面 的任何位置添加任何文字内容 , 并可以 自定义文字的字体 / 大小 / 颜色 / 位置 等属性;动态时间戳显示 : drawtext 过滤器 可以 使用 时间戳 显示 动态变化 的时间信息 , 如 : 在视频上显示从 视频开始 到 当前时间 的经过时间;

			
		

	





	

		

			

				
					
FFmpeg 视频添加水印

				
			

			

				

					希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
				

				

					07-25
					
					4633
					
				

			

		

		

			
				
本示例，在视频中添加一个logo图片，把添加水印好的图片保存到本地。

			
		

	



		

			
		



	

		

			

				
					
ffmpeg 添加水印

				
			

			

				

					liuxunfei15的博客
				

				

					12-23
					
					5592
					
				

			

		

		

			
				
ffmpeg中文水印乱码两种原因

1.字符编码格式原因，中文必须是utf8编码格式的（我遇到的问题，在vs2013上写的中文，已做编码格式转码，放到centos7.2上编译运行也会出现中文乱码的问题，在Linux上把中文水印重新输入一遍就OK了）

2.字体文件fontfile原因,最好去C:\Windows\Fonts目录下去找，比如说宋体，黑体这些是不会乱码的



1.ffmpeg命令添加视频水印

ffmpeg –i input.flv -acodec copy-vcodec copy -vf "

			
		

	





	

		

			

				
					
【FFMpeg视频开发与应用基础】七、 调用FFMpeg SDK实现视频水印

				
			

			

				

					Workshop of Wenjie.Yin
				

				

					06-10
					
					6835
					
				

			

		

		

			
				
《FFMpeg视频开发与应用基础——使用FFMpeg工具与SDK》视频教程已经在“CSDN学院”上线，视频中包含了从0开始逐行代码实现FFMpeg视频开发的过程，欢迎观看！链接地址：FFMpeg视频开发与应用基础——使用FFMpeg工具与SDKGithub工程代码地址：FFmpeg_Tutorial视频的水印通常指附加在原始视频上的可见或者不可见的，与原始视频无直接关联的标识。通常在有线电视画面上电

			
		

	





	

		

			

				
					
ffmpeg加水印

				
			

			

				

					极客神殿
				

				

					10-31
					
					2047
					
				

			

		

		

			
				
一、ffmpeg加水印命令，主要从直播和视频文件加水印
1）直播推流加水印示例
ffmpeg -i rtmp://localhost/live/name  -vf "movie=/path/2.png [watermark]; [in][watermark] overlay=10:10 [out]" -c:v libx264 -c:a copy -f flv rtmp://locahost:193...

			
		

	





	

		

			

				
					
android利用FFmpeg为视频加水印

				
			

			

				

					01-11
				

			

		

		

			
				
之前有人反馈之前上传的下载不了，我再次上传一次，如果有问题及时给我发邮件，或者可以关注一下我，给我发私信，咱们互相学习！（android端代码，FFmpeg实现为视频加水印, 邮箱：1213236113@qq.com）

			
		

	





	

		

			

				
					
java调用ffmpeg 添加水印转换视频

				
			

			

				

					12-31
				

			

		

		

			
				
java调用ffmpeg添加水印并且转换视频,代码中并没有判断哪些格式支持,那些不支持,mpg,mp4,avi,wmv基本都可以(传入格式)，转换为flv avi mp4起码都没问题，其它的没事过ffmpeg是开源的支持的挺多的 补充：时间算错了，...

			
		

	





	

		

			

				
					
ffmpeg 视频添加水印 logo

				
			

			

				

					03-24
				

			

		

		

			
				
NULL 博文链接：https://tompig.iteye.com/blog/1107765

			
		

	





	

		

			

				
					
ffmpeg添加水印

				
			

			

				

					02-24
				

			

		

		

			
				
FFmpeg是一款强大的开源...总的来说，使用FFmpeg添加水印涉及到对FFmpeg命令行的熟练掌握，理解滤镜功能，以及在出现问题时进行有效的故障排除。通过学习和实践，你将能够自如地运用这一工具，提升视频处理的专业性。

			
		

	





	

		

			

				
					
ffmpeg中添加水印的讲解

				
			

			

				

					03-10
				

			

		

		

			
				
个人关于ffmpeg中添加水印的命令以及详细说明

			
		

	





	

		

			

				
					
用fffmpeg实现视频转flv时加水印

				
			

			

				

					03-01
				

			

		

		

			
				

博文链接：https://xiaoshuolang.iteye.com/blog/243489

			
		

	





	

		

			

				
					
基于ffmpeg对摄像头采集的视频加上时间戳水印

				
			

			

				

					07-13
				

			

		

		

			
				
在这个项目中，我们使用FFmpeg对通过摄像头采集的视频进行处理，添加时间戳作为水印。时间戳水印是视频编辑中常见的一种方式，它可以记录视频的实时录制时间，增加视频的可信度。  首先，我们需要了解FFmpeg如何调用...

			
		

	





	

		

			

				
					
使用ffmpeg命令行操作_之添加水印

				
			

			

				

					Stephen8848的博客
				

				

					04-27
					
					2305
					
				

			

		

		

			
				
FFMPEG命令行操作_添加水印
下载ffmpeg和配置环境变量

在ffmpeg官网下载最新的relese包

解压并将bin路径添加到系统环境变量

使用命令行测试是否成功
$ ffmpeg.exe -version


返回版本信息即表示系统环境变量已生效，
可进行ffmpeg命令行的使用了
使用ffmpeg命令行给视频添加水印

先将下列材料准备好

初始视频源
水印图片


我本地的视频源是：realshort.mp4

水印图片是：tree_s.png

$ ffmpeg.exe -i real

			
		

	





	

		

			

				
					
代码中使用ffmpeg命令行给图片添加水印

				
			

			

				

					bigfanofloT的博客
				

				

					09-25
					
					320
					
				

			

		

		

			
				
【代码】代码中使用ffmpeg命令行给图片添加水印。

			
		

	





	

		

			

				
					
【FFmpeg】命令行转码时加水印

				
			

			

				

					突围
				

				

					02-10
					
					740
					
				

			

		

		

			
				
Fontconfig error: Cannot load default config file
俩vf


  libpostproc    55.  9.100 / 55.  9.100
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '30_bbb_sunflower_1080p_30fps_normal.mp4
                                                                           ...

			
		

	





	

		

			

				
					
ffmpeg 命令行 转码 添加水印 调节透明度

				
			

			

				

					c553110519的专栏
				

				

					05-24
					
					1242
					
				

			

		

		

			
				
公司项目需求是，一个视频，需要转码成不同比例的视频，并且添加一个水印，这个水印透明度可调节，本来想用公司渲染引擎，考虑需要gpu环境的服务器，成本比较高，后来想了下使用ffmpeg命令行也能完成这些事情。导出视频1920*1080，如果收入视频比例不一致，把它fidin到1920*1080，多的地方黑色背景填充，lut=a=val*0.5, 0.5是水印的透明度，也就是半透明。input.mp4 输入视频比例可以任意。logo.png 水印文件。overlay 添加水印。

			
		

	





	

		

			

				
					
ffmpeg 合并视频添加时间水印

				
			

			

				

					萧云城主の博客
				

				

					06-04
					
					472
					
				

			

		

		

			
				
时间总长度，根据input的视频长度来计算合并的次数，此次是5次。比如此次input视频长度是7秒，循环了5次合并，则输出是35秒的视频输出。功能: 重复合并输入的视频5次，并且添加时间戳，添加自定义文字。时间初始值: 2023-12-12 00:000:00。for i in {1:5} 中 5 是次数可修改此值。把代码文本内容 复制到 generate.sh。input 是输入的视频路径。output是输出的视频路径。fontfile :字体。

			
		

	





	

		

			

				
					
Ffmpeg 如何为视频加水印，c++纯代码实现

				
			

			

				

					03-02
				

			

		

		

			
				
Ffmpeg是一个功能强大的视频处理工具，可以通过在视频中添加水印来保护视频内容的版权，以下是使用C语言实现在视频中添加水印的步骤：

1.打开视频文件
```c
AVFormatContext *fmt_ctx = avformat_alloc_context();
if(avformat_open_input(&fmt_ctx, "input.mp4", NULL, NULL) < 0) {
    printf("无法打开输入文件\n");
    exit(1);
}
```
2.查找视频流
```c
if(avformat_find_stream_info(fmt_ctx, NULL) < 0) {
    printf("无法查找视频流信息\n");
    exit(1);
}
int video_index = -1;
for(int i=0; i<fmt_ctx->nb_streams; i++) {
    if(fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
        video_index = i;
        break;
    }
}
if(video_index == -1) {
    printf("无法找到视频流\n");
    exit(1);
}
AVCodecParameters *codec_par = fmt_ctx->streams[video_index]->codecpar;
```
3.打开视频解码器
```c
AVCodec *codec = avcodec_find_decoder(codec_par->codec_id);
if(codec == NULL) {
    printf("无法找到解码器\n");
    exit(1);
}
AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
if(avcodec_parameters_to_context(codec_ctx, codec_par) < 0) {
    printf("无法将解码器参数转换为上下文\n");
    exit(1);
}
if(avcodec_open2(codec_ctx, codec, NULL) < 0) {
    printf("无法打开解码器\n");
    exit(1);
}
```
4.创建输出文件
```c
AVFormatContext *out_fmt_ctx = NULL;
if(avformat_alloc_output_context2(&out_fmt_ctx, NULL, NULL, "output.mp4") < 0) {
    printf("无法创建输出文件\n");
    exit(1);
}
AVStream *out_stream = avformat_new_stream(out_fmt_ctx, codec);
if(out_stream == NULL) {
    printf("无法创建输出流\n");
    exit(1);
}
if(avcodec_parameters_copy(out_stream->codecpar, codec_par) < 0) {
    printf("无法复制编解码器参数\n");
    exit(1);
}
if(avio_open(&out_fmt_ctx->pb, "output.mp4", AVIO_FLAG_WRITE) < 0) {
    printf("无法打开输出文件\n");
    exit(1);
}
if(avformat_write_header(out_fmt_ctx, NULL) < 0) {
    printf("无法写入输出文件头\n");
    exit(1);
}
```
5.创建水印
```c
AVFilterContext *buffersrc_ctx;
AVFilterContext *buffersink_ctx;
AVFilterGraph *filter_graph;
const char *filter_descr = "movie=watermark.png[watermark];[in][watermark]overlay=x=100:y=100[out]";
avfilter_register_all();
AVFilter *buffersrc = avfilter_get_by_name("buffer");
AVFilter *buffersink = avfilter_get_by_name("buffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 4

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值