devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ 使用ffmpeg播放音视频文件_c++ ffmpeg 播放视频

作者：weixin_40725706 | 2024-04-03 03:06:34

赞

踩

c++ ffmpeg 播放视频

 1、包含必须的头文件。

  1. #include <iostream>
  2. extern "C" {
  3. #include <libavformat/avformat.h>
  4. #include <libswresample/swresample.h>
  5. #include <libavutil/opt.h>
  6. #include <libavutil/audio_fifo.h>
  7. #include <libavutil/frame.h>
  8. }
  9.  
  10. // SDL相关头文件
  11. #include <SDL2/SDL.h>
  12. #include <SDL2/SDL_audio.h>

2、示例。

  1. #define AUDIO_BUFFER_SIZE 4096
  2.  
  3. typedef struct {
  4. 	uint8_t* buffer;
  5. 	int size;
  6. 	int pos;
  7. } AudioParams;
  8.  
  9. void audio_callback(void* userdata, Uint8* stream, int len) {
  10. 	AudioParams* audioParams = (AudioParams*)userdata;
  11. 	if (audioParams->pos >= audioParams->size) {
  12. 		return;
  13. 	}
  14. 	int remaining = audioParams->size - audioParams->pos;
  15. 	len = (len > remaining) ? remaining : len;
  16. 	memcpy(stream, audioParams->buffer + audioParams->pos, len);
  17. 	audioParams->pos += len;
  18. }
  19.  
  20. int main() {
  21. 	AVFormatContext* formatContext = avformat_alloc_context();
  22.  
  23. 	// 打开输入文件
  24. 	if (avformat_open_input(&formatContext, "input.mp4", NULL, NULL) != 0) {
  25. 		std::cerr << "无法打开输入文件" << std::endl;
  26. 		return -1;
  27. 	}
  28.  
  29. 	// 检索流信息
  30. 	if (avformat_find_stream_info(formatContext, NULL) < 0) {
  31. 		std::cerr << "无法检索流信息" << std::endl;
  32. 		return -1;
  33. 	}
  34.  
  35. 	// 寻找音频流和视频流
  36. 	int audioStreamIndex = -1;
  37. 	int videoStreamIndex = -1;
  38.  
  39. 	for (unsigned int i = 0; i < formatContext->nb_streams; i++) {
  40. 		if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
  41. 			audioStreamIndex = i;
  42. 		}
  43. 		else if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
  44. 			videoStreamIndex = i;
  45. 		}
  46. 	}
  47.  
  48. 	// 检查是否找到音频流和视频流
  49. 	if (audioStreamIndex == -1 || videoStreamIndex == -1) {
  50. 		std::cerr << "无法找到音频流或视频流" << std::endl;
  51. 		return -1;
  52. 	}
  53.  
  54. 	// 获取音频解码器和视频解码器
  55. 	AVCodecParameters* audioCodecParameters = formatContext->streams[audioStreamIndex]->codecpar;
  56. 	AVCodecParameters* videoCodecParameters = formatContext->streams[videoStreamIndex]->codecpar;
  57.  
  58. 	AVCodec* audioCodec = avcodec_find_decoder(audioCodecParameters->codec_id);
  59. 	AVCodec* videoCodec = avcodec_find_decoder(videoCodecParameters->codec_id);
  60.  
  61. 	// 打开音频解码器和视频解码器
  62. 	AVCodecContext* audioCodecContext = avcodec_alloc_context3(audioCodec);
  63. 	AVCodecContext* videoCodecContext = avcodec_alloc_context3(videoCodec);
  64.  
  65. 	if (!audioCodecContext || !videoCodecContext) {
  66. 		std::cerr << "无法分配解码器上下文" << std::endl;
  67. 		return -1;
  68. 	}
  69.  
  70. 	if (avcodec_parameters_to_context(audioCodecContext, audioCodecParameters) < 0 ||
  71. 		avcodec_parameters_to_context(videoCodecContext, videoCodecParameters) < 0) {
  72. 		std::cerr << "无法填充解码器上下文" << std::endl;
  73. 		return -1;
  74. 	}
  75.  
  76. 	if (avcodec_open2(audioCodecContext, audioCodec, NULL) < 0 ||
  77. 		avcodec_open2(videoCodecContext, videoCodec, NULL) < 0) {
  78. 		std::cerr << "无法打开解码器" << std::endl;
  79. 		return -1;
  80. 	}
  81.  
  82. 	// 初始化SDL
  83. 	if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO) < 0) {
  84. 		std::cerr << "无法初始化SDL" << std::endl;
  85. 		return -1;
  86. 	}
  87.  
  88. 	// 创建窗口和渲染器
  89. 	SDL_Window* window = SDL_CreateWindow("Video Player", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
  90. 		videoCodecParameters->width, videoCodecParameters->height, SDL_WINDOW_SHOWN);
  91. 	SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
  92. 	SDL_Texture* texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
  93. 		videoCodecParameters->width, videoCodecParameters->height);
  94.  
  95. 	// 音频参数设置
  96. 	AudioParams audioParams;
  97. 	audioParams.buffer = new uint8_t[AUDIO_BUFFER_SIZE];
  98. 	audioParams.size = AUDIO_BUFFER_SIZE;
  99. 	audioParams.pos = 0;
  100.  
  101. 	// 初始化音频重采样上下文
  102. 	SwrContext* swrContext = swr_alloc_set_opts(NULL,
  103. 		av_get_default_channel_layout(audioCodecContext->channels),
  104. 		AV_SAMPLE_FMT_S16,
  105. 		audioCodecContext->sample_rate,
  106. 		av_get_default_channel_layout(audioCodecContext->channels),
  107. 		audioCodecContext->sample_fmt,
  108. 		audioCodecContext->sample_rate,
  109. 		0, NULL);
  110. 	if (!swrContext) {
  111. 		std::cerr << "无法分配音频重采样上下文" << std::endl;
  112. 		return -1;
  113. 	}
  114.  
  115. 	if (swr_init(swrContext) < 0) {
  116. 		std::cerr << "无法初始化音频重采样上下文" << std::endl;
  117. 		return -1;
  118. 	}
  119.  
  120. 	// 打开音频设备
  121. 	SDL_AudioSpec desiredSpec, obtainedSpec;
  122. 	desiredSpec.freq = audioCodecContext->sample_rate;
  123. 	desiredSpec.format = AUDIO_S16SYS;
  124. 	desiredSpec.channels = audioCodecContext->channels;
  125. 	desiredSpec.silence = 0;
  126. 	desiredSpec.samples = 1024;
  127. 	desiredSpec.callback = audio_callback;
  128. 	desiredSpec.userdata = &audioParams;
  129.  
  130. 	if (SDL_OpenAudio(&desiredSpec, &obtainedSpec) < 0) {
  131. 		std::cerr << "无法打开音频设备" << std::endl;
  132. 		return -1;
  133. 	}
  134.  
  135. 	// 开始播放音频
  136. 	SDL_PauseAudio(0);
  137.  
  138. 	// 循环读取帧数据并播放
  139. 	AVPacket packet;
  140. 	AVFrame* frame = av_frame_alloc();
  141. 	AVFrame* convertedFrame = av_frame_alloc();
  142.  
  143. 	while (av_read_frame(formatContext, &packet) >= 0) {
  144. 		if (packet.stream_index == audioStreamIndex) {
  145. 			// 解码音频帧
  146. 			int ret = avcodec_send_packet(audioCodecContext, &packet);
  147.  
  148. 			if (ret < 0) {
  149. 				std::cerr << "无法发送音频数据包" << std::endl;
  150. 				break;
  151. 			}
  152.  
  153. 			while (ret >= 0) {
  154. 				ret = avcodec_receive_frame(audioCodecContext, frame);
  155.  
  156. 				if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
  157. 					break;
  158. 				}
  159. 				else if (ret < 0) {
  160. 					std::cerr << "无法解码音频帧" << std::endl;
  161. 					break;
  162. 				}
  163.  
  164. 				// 音频重采样
  165. 				int dst_nb_samples = av_rescale_rnd(swr_get_delay(swrContext, frame->sample_rate) +
  166. 					frame->nb_samples,
  167. 					audioCodecContext->sample_rate,
  168. 					frame->sample_rate,
  169. 					AV_ROUND_UP);
  170. 				av_frame_make_writable(convertedFrame);
  171. 				convertedFrame->format = AV_SAMPLE_FMT_S16;
  172. 				convertedFrame->channel_layout = audioCodecContext->channel_layout;
  173. 				convertedFrame->sample_rate = audioCodecContext->sample_rate;
  174. 				convertedFrame->channels = audioCodecContext->channels;
  175. 				av_samples_alloc(convertedFrame->data, convertedFrame->linesize, audioCodecContext->channels,
  176. 					dst_nb_samples, AV_SAMPLE_FMT_S16, 0);
  177. 				swr_convert(swrContext, convertedFrame->data, dst_nb_samples,
  178. 					(const uint8_t**)frame->data, frame->nb_samples);
  179.  
  180. 				// 播放音频
  181. 				int dataSize = av_get_bytes_per_sample((AVSampleFormat)convertedFrame->format) *
  182. 					convertedFrame->nb_samples * convertedFrame->channels;
  183.  
  184. 				if (audioParams.pos + dataSize <= audioParams.size) {
  185. 					memcpy(audioParams.buffer + audioParams.pos, convertedFrame->data[0], dataSize);
  186. 					audioParams.pos += dataSize;
  187. 				}
  188.  
  189. 				av_freep(&convertedFrame->data[0]);
  190. 			}
  191. 		}
  192. 		else if (packet.stream_index == videoStreamIndex) {
  193. 			// 解码视频帧
  194. 			int ret = avcodec_send_packet(videoCodecContext, &packet);
  195.  
  196. 			if (ret < 0) {
  197. 				std::cerr << "无法发送视频数据包" << std::endl;
  198. 				// 音频参数设置
  199. 				AudioParams audioParams;
  200. 				audioParams.buffer = new uint8_t[AUDIO_BUFFER_SIZE];
  201. 				audioParams.size = AUDIO_BUFFER_SIZE;
  202. 				audioParams.pos = 0;
  203.  
  204. 				// 初始化音频重采样上下文
  205. 				SwrContext* swrContext = swr_alloc_set_opts(NULL,
  206. 					av_get_default_channel_layout(audioCodecContext->channels),
  207. 					AV_SAMPLE_FMT_S16,
  208. 					audioCodecContext->sample_rate,
  209. 					av_get_default_channel_layout(audioCodecContext->channels),
  210. 					audioCodecContext->sample_fmt,
  211. 					audioCodecContext->sample_rate,
  212. 					0, NULL);
  213. 				if (!swrContext) {
  214. 					std::cerr << "无法分配音频重采样上下文" << std::endl;
  215. 					return -1;
  216. 				}
  217.  
  218. 				if (swr_init(swrContext) < 0) {
  219. 					std::cerr << "无法初始化音频重采样上下文" << std::endl;
  220. 					return -1;
  221. 				}
  222.  
  223. 				// 打开音频设备
  224. 				SDL_AudioSpec desiredSpec, obtainedSpec;
  225. 				desiredSpec.freq = audioCodecContext->sample_rate;
  226. 				desiredSpec.format = AUDIO_S16SYS;
  227. 				desiredSpec.channels = audioCodecContext->channels;
  228. 				desiredSpec.silence = 0;
  229. 				desiredSpec.samples = 1024;
  230. 				desiredSpec.callback = audio_callback;
  231. 				desiredSpec.userdata = &audioParams;
  232.  
  233. 				if (SDL_OpenAudio(&desiredSpec, &obtainedSpec) < 0) {
  234. 					std::cerr << "无法打开音频设备" << std::endl;
  235. 					return -1;
  236. 				}
  237.  
  238. 				// 开始播放音频
  239. 				SDL_PauseAudio(0);
  240.  
  241. 				// 循环读取帧数据并播放
  242. 				AVPacket packet;
  243. 				AVFrame* frame = av_frame_alloc();
  244. 				AVFrame* convertedFrame = av_frame_alloc();
  245.  
  246. 				while (av_read_frame(formatContext, &packet) >= 0) {
  247. 					if (packet.stream_index == audioStreamIndex) {
  248. 						// 解码音频帧
  249. 						int ret = avcodec_send_packet(audioCodecContext, &packet);
  250.  
  251. 						if (ret < 0) {
  252. 							std::cerr << "无法发送音频数据包" << std::endl;
  253. 							break;
  254. 						}
  255.  
  256. 						while (ret >= 0) {
  257. 							ret = avcodec_receive_frame(audioCodecContext, frame);
  258.  
  259. 							if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
  260. 								break;
  261. 							}
  262. 							else if (ret < 0) {
  263. 								std::cerr << "无法解码音频帧" << std::endl;
  264. 								break;
  265. 							}
  266.  
  267. 							// 音频重采样
  268. 							int dst_nb_samples = av_rescale_rnd(swr_get_delay(swrContext, frame->sample_rate) +
  269. 								frame->nb_samples,
  270. 								audioCodecContext->sample_rate,
  271. 								frame->sample_rate,
  272. 								AV_ROUND_UP);
  273. 							av_frame_make_writable(convertedFrame);
  274. 							convertedFrame->format = AV_SAMPLE_FMT_S16;
  275. 							convertedFrame->channel_layout = audioCodecContext->channel_layout;
  276. 							convertedFrame->sample_rate = audioCodecContext->sample_rate;
  277. 							convertedFrame->channels = audioCodecContext->channels;
  278. 							av_samples_alloc(convertedFrame->data, convertedFrame->linesize, audioCodecContext->channels,
  279. 								dst_nb_samples, AV_SAMPLE_FMT_S16, 0);
  280. 							swr_convert(swrContext, convertedFrame->data, dst_nb_samples,
  281. 								(const uint8_t**)frame->data, frame->nb_samples);
  282.  
  283. 							// 播放音频
  284. 							int dataSize = av_get_bytes_per_sample((AVSampleFormat)convertedFrame->format) *
  285. 								convertedFrame->nb_samples * convertedFrame->channels;
  286.  
  287. 							if (audioParams.pos + dataSize <= audioParams.size) {
  288. 								memcpy(audioParams.buffer + audioParams.pos, convertedFrame->data[0], dataSize);
  289. 								audioParams.pos += dataSize;
  290. 							}
  291.  
  292. 							av_freep(&convertedFrame->data[0]);
  293. 						}
  294. 					}
  295. 					else if (packet.stream_index == videoStreamIndex) {
  296. 						// 解码视频帧
  297. 						int ret = avcodec_send_packet(videoCodecContext, &packet);
  298.  
  299. 						if (ret < 0) {
  300. 							std::cerr << "无法发送视频数据包" << std::endl;
  301. 							break;
  302. 						}
  303. 						while (ret >= 0) {
  304. 							ret = avcodec_receive_frame(videoCodecContext, frame);
  305.  
  306. 							if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
  307. 								break;
  308. 							}
  309. 							else if (ret < 0) {
  310. 								std::cerr << "无法解码视频帧" << std::endl;
  311. 								break;
  312. 							}
  313.  
  314. 							// 渲染视频
  315. 							SDL_UpdateTexture(texture, NULL, frame->data[0], frame->linesize[0]);
  316. 							SDL_RenderClear(renderer);
  317. 							SDL_RenderCopy(renderer, texture, NULL, NULL);
  318. 							SDL_RenderPresent(renderer);
  319. 						}
  320. 					}
  321.  
  322. 					av_packet_unref(&packet);
  323. 				}
  324.  
  325. 				// 释放资源
  326. 				av_frame_free(&frame);
  327. 				av_frame_free(&convertedFrame);
  328. 				avcodec_close(audioCodecContext);
  329. 				avcodec_close(videoCodecContext);
  330. 				avformat_close_input(&formatContext);
  331. 				avformat_free_context(formatContext);
  332. 				swr_free(&swrContext);
  333. 				SDL_CloseAudio();
  334. 				SDL_Quit();
  335.  
  336. 				return 0;
  337. 			}
  338. 		}
  339. 	}
  340. }

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号