FFmpeg拉流器

最新推荐文章于 2024-05-05 14:54:55 发布
最新推荐文章于 2024-05-05 14:54:55 发布
阅读量2.1k 收藏 7
点赞数
分类专栏： 音视频应用开发 文章标签： AvPuller ffmpeg 拉流器 ffmpeg拉流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaychangeek/article/details/103714862
版权

《音视频应用开发系列文章目录》

拉流器设计思路

生产者-消费者模式。一个线程负责拉取原始音视频流然后存储在队列，音频消费线程从音频队列获取原始流进行解码等其他消费，视频消费线程从视频队列获取原始流进行解码等其他消费。

设计AvPuller类

AvPuller.h

#ifndef _AV_PULLER_H_
#define _AV_PULLER_H_

/***********************************************************
**	Author:kaychan
**	Data:2019-11-04
**	Mail:1203375695@qq.com
**	Explain:a audio/video puller
***********************************************************/

#include "AvCommon.h"

// 获取到解码帧后的回调函数
typedef void(*on_frame)(AVStream *stream, AVFrame *frame, void *priv);
// 错误回调函数
typedef void(*on_error)(std::string error, void *priv);

typedef struct AvPullerParamters_S {

public:
	void *priv = NULL;
	std::string stream = "";
	enum AVHWDeviceType hw_dev_type = AV_HWDEVICE_TYPE_NONE;
	enum AVPixelFormat hw_pix_fmt = AV_PIX_FMT_NONE;
	AVBufferRef *hw_dev_ctx = NULL;
	bool run = true;
	AVFormatContext *fmt_ctx = NULL;
	AVCodecContext *audio_cc = NULL;
	AVCodecContext *video_cc = NULL;
	int64_t cache_packets_size = 0;
	AvPacketSafeQueue audio_packets;
	AvPacketSafeQueue video_packets;
	AVFrame *audio_frame = NULL;
	AVFrame *video_frame = NULL;
	AVFrame *video_hw2sw_frame = NULL;
	int audio_idx = -1;
	int video_idx = -1;
	on_frame audio_on_frame;
	on_frame video_on_frame;
	on_error av_on_error;
}AvPullerParamters;

class AvPuller {

public:
	AvPuller();
	// 启动拉流器
	// stream：流名
	// audio_on_frame：音频消费回调函数
	// video_on_frame：视频消费回调函数
	// on_error：错误信息回调函数
	// hw_dev_type：解码器类型支持硬件解码
	//				(可以参考本系列博文《FFmpeg视频解码硬件加速》使用)
	// priv：回调函数入参
	void start(const std::string stream,
		on_frame audio_on_frame, on_frame video_on_frame, on_error av_on_error, 
		enum AVHWDeviceType hw_dev_type = AV_HWDEVICE_TYPE_NONE, 
		void *priv = NULL);
	// 停止拉流器
	void stop();

private:
	std::thread tsk_p_av_;
	std::thread tsk_c_a_;
	std::thread tsk_c_v_;
	AvPullerParamters paramters_;
};

#endif

AvPuller.cpp

#include "AvPuller.h"

static std::string AnsiToUTF8(const char *_ansi, int _ansi_len) {

	std::string str_utf8("");
	wchar_t* pUnicode = NULL;
	BYTE * pUtfData = NULL;
	do {

		int unicodeNeed = MultiByteToWideChar(CP_ACP, 0, _ansi, _ansi_len, NULL, 0);
		pUnicode = new wchar_t[unicodeNeed + 1];
		memset(pUnicode, 0, (unicodeNeed + 1) * sizeof(wchar_t));
		int unicodeDone = MultiByteToWideChar(CP_ACP, 0, _ansi, _ansi_len, (LPWSTR)pUnicode, unicodeNeed);
		if (unicodeDone != unicodeNeed) break;
		int utfNeed = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pUnicode, unicodeDone, (char *)pUtfData, 0, NULL, NULL);
		pUtfData = new BYTE[utfNeed + 1];
		memset(pUtfData, 0, utfNeed + 1);
		int utfDone = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pUnicode, unicodeDone, (char *)pUtfData, utfNeed, NULL, NULL);
		if (utfNeed != utfDone) break;
		str_utf8.assign((char *)pUtfData);
	} while (false);
	if (pUnicode) delete[] pUnicode;
	if (pUtfData) delete[] pUtfData;
	return str_utf8;
}

enum AVPixelFormat global_hw_pix_fmt = AV_PIX_FMT_NONE;

static enum AVPixelFormat on_get_hw_format(AVCodecContext *ctx, const enum AVPixelFormat *pix_fmts) {

	const enum AVPixelFormat *p;
	for (p = pix_fmts; *p != -1; p++) {
		if (*p == global_hw_pix_fmt)
			return *p;
	}
	return AV_PIX_FMT_NONE;
}

static inline void emit_error(int errcode, AvPullerParamters &paramters) {

	paramters.run = false;
	char error[256];
	av_strerror(errcode, error, 256);
	paramters.av_on_error(error, paramters.priv);
}

static inline void emit_error(std::string errstr, AvPullerParamters &paramters) {

	paramters.run = false;
	paramters.av_on_error(errstr, paramters.priv);
}

void AvPuller_p_av(AvPullerParamters &paramters) {

	// open media input
	AVInputFormat *ifmt = NULL;
	std::string::size_type sta = paramters.stream.find("audio="); 
	std::string::size_type stv = paramters.stream.find("video=");
	if (sta != std::string::npos || stv != std::string::npos) {

		ifmt = av_find_input_format(AVENGINE_MEDIA_DRIVER);
	}
	std::string url_utf8 = AnsiToUTF8(paramters.stream.c_str(), paramters.stream.length());
	AVDictionary *dict = NULL;
	av_dict_set(&dict, "stimeout", "2000000", 0);
	av_dict_set(&dict, "buffer_size", "4096000", 0);
	av_dict_set(&dict, "recv_buffer_size", "4096000", 0);
	int r = avformat_open_input(&paramters.fmt_ctx, url_utf8.c_str(), ifmt, &dict);
	if (r != 0) {

		emit_error(r, paramters);
		return;
	}
	r = avformat_find_stream_info(paramters.fmt_ctx, NULL);
	if (r < 0) {

		emit_error(r, paramters);
		return;
	}
	// find media stream index
	AVCodec *ac, *vc;
	paramters.audio_idx = av_find_best_stream(paramters.fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &ac, 0);
	paramters.video_idx = av_find_best_stream(paramters.fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &vc, 0);
	// open media stream decoder
	if (paramters.audio_idx >= 0) {

		paramters.audio_cc = avcodec_alloc_context3(ac);
		avcodec_parameters_to_context(paramters.audio_cc, paramters.fmt_ctx->streams[paramters.audio_idx]->codecpar);
		av_codec_set_pkt_timebase(paramters.audio_cc, paramters.fmt_ctx->streams[paramters.audio_idx]->time_base);
		r = avcodec_open2(paramters.audio_cc, ac, NULL);
		if (r == 0) {

			paramters.audio_frame = av_frame_alloc();
			if (!paramters.audio_frame) {

				emit_error("av_frame_alloc failed", paramters);
				return;
			}
		}
		else {

			emit_error(r, paramters);
			return;
		}
	}
	if (paramters.video_idx >= 0) {

		paramters.video_cc = avcodec_alloc_context3(vc);
		avcodec_parameters_to_context(paramters.video_cc, paramters.fmt_ctx->streams[paramters.video_idx]->codecpar);
		av_codec_set_pkt_timebase(paramters.video_cc, paramters.fmt_ctx->streams[paramters.video_idx]->time_base);
		// check video decode device
		if (paramters.hw_dev_type != AV_HWDEVICE_TYPE_NONE) {

			paramters.hw_pix_fmt = AV_PIX_FMT_NONE;
			int iii = 0;
			for (;;) {

				const AVCodecHWConfig *config = avcodec_get_hw_config(vc, iii++);
				if (config) {

					if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
						config->device_type == paramters.hw_dev_type) {

						paramters.hw_pix_fmt = config->pix_fmt;
						r = av_hwdevice_ctx_create(&paramters.hw_dev_ctx, paramters.hw_dev_type, NULL, NULL, 0);
						if (r == 0) {

							global_hw_pix_fmt = paramters.hw_pix_fmt;
							paramters.video_cc->get_format = on_get_hw_format;
							paramters.video_cc->hw_device_ctx = av_buffer_ref(paramters.hw_dev_ctx);
						}
						break; // support
					}
				}
				else break; // the hw not support the codec
			}
		}
		r = avcodec_open2(paramters.video_cc, vc, NULL);
		if (r == 0) {

			paramters.video_frame = av_frame_alloc();
			paramters.video_hw2sw_frame = av_frame_alloc();
			if (!paramters.video_frame || !paramters.video_hw2sw_frame) {

				emit_error("av_frame_alloc failed", paramters);
				return;
			}
		}
		else {

			emit_error(r, paramters);
			return;
		}
	}

	// start produce audio and video
	while (paramters.run) {
		
		AVPacket packet;
		paramters.cache_packets_size = paramters.audio_packets.size() + paramters.video_packets.size();
		if (paramters.cache_packets_size < 1 * MB) {

			r = av_read_frame(paramters.fmt_ctx, &packet);
			if (r >= 0) {

				if (packet.stream_index == paramters.audio_idx) paramters.audio_packets.eq(packet);
				if (packet.stream_index == paramters.video_idx) paramters.video_packets.eq(packet);
			}
			else {

				// maybe rtsp/rtmp has disconnected
				// maybe file is eof
				break;
			}
		}
		else CPP11_MSLEEP(30);
	}
}

void AvPuller_c_a(AvPullerParamters &paramters) {

	// start consume audio
	while (paramters.run) {

		if (!paramters.audio_packets.empty()) {

			AVPacket p = paramters.audio_packets.dq();
			if (!p.data) continue;
			int r = avcodec_send_packet(paramters.audio_cc, &p);
			av_packet_unref(&p);
			if (r == 0) {

				r = avcodec_receive_frame(paramters.audio_cc, paramters.audio_frame);
				if (r == 0) { 

					paramters.audio_on_frame(paramters.fmt_ctx->streams[paramters.audio_idx],
						paramters.audio_frame, paramters.priv);
				}
			}
		}else CPP11_MSLEEP(30);
	}
}

void AvPuller_c_v(AvPullerParamters &paramters) {

	// start consume video
	while (paramters.run) {

		if (!paramters.video_packets.empty()) {

			AVPacket p = paramters.video_packets.dq();
			if (!p.data) continue;
			int r = avcodec_send_packet(paramters.video_cc, &p);
			av_packet_unref(&p);
			if (r == 0) {

				r = avcodec_receive_frame(paramters.video_cc, paramters.video_frame);
				if (r == 0) {

					AVFrame *tf = paramters.video_frame;
					if (paramters.video_frame->format == paramters.hw_pix_fmt) {

						r = av_hwframe_transfer_data(paramters.video_hw2sw_frame, paramters.video_frame, 0);
						if (r == 0)
							tf = paramters.video_hw2sw_frame;
					}
					tf->best_effort_timestamp = paramters.video_frame->best_effort_timestamp;
					paramters.video_on_frame(paramters.fmt_ctx->streams[paramters.video_idx],
						tf, paramters.priv);
				}
			}
		}
		else CPP11_MSLEEP(30);
	}
}

AvPuller::AvPuller() {

}

void AvPuller::start(const std::string stream,
	on_frame audio_on_frame, on_frame video_on_frame, on_error av_on_error,
	enum AVHWDeviceType hw_dev_type,
	void *priv) {

	paramters_.stream = stream;
	paramters_.audio_on_frame = audio_on_frame;
	paramters_.video_on_frame = video_on_frame;
	paramters_.av_on_error = av_on_error;
	paramters_.hw_dev_type = hw_dev_type;
	paramters_.priv = priv;
	paramters_.run = true;
	tsk_p_av_ = std::thread(AvPuller_p_av, std::ref(paramters_));
	tsk_c_a_ = std::thread(AvPuller_c_a, std::ref(paramters_));
	tsk_c_v_ = std::thread(AvPuller_c_v, std::ref(paramters_));
}

void AvPuller::stop() {

	paramters_.run = false;
	if (tsk_p_av_.joinable()) tsk_p_av_.join();
	if (tsk_c_a_.joinable()) tsk_c_a_.join();
	if (tsk_c_v_.joinable()) tsk_c_v_.join();
	paramters_.audio_packets.clear();
	paramters_.video_packets.clear();
	if (paramters_.audio_frame) {

		av_frame_free(&paramters_.audio_frame);
		paramters_.audio_frame = NULL;
	}
	if (paramters_.video_frame) {

		av_frame_free(&paramters_.video_frame);
		paramters_.video_frame = NULL;
	}
	if (paramters_.video_hw2sw_frame) {

		av_frame_free(&paramters_.video_hw2sw_frame);
		paramters_.video_hw2sw_frame = NULL;
	}
	if (paramters_.audio_cc) {

		avcodec_close(paramters_.audio_cc);
		avcodec_free_context(&paramters_.audio_cc);
		paramters_.audio_cc = NULL;
	}
	if (paramters_.video_cc) {

		avcodec_close(paramters_.video_cc);
		avcodec_free_context(&paramters_.video_cc);
		paramters_.video_cc = NULL;
	}
	if (paramters_.hw_dev_ctx) {

		av_buffer_unref(&paramters_.hw_dev_ctx);
		paramters_.hw_dev_ctx = NULL;
	}
	if (paramters_.fmt_ctx) {

		avformat_close_input(&paramters_.fmt_ctx);
		paramters_.fmt_ctx = NULL;
	}
}

 

KayChanGeek
关注
专栏目录
ffmpeg拉流 —— RTMP拉流例程
yinshipin007的博客
05-26 626
参考：FFmpeg 解码 API 超时设置当视频流地址能打开，但是视频流中并没有流内容的时候，可能会导致整体执行流程阻塞在 avformat_open_input 或者 av_read_frame 方法上。ffmpeg之文件操作——AVIOContext, URLContext, URLProtocolFFmpeg 结构体学习(七)： AVIOContext 分析版权声明：本文为CSDN博主「zhou jiabo」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
QT+FFMPEG 从摄像机拉取rtsp裸h264流，播放并保存到本地
12-04
功能： 1. 从摄像头拉rtsp裸h264流 2. 实时播放 3. 视频流实时转换为Mpeg-Ts 4. 改变码率，改变I帧间隔 5. 断线重连 6. ffmpeg版本4.3
【深度学习】使用ffmpg及gstreamer进行视频拉流及编解码（一）：ffmpg
种一棵树最好的时间是十年前，其次是现在
03-30 5726
GStreamer：一款功能强大的多媒体框架，可以用于音视频的采集、编码、解码、处理和传输。FFmpeg：一个开源的音视频处理工具，可以用于音视频的采集、编码、解码、转码、处理等。FFmpeg和GStreamer都是流媒体处理框架，它们在音视频编解码、转码、过滤、采集等方面都有广泛的应用。FFmpeg是一个开源的音视频处理库，支持多种音视频格式的编解码、转码、过滤等操作。
FFmpeg拉流教程
zhaoxz
08-02 4033
android版FFmpeg库资源：https://download.csdn.net/download/m0_37759974/86272410。note:因为FFmpeg是用C语言的规则，所以此处引用头文件要加上extern “C”SwsContext *swsContext;做了一个项目学习下FFmpeg拉流的过程。note：据说FFmpeg库的加载顺序还有要求。.........
FFmpeg中RTSP客户端拉流测试代码
网络资源是无限的
06-15 7358
之前在https://blog.csdn.net/fengbingchun/article/details/91355410中给出了通过LIVE555实现拉流的测试代码，这里通过FFmpeg来实现，代码量远小于LIVE555，实现模块在libavformat。 在4.0及以上版本中，FFmpeg有了些变动，好像不再推荐使用av_register_all、avformat_network_init...
ffmpeg命令 拉流
万事亨通
12-25 9873
ffmpeg命令 拉流
ffmpeg拉流后保存为MP4文件
05-05
确保正确配置输入URL、输出路径，并根据实际需求调整编码参数，就能实现FFmpeg拉流并保存为MP4的功能。 总之，FFmpeg是一个功能强大的工具，能够方便地处理各种流媒体任务。通过拉流、转换和存储，我们可以构建起一...
ffmpeg rtmp拉流转发
06-18
ffmpeg 从Nginx拉取rtmp流，然后通过rtmp推流地址，推流到另一个rtmp服务器。文为linux 源码，需要在linux编译。编译makefile自行编写。文件源码已在生产环境使用，可以正常拉取、推送rtmp视频流
Java 使用javaCV、ffmpeg拉流H265 RTSP转推H264 RTMP可获取流访问人数（源代码）
09-08
4）、ffmpeg采用命令的方式拉流和推流，支持H265和H264。 5）、支持获取流的访问数，可设置自动关闭0访问数的推流以节约系统资源。 6）、linux系统支持推流前系统资源限制。 7）、完整的日志输出，便于查看项目...
Android平台使用的FFmpeg静态库版本4.4.2。支持RTP拉流
08-02
其他说明：在网上没有找到android平台的FFmpeg库，就自己编译了一个，我用的事RTP拉流的功能，教程上说功能挺全的但是其他的功能没有使用过。本人的开发环境为：Qt For Android，感兴趣的朋友见链接：...
利用FFmpeg实现简单rtp推流
09-19
利用FFmpeg实现rtp推流.重点为时间戳转换.
ffmpeg多路流合成
07-27
用ffmpeg将多路流合成一路，合成后画面可以画中画或者并排显示。包括混音
VLC小型rstp拉流播放器
10-17
海康、大华摄像头直接拉流的小型播放器，用于测试摄像头是否接入，以及试验视频路径是否正确
QT/C++多线程练习:单生产者多消费者(源码)
09-09
详细设计说明在我的上一篇文章内。 使用linux qt打开文件夹下的.pro文件即可。 涉及 线程创建与退出、线程暂停、父子线程之前以及兄弟线程之间的参数和信号传递、多线程的以及多线程的管理。要求是练习的demo对于以上的点只要涉及基础即可。 主线程、生产者线程（一）、消费者管理线程（一）、消费者线程（多），以及一些全局变量。 主线程职责:UI控件的控制和显示、控制生产者:调节生产的速度和暂停与继续、控制消费 生产者线程职责:根据商品数量调控生产，根据生产速度增加商品数量。 消费者管理类:根据UI的控制去创建消费者线程以及删除/停止消费者线程，需要一个容器将已存在的消费者线程指针存储起来，并且可以通过容器内的指针去控制消费者线程。 消费者线程职责:减少商品数量，其他的都不管，全交给管理类去控制。 全局变量:单独把一些全局变量和共用的头文件放在appdata.h/.cpp 里面，这样在写的时候结构可以比较清晰,一般的成熟项目都这么写，严禁一点的还可以创建一个类把变量设置为私有的，再通过get/set去取值和修改。
使用ffmpeg推流拉流
lu_linux的博客
07-21 1431
使用ffmpeg推流拉流
FFmpeg多线程拉流
yinshipin007的博客
05-26 543
环境是Ubuntu18.04，ffmpeg4.1.5主要有这么几个文件:main.cpp。
【FFmpeg】使用 ffmpeg 命令实现直播推拉流 ( 推流和拉流简介 | 流媒体服务器搭建 | 使用 ffmpeg 命令进行推流操作 | 使用 ffmpeg/ffplay 命令进行拉流操作 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-05 1万+
一、推流和拉流简介 1、直播推流和拉流操作 2、直播推流和拉流涉及到的软件 3、推流 -> 拉流 流程 二、流媒体服务器搭建 1、相关文件准备 2、创建 ECS 云服务器实例 3、配置安全组 4、使用 WinSCP 上传流媒体服务器软件及配置脚本 5、使用 SecureCRT 连接服务器 6、搭建流媒体服务器 三、使用 ffmpeg 命令进行推流操作 四、使用 ffplay 命令进行拉流操作 五、使用 ffmpeg 命令进行拉流操作
ffmpeg获取rtsp h265_基于ffmpeg的rtsp拉流代码分析流水账
weixin_39959298的博客
12-19 772
概念RTP: Real-time Transport Protocol,实时传输协议，一般用于多媒体数据的传输。RTCP: RTP Control Protocol，实时传输控制协议，同RTP一起用于数据传输的监视，控制功能。RTSP: Real Time Streaming Protocol,实时流协议，用于多媒体数据流的控制，如播放，暂停等。RTP/RTCP相对于底层传输层，和RTSP，SIP...
FFMpeg直播命令拉流与推流
一条小船的博客
11-10 5554
FFMpeg直播命令拉流与推流. 直播推流 ffmpeg -re -i test.flv -c copy -f flv rtmp://server/live/streamName -re 减慢推流的帧率 -c copy 表示将流直接拷贝 直播拉流 ffmpeg -i rtmp://server/live/streamName -c copy dump.flv ffmpeg -i rtmp://5...
ffmpeg拉流测试
04-26
FFmpeg是一个开源的跨平台音视频处理工具，它提供了丰富的功能和命令行选项，可以用于音视频的编解码、转码、流媒体处理等。下面是使用FFmpeg进行拉流测试的步骤： 1. 下载和安装FFmpeg：你可以从FFmpeg官方网站（https://ffmpeg.org/）下载适合你操作系统的版本，并按照官方文档进行安装。 2. 获取测试视频流地址：你需要找到一个可用的视频流地址，可以是网络上的直播流、本地文件或者其他支持的视频源。 3. 使用FFmpeg进行拉流测试：打开终端或命令行窗口，输入以下命令进行拉流测试： ``` ffmpeg -i <视频流地址> ``` 其中，`<视频流地址>`是你要测试的视频流地址。 4. 观察输出信息：FFmpeg会输出一些关于视频流的信息，包括分辨率、编码格式、帧率等。你可以根据输出信息来判断视频流是否正常。 5. 结束测试：按下Ctrl+C组合键可以停止FFmpeg的运行。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值