rtmp源码分析之RTMP_Write 和 RTMP_SendPacket

于 2022-02-27 22:21:46 发布
阅读量785 收藏 1
点赞数 1
分类专栏： c/c++ 音视频 文章标签： 音视频 rtmp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dss875914213/article/details/123171825
版权
本文详细解析了RTMP协议中的RTMPPacket结构体，包括chunk header、message header等关键字段，并展示了RTMP_Write函数如何处理音视频数据，进行FLV格式的Tag数据读取和组装。同时，RTMP_SendPacket函数展示了如何根据chunk size发送RTMPPacket，处理不同大小的消息头和时间戳增量，确保数据正确传输。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

typedef struct RTMPPacket
	{
		uint8_t m_headerType; //  chunk type id (2bit)fmt 对应message head {0,3,7,11} + (6bit)chunk stream id  /*大部分情况是一个字节
		uint8_t m_packetType; // Message type ID（1-7协议控制；8，9音视频；10以后为AMF编码消息）
		uint8_t m_hasAbsTimestamp;	/* timestamp absolute or relative? */
		int m_nChannel; //chunk stream id(chunk basic header)字段
		uint32_t m_nTimeStamp;	/* timestamp */
		int32_t m_nInfoField2;	/* last 4 bytes in a long header */
		uint32_t m_nBodySize; //经过AMF编码组包后，message的大小 (如果是音视频数据 即FLV格式一个Tag中Tag Data 大小)
		uint32_t m_nBytesRead; // 需要发送一个Tag Data 的数据大小或者是已读取数据大小
		RTMPChunk *m_chunk;
		// body 指向数据的起始处。创建 body 空间时，也把 chunk header 的空间也创立了，且在 body 前面，故可以将指针指向 body 前面
		char* m_body; // Tag Data 数据  Tag data的起始指针因为会循环读取，给m_body所在内存赋值，直到一个Tag Data 读完
					//当chunk中的内容为命令时，m_body为chunk body(data)的起始指针
	} RTMPPacket;

int
RTMP_Write(RTMP* r, const char* buf, int size, int streamIdx, int channel)
{
	RTMPPacket* pkt = &r->m_write;
	char* pend, * enc;
	int s2 = size;
	int ret = 0;
	int num = 0;
	int bodySize = 0;
	int bytesRead = 0;
	pkt->m_nChannel = channel;	/* source channel */
	pkt->m_nInfoField2 = r->Link.streams[streamIdx].id;

	while (s2)
	{
		if (!pkt->m_nBytesRead)
		{
			if (size < 11)
			{
				/* FLV pkt too small */
				return 0;
			}

			if (buf[0] == 'F' && buf[1] == 'L' && buf[2] == 'V')
			{
				buf += 13;
				s2 -= 13;
			}
			// 获取 tag 类型
			pkt->m_packetType = *buf++;
			// 获取 data size 
			pkt->m_nBodySize = AMF_DecodeInt24(buf);
			bodySize = pkt->m_nBodySize;
			buf += 3;
			// 获取时间戳
			pkt->m_nTimeStamp = AMF_DecodeInt24(buf);
			buf += 3;
			// 加上扩展时间戳
			pkt->m_nTimeStamp |= *buf++ << 24;
			// 跳过 streamID
			buf += 3;
			// 总长度跳过 11
			s2 -= 11; 

			// RTMP_PACKET_TYPE_INFO 代表 script
			if (((pkt->m_packetType == RTMP_PACKET_TYPE_AUDIO
				|| pkt->m_packetType == RTMP_PACKET_TYPE_VIDEO) &&
				!pkt->m_nTimeStamp) || pkt->m_packetType == RTMP_PACKET_TYPE_INFO) 
			{
				// 设置 basic header  chunk type id = 0  chunk stream id = 0
				// cs id = 0 表示 2字节头
				pkt->m_headerType = RTMP_PACKET_SIZE_LARGE;
				if (pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
				{
					pkt->m_nBodySize += 16;
					bodySize += 16;
				}
			}
			else
			{
				pkt->m_headerType = RTMP_PACKET_SIZE_MEDIUM;
			}

			// 分配 chunk 空间，既分配了 data 空间，也分配了 chunk header 最大的空间
			if (!RTMPPacket_Alloc(pkt, pkt->m_nBodySize))
			{
				RTMP_Log(RTMP_LOGDEBUG, "%s, failed to allocate packet", __FUNCTION__);
				return FALSE;
			}
			enc = pkt->m_body; // 指向数据
			pend = enc + pkt->m_nBodySize; // 指向数据结尾
			if (pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
			{
				enc = AMF_EncodeString(enc, pend, &av_setDataFrame);
				pkt->m_nBytesRead = enc - pkt->m_body;
			}
		}
		else
		{
			enc = pkt->m_body + pkt->m_nBytesRead;
		}
		// num 为还未发送的数据个数
		num = pkt->m_nBodySize - pkt->m_nBytesRead;
		if (num < 0)
		{
			RTMP_Log(RTMP_LOGERROR, "%s error %d,%d", __FUNCTION__, pkt->m_nBodySize, pkt->m_nBytesRead);
			return FALSE;
		}
		if (num > s2)
			num = s2;
		if (num < 0)
		{
			RTMP_Log(RTMP_LOGERROR, "%s error %d", __FUNCTION__, s2);
			return FALSE;
		}
		memcpy(enc, buf, num); // 将 buf 拷贝到 pkt->m_body
		pkt->m_nBytesRead += num;
		bytesRead += num;
		s2 -= num;
		buf += num;
		if (pkt->m_nBytesRead == pkt->m_nBodySize)
		{
			// 把 pkt 发送出去
			ret = RTMP_SendPacket(r, pkt, FALSE);
			RTMPPacket_Free(pkt);
			pkt->m_nBytesRead = 0;
			bytesRead = 0;
			if (!ret)
				return -1;
			// 跳过 previousTagSize 
			// 所以 previousTagSize 作用是什么?
			// 快速向前 seek 数据
			buf += 4;
			s2 -= 4;
			if (s2 < 0)
				break;
		}
	}
	return size + s2;
}

int
RTMP_SendPacket(RTMP* r, RTMPPacket* packet, int queue)
{
	const RTMPPacket* prevPacket;
	uint32_t last = 0;
	int nSize;
	int hSize, cSize;
	char* header, * hptr, * hend, hbuf[RTMP_MAX_HEADER_SIZE], c;
	uint32_t t;
	char* buffer, * tbuf = NULL, * toff = NULL;
	int nChunkSize;
	int tlen;

	if (packet->m_nChannel >= r->m_channelsAllocatedOut)
	{
		int n = packet->m_nChannel + 10;
		RTMPPacket** packets = realloc(r->m_vecChannelsOut, sizeof(RTMPPacket*) * n);
		if (!packets)
		{
			free(r->m_vecChannelsOut);
			r->m_vecChannelsOut = NULL;
			r->m_channelsAllocatedOut = 0;
			return FALSE;
		}
		r->m_vecChannelsOut = packets;
		memset(r->m_vecChannelsOut + r->m_channelsAllocatedOut, 0, sizeof(RTMPPacket*) * (n - r->m_channelsAllocatedOut));
		r->m_channelsAllocatedOut = n;
	}

	// 获取该通道，上一次的数据
	prevPacket = r->m_vecChannelsOut[packet->m_nChannel];
	if (prevPacket && packet->m_headerType != RTMP_PACKET_SIZE_LARGE)
	{
		/* compress a bit by using the prev packet's attributes */
		if (prevPacket->m_nBodySize == packet->m_nBodySize
			&& prevPacket->m_packetType == packet->m_packetType
			&& packet->m_headerType == RTMP_PACKET_SIZE_MEDIUM)
			packet->m_headerType = RTMP_PACKET_SIZE_SMALL;

		if (prevPacket->m_nTimeStamp == packet->m_nTimeStamp
			&& packet->m_headerType == RTMP_PACKET_SIZE_SMALL)
			packet->m_headerType = RTMP_PACKET_SIZE_MINIMUM;
		last = prevPacket->m_nTimeStamp;
	}

	if (packet->m_headerType > 3)	/* sanity */
	{
		RTMP_Log(RTMP_LOGERROR, "sanity failed!! trying to send header of type: 0x%02x.",
			(unsigned char)packet->m_headerType);
		return FALSE;
	}

	// 块头初始大小 = 基本头(1字节) + 块消息头大小(11/7/3/0) = [12, 8, 4, 1]
	// 块基本头是1-3字节，因此用变量cSize来表示剩下的0-2字节
	// nSize 表示块头初始大小， hSize表示块头大小, cSize来表示剩下的0-2字节
	// hSize = nSize + cSize + 4
	nSize = packetSize[packet->m_headerType];
	hSize = nSize;
	cSize = 0;

	if (packet->m_nTimeStamp < last)
	{
		RTMP_Log(RTMP_LOGWARNING, "timestamp not increase [%u] [%u] type[%d]", packet->m_nTimeStamp, last, packet->m_packetType);
	}

	// 时间戳增量
	t = packet->m_nTimeStamp - last;
	if (packet->m_body) 
	{
		// 块头的首指针  向前平移了  基本头(1字节) + 块消息头大小(11/7/3/0)  字节
		header = packet->m_body - nSize;
		// 块头的尾指针
		hend = packet->m_body;
	}
	else
	{
		header = hbuf + 6;
		hend = hbuf + sizeof(hbuf);
	}

	// 块基本头是1-3字节，因此用变量cSize来表示剩下的0-2字节
	if (packet->m_nChannel > 319) // 块流id(cs id)大于319，则块基本头占3个字节
		cSize = 2;
	else if (packet->m_nChannel > 63) // 块流id(cs id)在64与319之间，则块基本头占2个字节
		cSize = 1;
	if (cSize)
	{
		// 向前平移了 块基本头是1-3字节，因此用变量cSize来表示剩下的0-2字节 个字节
		header -= cSize;
		hSize += cSize;
	}

	// 如果 t>0xffffff， 则需要使用 extended timestamp
	if (nSize > 1 && t >= 0xffffff)
	{
		// 向前平移了 extended timestamp
		header -= 4;
		hSize += 4;
	}

	// 确定好 Header 的位置后，就可以开始赋值了
	hptr = header;

	// 设置 basic header


	// 0 1 2 3 4 5 6 7
	//	+ -+-+-+-+-+-+-+-+
	//	| fmt | cs id |
	//	+-+-+-+-+-+-+-+-+
	//	一字节头

	//	0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
	//	+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| fmt | 0 | cs id - 64 |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	两字节头

	//	0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
	//	+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| fmt | 1 | cs id - 64 |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	三字节头

	// 把ChunkBasicHeader的Fmt类型左移6位
	// cSize 表示块基本头剩下的0-2字节 
	c = packet->m_headerType << 6;
	switch (cSize)
	{
	case 0:
		c |= packet->m_nChannel; // chunk stream ID
		break;
	case 1:
		break;
	case 2:
		c |= 1;
		break;
	}
	*hptr++ = c;
	if (cSize)
	{
		int tmp = packet->m_nChannel - 64;
		*hptr++ = tmp & 0xff;
		if (cSize == 2)
			*hptr++ = tmp >> 8;
	}

	// 设置 message header


	//消息类型 0， fmt = 0，字节长度 = 11：

	//	0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
	//	+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| timestamp | message length |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| message length(cont) | message type id | msg stream id |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| message stream id(cont) |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	消息类型 1， fmt = 1，字节长度 = 7:

	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
	//	+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| timestamp delta | message length |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| message length(cont) | message type id |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	消息类型 2， fmt = 2，字节长度 = 3:

	//0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
	//	+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	| timestamp delta |
	//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	//	消息类型 3， fmt = 3，字节长度 = 0:

	//没有消息头，消息头长度是 0
	// nSize 块头初始大小 = 基本头(1字节) + 块消息头大小(11/7/3/0) = [12, 8, 4, 1]
	if (nSize > 1)
	{
		// 写入 timestamp 或 timestamp delta
		hptr = AMF_EncodeInt24(hptr, hend, t > 0xffffff ? 0xffffff : t);
	}

	if (nSize > 4)
	{
		// 写入 message length
		hptr = AMF_EncodeInt24(hptr, hend, packet->m_nBodySize);
		// 写入 message type id
		*hptr++ = packet->m_packetType;
	}

	if (nSize > 8)
		// 写入 message stream id  
		// 还原Chunk为Message的时候都是根据这个ID来辨识是否是同一个消息的Chunk的
		hptr += EncodeInt32LE(hptr, packet->m_nInfoField2);

	if (nSize > 1 && t >= 0xffffff)
		// 写入 extended timestamp
		hptr = AMF_EncodeInt32(hptr, hend, t);

	// 后面的 nSize 表示 data 的长度
	nSize = packet->m_nBodySize;
	// buffer 表示 data 的指针
	buffer = packet->m_body;
	// Chunk大小，默认是128字节
	nChunkSize = r->m_outChunkSize;

	RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d, size=%d", __FUNCTION__, (int)r->m_sb.sb_socket,
		nSize);
	/* send all chunks in one HTTP request */
	if (r->Link.protocol & RTMP_FEATURE_HTTP)
	{
		// 需要将 data 切分成几次发送
		int chunks = (nSize + nChunkSize - 1) / nChunkSize;
		if (chunks > 1)
		{

			// 注意：ChunkBasicHeader的长度 = cSize + 1
			// 消息分n块后总的开销：
			// n个ChunkBasicHeader，1个ChunkMsgHeader，1个Message负载
			// 实际上只有第一个Chunk是完整的，剩下的只有ChunkBasicHeader
			// ? 感觉应该是 (chunks-1) * (cSize + 1) + nSize + hSize?
			tlen = chunks * (cSize + 1) + nSize + hSize; // tlen 正真发送需要的字节数
			tbuf = malloc(tlen);
			if (!tbuf)
				return FALSE;
			toff = tbuf;
		}
	}
	// chunk 大小 chunk header + data
	while (nSize + hSize)
	{
		int wrote;

		if (nSize < nChunkSize)
			nChunkSize = nSize;

		RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t*)header, hSize);
		RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t*)buffer, nChunkSize);
		// tbuf 不为 0，代表一个 chunkSize 发送不完全部数据
		if (tbuf)
		{
			memcpy(toff, header, nChunkSize + hSize);
			toff += nChunkSize + hSize;
		}
		else
		{
			// 一次发送完全部数据
			wrote = WriteN(r, header, nChunkSize + hSize);
			if (!wrote)
				return FALSE;
		}
		// nSize 为剩下的 data 长度
		nSize -= nChunkSize;
		// buffer 往后移动 chunksize 
		buffer += nChunkSize;
		// chunk header 设为 0
		hSize = 0;

		if (nSize > 0)
		{
			header = buffer - 1;

			// basic header 字节
			hSize = 1;
			if (cSize)
			{
				header -= cSize;
				hSize += cSize;
			}

			// c 为 basic header 第一个字节
			*header = (0xc0 | c); // 将 fmt 设置为 3，表示 message header 和 extended timestamp 都为空
			if (cSize)
			{
				int tmp = packet->m_nChannel - 64;
				header[1] = tmp & 0xff;
				if (cSize == 2)
					header[2] = tmp >> 8;
			}
		}
	}
	if (tbuf)
	{
		int wrote = WriteN(r, tbuf, toff - tbuf);
		free(tbuf);
		tbuf = NULL;
		if (!wrote)
			return FALSE;
	}

	/* we invoked a remote method */
	if (packet->m_packetType == RTMP_PACKET_TYPE_INVOKE)
	{
		AVal method;
		char* ptr;
		ptr = packet->m_body + 1;
		AMF_DecodeString(ptr, &method);
		RTMP_Log(RTMP_LOGDEBUG, "Invoking %s", method.av_val);
		/* keep it in call queue till result arrives */
		if (queue)
		{
			int txn;
			ptr += 3 + method.av_len;
			txn = (int)AMF_DecodeNumber(ptr);
			AV_queue(&r->m_methodCalls, &r->m_numCalls, &method, txn);
		}
	}

	if (!r->m_vecChannelsOut[packet->m_nChannel])
		r->m_vecChannelsOut[packet->m_nChannel] = malloc(sizeof(RTMPPacket));
	memcpy(r->m_vecChannelsOut[packet->m_nChannel], packet, sizeof(RTMPPacket));
	return TRUE;
}

参考文献

https://blog.youkuaiyun.com/qq_39683826/article/details/114656972

基于obs的rtmp源码分析之RTMP_Write(rtmp发送音视频数据或命令)
一个大龄程序员的博客
03-12 779
最近在研究OBS源码，里面有一个很重要的模块是推流模块，OBS是使用RTMP进行推流的，源码里面也有RTMP的源码，翻了一下目前网上没有详细的RTMP源码注释，所以这里基于OBS项目，来详细讲一下RTMP源码包括内核数据结构、公共函数接口功能。关于具体的RTMP协议，网上有很多RTMP协议可以找到这里只做简单介绍，重点是代码的注释分析。关于RTMP源码的内核结构体，在代码中涉及的我会有标注，在另一个博文中具体分析了核心结构体注释。 接口比较多写的比较细，文章比较长，有些函数体中无效的代码（例如 log日志、
基于obs的rtmp源码分析之RTMP_ReadPacket(rtmp读取服务端数据并处理)
一个大龄程序员的博客
03-12 864
最近在研究OBS源码，里面有一个很重要的模块是推流模块，OBS是使用RTMP进行推流的，源码里面也有RTMP的源码，翻了一下目前网上没有详细的RTMP源码注释，所以这里基于OBS项目，来详细讲一下RTMP源码包括内核数据结构、公共函数接口功能。关于具体的RTMP协议，网上有很多RTMP协议可以找到这里只做简单介绍，重点是代码的注释分析。关于RTMP源码的内核结构体，在代码中涉及的我会有标注，在另一个博文中具体分析了核心结构体注释。 接口比较多写的比较细，文章比较长，有些函数体中无效的代码（例如 log日志、
librtmp协议分析---RTMP_SendPacket函数
幽雨雨幽
05-25 1252
接下来我们分析RTMP_SendPacket函数。我们先了解一下rtmp的消息格式chunk。 RTMP的head组成 RTMP的head在协议中的表现形式是chunk head，前面已经说到一个Message + head可以分成一个和多个chunk，为了区分这些chunk，肯定是需要一个chunk head的，具体的实现就把Message  head的信息和chunk head的信
LibRTMP源代码分析8：发送消息(Send RTMPPacket)
huangmindong的专栏
05-22 2773
在详细分析函数RTMP_SendPacket()之前，让我们来看看RTMPPacket结构体的定义： typedef struct RTMPPacket {         uint8_t   m_headerType; // ChunkMsgHeader类型(4种)         uint8_t   m_packetType; // Message type ID（1-
RTMP_EnableWrite(rtmp)
weixin_30307921的博客
01-23 195
发布流关键函数： RTMP_EnableWrite(rtmp); 将rtmp设置可写状态,会发出publish指令,否则是play指令； 转载于:https://www.cnblogs.com/wainiwann/p/4243745.html
RTMP源码（未修改版）.zip
07-16
rtmpdump源码，用于RTMP功能实现支持。 tar -zxvf rtmpdump-2.3.tgz cd rtmpdump make 即可完成编译
librtmp 源码分析笔记 RTMP_SendPacket
lucyTheSlayer的博客
04-02 1026
接下来看一下librtmp最重要之一的函数 RTMP_SendPacket首先必须有一份rtmp文档在手配合源码阅读，点击打开链接顾名思义，即发送一个packet，这是rtmp协议逻辑上数据交互的基本单元（实际物理上还要分成chunk发送）。先看一下 RTMPPacket 的定义 typedef struct RTMPPacket { uint8_t m_headerType; ...
基于obs的rtmp源码分析之RTMP_Connect(rtmp连接)
一个大龄程序员的博客
03-12 1296
最近在研究OBS源码，里面有一个很重要的模块是推流模块，OBS是使用RTMP进行推流的，源码里面也有RTMP的源码，翻了一下目前网上没有详细的RTMP源码注释，所以这里基于OBS项目，来详细讲一下RTMP源码包括内核数据结构、公共函数接口功能。关于具体的RTMP协议，网上有很多RTMP协议可以找到这里只做简单介绍，重点是代码的注释分析。接口比较多写的比较细，耐心看哈哈哈。 这里所有的实际测试推流操作均为向斗鱼上推流（因为我一直用它看直播哈） RTMP协议是应用层协议，是要靠底层可靠的传输层协议（通常是TCP
librtmp 源码分析笔记 RTMP_ReadPacket
lucyTheSlayer的博客
04-02 2512
索性一口气把RTMP_ReadPacket也记录下来，好尽快开始对具体上层协议实现细节进行细读。与RTMP_SendPacket不同，RTMP_ReadPacket需要多次调用（每次读取一个chunk），并配合RTMPPacket_IsReady这个宏使用才能读取一个完整的RTMPPacket。大致如下：while（isPlaying &amp;&amp; RTMP_ReadPacket(r,&a...
rtmp视频拉流源代码
02-13
rtmp视频拉流源代码，上传了相应的源码和库文件，自己手动创建项目即可使用，已经编译运行成功。，很宝贵的资源，绝对经典，需要的可以下载哈！
RtmpServer 源代码
03-12
RtmpServer 源代码,内有VS2010工程，亲测可用
海思rtmp源码
09-20
海思平台hi3520的rtmp代码，有兴趣的朋友拿 去研究。
RTSP流转RTMP源码（官方资源）
04-04
rtsp转rtmp程序，从rtsp摄像机获取流，转换为rtmp push到服务器（官方资源）
librtmp源码
07-21
1 librtmp优化，并支持 chunksize发送 rtmp_->m_outChunkSize = 4096; rtmp_->m_bSendChunkSizeInfo = 1; 2 支持纯 ipv6 环境 ，跨平台支持
ffmpeg rtmp推流源码
08-07
一份可以直接将本地视频推送到服务器的推流源代码， 是学习推流的很好的资料， 代码基于ffmpeg rtmp推流， 采用nginx+rtmp module搭建本地流媒体服务器
rtmpdump代码简单分析
为了理想而奋斗
06-08 3337
第一步——握手（Hand Shake） 代码在 handshake.h文件中， 该文件中HandShake 函数是处理握手的。 第二 步-----建立连接NetConnection  在文件rtmp.cpp 中 RTMP_Connect()： 其内部调用了  RTMP_Connect0() 和  RTMP_Connect1()。 RTMP_Connect0() 主
Nginx RTMP源码分析--GOP的实现
xiaofeilong89的专栏
10-15 2123
nginx rtmp module的默认实现中，不支持gop缓存。我们可以自己进行开发，实现的主要原理是：当遇到关键帧时，清空旧的gop缓存并开始缓存新的帧数据；当play时，先将缓存的gop发送给对方，然后开始正常的发送的逻辑。 具体逻辑如下： （这里只列出了主要的流程，并不是全部的代码实现） 初始化 在ngx_rtmp_session_t增加gop相关的字段： typedef struct {...
生成一个qt下使用opencv 进行 rtmp推流 其中包含 rtmp_sendpacket 例程
最新发布
05-26
很高兴能为您提供帮助，以下是生成一个Qt下使用OpenCV进行rtmp推流的步骤和例程： 步骤： 1.安装OpenCV，可以从OpenCV官网下载对应的版本进行安装。 2.下载并安装FFmpeg，可以从FFmpeg官网下载对应的版本进行安装。 3.在Qt中配置OpenCV和FFmpeg，在项目.pro文件中添加以下代码： ``` INCLUDEPATH += [OpenCV的include目录] LIBS += -L[OpenCV的lib目录] -lopencv_core -lopencv_highgui -lopencv_imgproc -lopencv_videoio -lopencv_imgcodecs INCLUDEPATH += [FFmpeg的include目录] LIBS += -L[FFmpeg的lib目录] -lavcodec -lavdevice -lavfilter -lavformat -lavutil -lswresample -lswscale -lavcodec ``` 4.编写rtmp推流代码，示例代码如下： ``` #include <opencv2/opencv.hpp> #include <libavcodec/avcodec.h> #include <libavformat/avformat.h> #include <libavutil/opt.h> #include <libavutil/imgutils.h> #include <libswscale/swscale.h> #define STREAM_URL "rtmp://[推流地址]" using namespace cv; int main() { AVFormatContext *pFormatCtx; AVOutputFormat *fmt; AVStream *video_st; AVCodecContext *pCodecCtx; AVCodec *pCodec; AVFrame *pFrame, *pFrameRGB; uint8_t *buffer; int videoindex = -1; int framecnt = 0; int64_t start_time = 0; struct SwsContext *img_convert_ctx; // OpenCV读取视频文件 VideoCapture capture(0); if(!capture.isOpened()) { printf("OpenCV: Could not open camera.\n"); return -1; } // 初始化FFmpeg av_register_all(); // 初始化输出格式 avformat_alloc_output_context2(&pFormatCtx, NULL, "flv", STREAM_URL); if(!pFormatCtx) { printf("FFmpeg: Could not allocate output context.\n"); return -1; } fmt = pFormatCtx->oformat; // 添加视频流 video_st = avformat_new_stream(pFormatCtx, 0); if(!video_st) { printf("FFmpeg: Could not create new stream.\n"); return -1; } videoindex = video_st->index; // 设置编码器参数 pCodecCtx = video_st->codec; pCodecCtx->codec_id = fmt->video_codec; pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO; pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P; pCodecCtx->width = capture.get(CV_CAP_PROP_FRAME_WIDTH); pCodecCtx->height = capture.get(CV_CAP_PROP_FRAME_HEIGHT); pCodecCtx->time_base.num = 1; pCodecCtx->time_base.den = 25; // 查找编码器 pCodec = avcodec_find_encoder(pCodecCtx->codec_id); if(!pCodec) { printf("FFmpeg: Could not find encoder.\n"); return -1; } // 打开编码器 if(avcodec_open2(pCodecCtx, pCodec, NULL) < 0) { printf("FFmpeg: Could not open encoder.\n"); return -1; } // 分配视频帧内存 pFrame = av_frame_alloc(); pFrameRGB = av_frame_alloc(); // 分配视频帧缓冲区内存 int numBytes = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1); buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t)); av_image_fill_arrays(pFrame->data, pFrame->linesize, buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1); // 分配视频帧RGB缓冲区内存 uint8_t *rgbBuffer = (uint8_t *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1)); av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, rgbBuffer, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1); // 初始化图像转换上下文 img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL); // 输出格式信息 av_dump_format(pFormatCtx, 0, STREAM_URL, 1); // 打开输出URL if(!(fmt->flags & AVFMT_NOFILE)) { if(avio_open(&pFormatCtx->pb, STREAM_URL, AVIO_FLAG_WRITE) < 0) { printf("FFmpeg: Could not open output URL.\n"); return -1; } } // 写入头部 avformat_write_header(pFormatCtx, NULL); while(capture.read(pFrameRGB->data[0])) { // RGB转YUV sws_scale(img_convert_ctx, pFrameRGB->data, pFrameRGB->linesize, 0, pCodecCtx->height, pFrame->data, pFrame->linesize); // 视频帧时间 AVRational time_base = {1, 1000}; int64_t pts = framecnt * (pCodecCtx->time_base.den * 1000 / pCodecCtx->time_base.num) / 25; pFrame->pts = av_rescale_q(pts, time_base, video_st->time_base); pFrame->key_frame = 1; // 编码并推送视频帧 AVPacket pkt; int ret = avcodec_send_frame(pCodecCtx, pFrame); if(ret < 0) { printf("FFmpeg: Error sending frame.\n"); break; } while(ret >= 0) { ret = avcodec_receive_packet(pCodecCtx, &pkt); if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) { break; } else if(ret < 0) { printf("FFmpeg: Error encoding frame.\n"); return -1; } // 发送视频帧Packet av_packet_rescale_ts(&pkt, pCodecCtx->time_base, video_st->time_base); pkt.stream_index = videoindex; ret = av_interleaved_write_frame(pFormatCtx, &pkt); av_packet_unref(&pkt); } // 输出进度信息 printf("FFmpeg: Encode frame index:%d\n", framecnt); framecnt++; // 推流时间 if(start_time == 0) { start_time = av_gettime(); } int64_t now_time = av_gettime() - start_time; int64_t duration = framecnt * pCodecCtx->time_base.num * 1000 / pCodecCtx->time_base.den; if(now_time < duration) { av_usleep(duration - now_time); } } // 写入尾部 av_write_trailer(pFormatCtx); // 释放内存 avcodec_close(pCodecCtx); av_free(pCodecCtx); av_frame_free(&pFrame); av_frame_free(&pFrameRGB); av_free(buffer); av_free(rgbBuffer); avio_close(pFormatCtx->pb); avformat_free_context(pFormatCtx); return 0; } ``` 注：在实际使用中需要将[推流地址]替换为实际的地址。 这是一个简单的例程，仅供参考，具体实现方式还需要根据实际情况进行调整和完善。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值