• FFmpeg 视频添加水印

    1.简介

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

    2.流程

    2.1打开输入的文件

    首先打开输入的视频文件，查找到视频流索引，找到对应的视频解码器，拷贝一些重要的参数到解码器，最后打开解码器。

    1. 	//av_register_all();
    2. 	avformat_network_init();
    3.  
    4. 	///打开输入的流
    5. 	int ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL);
    6. 	if (ret != 0)
    7. 	{
    8. 		printf("Couldn't open input stream.\n");
    9. 		return -1;
    10. 	}
    11.  
    12. 	//查找流信息
    13. 	if (avformat_find_stream_info(fmt_ctx, NULL) < 0)
    14. 	{
    15. 		printf("Couldn't find stream information.\n");
    16. 		return -1;
    17. 	}
    18.  
    19. 	//找到视频流索引
    20. 	video_index = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    21.  
    22. 	AVStream* st = fmt_ctx->streams[video_index];
    23.  
    24. 	AVCodec* codec = nullptr;
    25.  
    26. 	//找到解码器
    27. 	codec = avcodec_find_decoder(st->codecpar->codec_id);
    28. 	if (!codec)
    29. 	{
    30. 		fprintf(stderr, "Codec not found\n");
    31. 		return -1;
    32. 	}
    33.  
    34. 	//申请AVCodecContext
    35. 	dec_ctx = avcodec_alloc_context3(codec);
    36. 	if (!dec_ctx)
    37. 	{
    38. 		return -1;
    39. 	}
    40.  
    41. 	avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[video_index]->codecpar);
    42.  
    43. 	//打开解码器
    44. 	if ((ret = avcodec_open2(dec_ctx, codec, NULL) < 0))
    45. 	{
    46. 		return -1;
    47. 	}
    48.  
    49. 	return 0;

    2.2初始化滤镜

    2.2.1获取滤镜处理的源

    获得滤镜处理的源及滤镜处理的sink滤镜，同时申请输入和输出的滤镜结构AVFilterInOut。

    1. 	const AVFilter* buffersrc = avfilter_get_by_name("buffer");
    2. 	const AVFilter* buffersink = avfilter_get_by_name("buffersink");
    3. 	AVFilterInOut* outputs = avfilter_inout_alloc();
    4. 	AVFilterInOut* inputs = avfilter_inout_alloc();

    2.2.2处理AVFilterGraph

    需要的AVFilter和AVFilterInOut申请完成之后，需要申请一个AVFilterGraph，用来存储Filter的in和out描述信息

    1.     AVFilterGraph* filter_graph = NULL;
    2. 	
    3.     filter_graph = avfilter_graph_alloc();
    4. 	if (!outputs || !inputs || !filter_graph)
    5. 	{
    6. 		ret = AVERROR(ENOMEM);
    7. 		return ret;
    8. 	}

    2.2.3创建AVFilterContext

    接下来创建一个AVFilterContext结构用来存储Filter的处理内容，包括input与output的Filter信息，在创建input信息时，需要加入原视频的相关信息，比如pix_fmt、time_base等。

    首先输入参数：

    1. 	char args[512];
    2.     snprintf(args, sizeof(args),
    3.         "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
    4. 		dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
    5. 		time_base.num, time_base.den,
    6. 		dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);

    然后创建AVFilterContext：

    1. 	AVFilterContext* buffersink_ctx = NULL;
    2.     AVFilterContext* buffersrc_ctx = NULL;
    3.  
    4.     ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
    5. 		args, NULL, filter_graph);
    6. 	if (ret < 0) 
    7. 	{
    8. 		av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
    9. 		return ret;
    10. 	}
    11.  
    12. 	/* buffer video sink: to terminate the filter chain. */
    13. 	ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
    14. 		NULL, NULL, filter_graph);
    15. 	if (ret < 0) 
    16. 	{
    17. 		av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
    18. 		return ret;
    19. 	}

    2.2.4设置其他参数

    创建完输入与输出的AVFilterContext之后，如果还需要设置一些其他与Filter相关的参数。可以通过使用av_opt_set_int_list进行设置，例如设置输出的pix_fmt参数。

    1. 	ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
    2. 		AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
    3. 	if (ret < 0) 
    4. 	{
    5. 		av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
    6. 		return ret;
    7. 	}

    2.2.5建立滤镜解析器

    参数设置完毕后，可以针对前面设置的Filter相关的内容建立滤镜解析器。

    1.     const char* filter_descr = "movie=logo.jpg[wm];[in][wm]overlay=5:5[out]";
    2.  
    3.     outputs->name = av_strdup("in");
    4. 	outputs->filter_ctx = buffersrc_ctx;
    5. 	outputs->pad_idx = 0;
    6. 	outputs->next = NULL;
    7.  
    8. 	inputs->name = av_strdup("out");
    9. 	inputs->filter_ctx = buffersink_ctx;
    10. 	inputs->pad_idx = 0;
    11. 	inputs->next = NULL;
    12.  
    13. 	if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
    14. 		&inputs, &outputs, NULL)) < 0)
    15. 	{
    16. 		return ret;
    17. 	}
    18.  
    19. 	if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
    20. 	{
    21. 		return ret;
    22. 	}

    2.3读取数据解码并获取到添加好水印的数据。

    1. 	while (av_read_frame(fmt_ctx, pkt) >= 0)
    2. 	{
    3. 		if (pkt->stream_index == video_index)
    4. 		{
    5. 			int ret = avcodec_send_packet(dec_ctx, pkt);
    6. 			if (ret >= 0)
    7. 			{
    8. 				ret = avcodec_receive_frame(dec_ctx, frame);
    9. 				if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    10. 				{
    11. 					continue;
    12. 				}
    13. 				else if (ret < 0)
    14. 				{
    15. 					continue;
    16. 				}
    17.  
    18. 				frame->pts = frame->best_effort_timestamp;
    19.  
    20. 				/* push the decoded frame into the filtergraph */
    21. 				if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) 
    22. 				{
    23. 					av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
    24. 					break;
    25. 				}
    26.  
    27. 				/* pull filtered frames from the filtergraph */
    28. 				while (1) 
    29. 				{
    30. 					ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
    31. 					if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    32. 						break;
    33. 					if (ret < 0)
    34. 						break;
    35.  
    36. 					switch (dec_ctx->pix_fmt)
    37. 					{
    38. 					case AV_PIX_FMT_YUV420P:
    39. 					{
    40.  
    41. 						int size = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, filt_frame->width, filt_frame->height, 1);
    42.  
    43. 						char fileName[20] = { 0 };
    44. 						sprintf(fileName, "img2/%d.yuv", dec_ctx->frame_number);
    45.  
    46. 						FILE* fp;
    47. 						fp = fopen(fileName, "wb");
    48.  
    49. 						for (int i = 0; i < filt_frame->height; i++) 
    50. 						{
    51. 							fwrite(filt_frame->data[0] + filt_frame->linesize[0] * i, 1, filt_frame->width, fp);
    52. 						}
    53. 						for (int i = 0; i < filt_frame->height / 2; i++) 
    54. 						{
    55. 							fwrite(filt_frame->data[1] + filt_frame->linesize[1] * i, 1, filt_frame->width / 2, fp);
    56. 						}
    57. 						for (int i = 0; i < filt_frame->height / 2; i++)
    58. 						{
    59. 							fwrite(filt_frame->data[2] + filt_frame->linesize[2] * i, 1, filt_frame->width / 2, fp);
    60. 						}
    61.  
    62. 						fclose(fp);
    63. 					}
    64. 					break;
    65. 					default:
    66. 						return -1;
    67. 					}
    68.  
    69. 					av_frame_unref(filt_frame);
    70. 					
    71. 				}
    72. 				av_frame_unref(frame);
    73. 			}
    74. 		}
    75. 	}

    3.效果

    logo图如下

     

    效果图如下，可以看见添加到了左上角。

     4.源码

    1. #include "pch.h"
    2. #include 
    3. #include 
    4.  
    5. extern "C"
    6. {
    7. #include "libavformat/avformat.h"
    8. #include "libavutil/dict.h"
    9. #include "libavutil/opt.h"
    10. #include "libavutil/timestamp.h"
    11. #include "libavutil/avutil.h"
    12. #include "libswscale/swscale.h"
    13. #include "libswresample/swresample.h"
    14. #include "libavutil/imgutils.h" 
    15. #include "libavfilter/avfilter.h"
    16. #include "libavfilter/buffersink.h"
    17. #include "libavfilter/buffersrc.h"
    18. };
    19.  
    20. static AVFormatContext* fmt_ctx = NULL;
    21. static AVCodecContext* dec_ctx = NULL;
    22. AVFilterContext* buffersink_ctx = NULL;
    23. AVFilterContext* buffersrc_ctx = NULL;
    24. AVFilterGraph* filter_graph = NULL;
    25.  
    26. int video_index = -1;
    27.  
    28. const char* filter_descr = "movie=logo.jpg[wm];[in][wm]overlay=5:5[out]";
    29. static int64_t last_pts = AV_NOPTS_VALUE;
    30.  
    31.  
    32. static int open_input_file(const char* filename)
    33. {
    34. 	//av_register_all();
    35. 	avformat_network_init();
    36.  
    37. 	///打开输入的流
    38. 	int ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL);
    39. 	if (ret != 0)
    40. 	{
    41. 		printf("Couldn't open input stream.\n");
    42. 		return -1;
    43. 	}
    44.  
    45. 	//查找流信息
    46. 	if (avformat_find_stream_info(fmt_ctx, NULL) < 0)
    47. 	{
    48. 		printf("Couldn't find stream information.\n");
    49. 		return -1;
    50. 	}
    51.  
    52. 	//找到视频流索引
    53. 	video_index = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    54.  
    55. 	AVStream* st = fmt_ctx->streams[video_index];
    56.  
    57. 	AVCodec* codec = nullptr;
    58.  
    59. 	//找到解码器
    60. 	codec = avcodec_find_decoder(st->codecpar->codec_id);
    61. 	if (!codec)
    62. 	{
    63. 		fprintf(stderr, "Codec not found\n");
    64. 		return -1;
    65. 	}
    66.  
    67. 	//申请AVCodecContext
    68. 	dec_ctx = avcodec_alloc_context3(codec);
    69. 	if (!dec_ctx)
    70. 	{
    71. 		return -1;
    72. 	}
    73.  
    74. 	avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[video_index]->codecpar);
    75.  
    76. 	//打开解码器
    77. 	if ((ret = avcodec_open2(dec_ctx, codec, NULL) < 0))
    78. 	{
    79. 		return -1;
    80. 	}
    81.  
    82. 	return 0;
    83. }
    84.  
    85. static int init_filters(const char* filters_descr)
    86. {
    87. 	char args[512];
    88. 	int ret = 0;
    89. 	const AVFilter* buffersrc = avfilter_get_by_name("buffer");
    90. 	const AVFilter* buffersink = avfilter_get_by_name("buffersink");
    91. 	AVFilterInOut* outputs = avfilter_inout_alloc();
    92. 	AVFilterInOut* inputs = avfilter_inout_alloc();
    93. 	AVRational time_base = fmt_ctx->streams[video_index]->time_base;
    94. 	enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
    95.  
    96. 	filter_graph = avfilter_graph_alloc();
    97. 	if (!outputs || !inputs || !filter_graph)
    98. 	{
    99. 		ret = AVERROR(ENOMEM);
    100. 		return ret;
    101. 	}
    102.  
    103. 	/* buffer video source: the decoded frames from the decoder will be inserted here. */
    104. 	snprintf(args, sizeof(args),
    105. 		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
    106. 		dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
    107. 		time_base.num, time_base.den,
    108. 		dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
    109.  
    110. 	ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
    111. 		args, NULL, filter_graph);
    112. 	if (ret < 0) 
    113. 	{
    114. 		av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
    115. 		return ret;
    116. 	}
    117.  
    118. 	/* buffer video sink: to terminate the filter chain. */
    119. 	ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
    120. 		NULL, NULL, filter_graph);
    121. 	if (ret < 0) 
    122. 	{
    123. 		av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
    124. 		return ret;
    125. 	}
    126.  
    127. 	ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,
    128. 		AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
    129. 	if (ret < 0) 
    130. 	{
    131. 		av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
    132. 		return ret;
    133. 	}
    134.  
    135. 	outputs->name = av_strdup("in");
    136. 	outputs->filter_ctx = buffersrc_ctx;
    137. 	outputs->pad_idx = 0;
    138. 	outputs->next = NULL;
    139.  
    140. 	inputs->name = av_strdup("out");
    141. 	inputs->filter_ctx = buffersink_ctx;
    142. 	inputs->pad_idx = 0;
    143. 	inputs->next = NULL;
    144.  
    145. 	if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
    146. 		&inputs, &outputs, NULL)) < 0)
    147. 	{
    148. 		return ret;
    149. 	}
    150.  
    151. 	if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
    152. 	{
    153. 		return ret;
    154. 	}
    155.  
    156. 	avfilter_inout_free(&inputs);
    157. 	avfilter_inout_free(&outputs);
    158.  
    159. 	return ret;
    160. }
    161.  
    162. int main()
    163. {
    164. ///1.打开文件
    165. 	const char* inputUrl = "test.mp4";
    166.  
    167. 	int ret = -1;
    168. 	if ((ret = open_input_file(inputUrl) < 0))
    169. 	{
    170. 		return -1;
    171. 	}
    172.  
    173. ///2.初始化滤镜
    174. 	if ((ret = init_filters(filter_descr)) < 0)
    175. 	{
    176. 		return -1;
    177. 	}
    178.  
    179. 	AVPacket* pkt = av_packet_alloc();
    180. 	//av_init_packet(pkt);
    181.  
    182. 	AVFrame* frame = av_frame_alloc();
    183. 	AVFrame *filt_frame = av_frame_alloc();
    184.  
    185. 	while (av_read_frame(fmt_ctx, pkt) >= 0)
    186. 	{
    187. 		if (pkt->stream_index == video_index)
    188. 		{
    189. 			int ret = avcodec_send_packet(dec_ctx, pkt);
    190. 			if (ret >= 0)
    191. 			{
    192. 				ret = avcodec_receive_frame(dec_ctx, frame);
    193. 				if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    194. 				{
    195. 					continue;
    196. 				}
    197. 				else if (ret < 0)
    198. 				{
    199. 					continue;
    200. 				}
    201.  
    202. 				frame->pts = frame->best_effort_timestamp;
    203.  
    204. 				/* push the decoded frame into the filtergraph */
    205. 				if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) 
    206. 				{
    207. 					av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
    208. 					break;
    209. 				}
    210.  
    211. 				/* pull filtered frames from the filtergraph */
    212. 				while (1) 
    213. 				{
    214. 					ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
    215. 					if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    216. 						break;
    217. 					if (ret < 0)
    218. 						break;
    219.  
    220. 					switch (dec_ctx->pix_fmt)
    221. 					{
    222. 					case AV_PIX_FMT_YUV420P:
    223. 					{
    224.  
    225. 						int size = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, filt_frame->width, filt_frame->height, 1);
    226.  
    227. 						char fileName[20] = { 0 };
    228. 						sprintf(fileName, "img2/%d.yuv", dec_ctx->frame_number);
    229.  
    230. 						FILE* fp;
    231. 						fp = fopen(fileName, "wb");
    232.  
    233. 						for (int i = 0; i < filt_frame->height; i++) 
    234. 						{
    235. 							fwrite(filt_frame->data[0] + filt_frame->linesize[0] * i, 1, filt_frame->width, fp);
    236. 						}
    237. 						for (int i = 0; i < filt_frame->height / 2; i++) 
    238. 						{
    239. 							fwrite(filt_frame->data[1] + filt_frame->linesize[1] * i, 1, filt_frame->width / 2, fp);
    240. 						}
    241. 						for (int i = 0; i < filt_frame->height / 2; i++)
    242. 						{
    243. 							fwrite(filt_frame->data[2] + filt_frame->linesize[2] * i, 1, filt_frame->width / 2, fp);
    244. 						}
    245.  
    246. 						fclose(fp);
    247. 					}
    248. 					break;
    249. 					default:
    250. 						return -1;
    251. 					}
    252.  
    253. 					av_frame_unref(filt_frame);
    254. 					
    255. 				}
    256. 				av_frame_unref(frame);
    257. 			}
    258. 		}
    259. 	}
    260.  
    261. 	avfilter_graph_free(&filter_graph);
    262. 	avcodec_close(dec_ctx);
    263. 	avcodec_free_context(&dec_ctx);
    264. 	avformat_close_input(&fmt_ctx);
    265. 	av_frame_free(&frame);
    266. 	av_frame_free(&filt_frame);
    267. 	av_packet_free(&pkt);
    268.  
    269. 	return 0;
    270. }
    271.

  • 相关阅读:
    JAVASE总结作业----网络编程
    python的多线程介绍之thread
    集火全屋智能“后装市场”，真正玩得转的没几个
    1、2快速生成
    Superset embed Dashboard到React App
    交换机和路由器技术-31-扩展ACL
    vue中axios的封装
    sdk文档书写，如何写具有可读性和可信度的文档
    人力资源APP功能
    【PCL自学：Segmentation3】基于PCL的点云分割：区域增长分割
  • 原文地址：https://blog.csdn.net/wzz953200463/article/details/125983491