基于RTP的H264视频数据打包解包类

最新推荐文章于 2021-03-19 08:07:23 发布
最新推荐文章于 2021-03-19 08:07:23 发布
阅读量2.2k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adrian169/article/details/10076245
版权

http://blog.csdn.net/dengzikun/article/details/5807694

  最近考虑使用RTP替换原有的高清视频传输协议，遂上网查找有关H264视频RTP打包、解包的文档和代码。功夫不负有心人，找到不少有价值的文档和代码。参考这些资料，写了H264 RTP打包类、解包类，实现了单个NAL单元包和FU_A分片单元包。对于丢包处理，采用简单的策略：丢弃随后的所有数据包，直到收到关键帧。测试效果还不错，代码贴上来，若能为同道中人借鉴一二，足矣。两个类的使用说明如下(省略了错误处理过程)：

 DWORD H264SSRC ;
 CH264_RTP_PACK pack ( H264SSRC ) ;
 BYTE *pVideoData ;
 DWORD Size, ts ;
 bool IsEndOfFrame ;
 WORD wLen ;
 pack.Set ( pVideoData, Size, ts, IsEndOfFrame ) ;
 BYTE *pPacket ;
 while ( pPacket = pack.Get ( &wLen ) )
 {
  // rtp packet process
  // ...
 }


 HRESULT hr ;
 CH264_RTP_UNPACK unpack ( hr ) ;
 BYTE *pRtpData ;
 WORD inSize;
 int outSize ;
 BYTE *pFrame = unpack.Parse_RTP_Packet ( pRtpData, inSize, &outSize ) ;
 if ( pFrame != NULL )
 {
  // frame process
  // ...
 }

//
// class CH264_RTP_PACK start

class CH264_RTP_PACK
{
	#define RTP_VERSION 2

	typedef struct NAL_msg_s 
	{
		bool eoFrame ;
		unsigned char type;		// NAL type
		unsigned char *start;	// pointer to first location in the send buffer
		unsigned char *end;	// pointer to last location in send buffer
		unsigned long size ;
	} NAL_MSG_t;

	typedef struct 
	{
		//LITTLE_ENDIAN
		unsigned short   cc:4;		/* CSRC count                 */
		unsigned short   x:1;		/* header extension flag      */
		unsigned short   p:1;		/* padding flag               */
		unsigned short   v:2;		/* packet type                */
		unsigned short   pt:7;		/* payload type               */
		unsigned short   m:1;		/* marker bit                 */

		unsigned short    seq;		/* sequence number            */
		unsigned long     ts;		/* timestamp                  */
		unsigned long     ssrc;		/* synchronization source     */
	} rtp_hdr_t;

	typedef struct tagRTP_INFO
	{
		NAL_MSG_t	nal;	    // NAL information
		rtp_hdr_t	rtp_hdr;    // RTP header is assembled here
		int hdr_len;			// length of RTP header

		unsigned char *pRTP;    // pointer to where RTP packet has beem assembled
		unsigned char *start;	// pointer to start of payload
		unsigned char *end;		// pointer to end of payload

		unsigned int s_bit;		// bit in the FU header
		unsigned int e_bit;		// bit in the FU header
		bool FU_flag;		// fragmented NAL Unit flag
	} RTP_INFO;

public:
	CH264_RTP_PACK(unsigned long H264SSRC, unsigned char H264PAYLOADTYPE=96, unsigned short MAXRTPPACKSIZE=1472 )
	{
		m_MAXRTPPACKSIZE = MAXRTPPACKSIZE ;
		if ( m_MAXRTPPACKSIZE > 10000 )
		{
			m_MAXRTPPACKSIZE = 10000 ;
		}
		if ( m_MAXRTPPACKSIZE < 50 )
		{
			m_MAXRTPPACKSIZE = 50 ;
		}
		
		memset ( &m_RTP_Info, 0, sizeof(m_RTP_Info) ) ;

		m_RTP_Info.rtp_hdr.pt = H264PAYLOADTYPE ;
		m_RTP_Info.rtp_hdr.ssrc = H264SSRC ;
		m_RTP_Info.rtp_hdr.v = RTP_VERSION ;

		m_RTP_Info.rtp_hdr.seq = 0 ;
	}

	~CH264_RTP_PACK(void)
	{
	}

	//传入Set的数据必须是一个完整的NAL,起始码为0x00000001。
	//起始码之前至少预留10个字节，以避免内存COPY操作。
	//打包完成后，原缓冲区内的数据被破坏。
	bool Set ( unsigned char *NAL_Buf, unsigned long NAL_Size, unsigned long Time_Stamp, bool End_Of_Frame )
	{
		unsigned long startcode = StartCode(NAL_Buf) ;
		
		if ( startcode != 0x01000000 )
		{
			return false ;
		}

		int type = NAL_Buf[4] & 0x1f ;
		if ( type < 1 || type > 12 )
		{
			return false ;
		}

		m_RTP_Info.nal.start = NAL_Buf ;
		m_RTP_Info.nal.size = NAL_Size ;
		m_RTP_Info.nal.eoFrame = End_Of_Frame ;
		m_RTP_Info.nal.type = m_RTP_Info.nal.start[4] ;
		m_RTP_Info.nal.end = m_RTP_Info.nal.start + m_RTP_Info.nal.size ;

		m_RTP_Info.rtp_hdr.ts = Time_Stamp ;

		m_RTP_Info.nal.start += 4 ;	// skip the syncword
									
		if ( (m_RTP_Info.nal.size + 7) > m_MAXRTPPACKSIZE )
		{
			m_RTP_Info.FU_flag = true ;
			m_RTP_Info.s_bit = 1 ;
			m_RTP_Info.e_bit = 0 ;

			m_RTP_Info.nal.start += 1 ;	// skip NAL header
		}
		else
		{
			m_RTP_Info.FU_flag = false ;
			m_RTP_Info.s_bit = m_RTP_Info.e_bit = 0 ;
		}
		
		m_RTP_Info.start = m_RTP_Info.end = m_RTP_Info.nal.start ;
		m_bBeginNAL = true ;

		return true ;
	}

	//循环调用Get获取RTP包，直到返回值为NULL
	unsigned char* Get ( unsigned short *pPacketSize )
	{
		if ( m_RTP_Info.end == m_RTP_Info.nal.end )
		{
			*pPacketSize = 0 ;
			return NULL ;
		}

		if ( m_bBeginNAL )
		{
			m_bBeginNAL = false ;
		}
		else
		{
			m_RTP_Info.start = m_RTP_Info.end;	// continue with the next RTP-FU packet
		}

		int bytesLeft = m_RTP_Info.nal.end - m_RTP_Info.start ;
		int maxSize = m_MAXRTPPACKSIZE - 12 ;	// sizeof(basic rtp header) == 12 bytes
		if ( m_RTP_Info.FU_flag )
			maxSize -= 2 ;

		if ( bytesLeft > maxSize )
		{
			m_RTP_Info.end = m_RTP_Info.start + maxSize ;	// limit RTP packetsize to 1472 bytes
		}
		else
		{
			m_RTP_Info.end = m_RTP_Info.start + bytesLeft ;
		}

		if ( m_RTP_Info.FU_flag )
		{	// multiple packet NAL slice
			if ( m_RTP_Info.end == m_RTP_Info.nal.end )
			{
				m_RTP_Info.e_bit = 1 ;
			}
		}

		m_RTP_Info.rtp_hdr.m =	m_RTP_Info.nal.eoFrame ? 1 : 0 ; // should be set at EofFrame
		if ( m_RTP_Info.FU_flag && !m_RTP_Info.e_bit )
		{
			m_RTP_Info.rtp_hdr.m = 0 ;
		}

		m_RTP_Info.rtp_hdr.seq++ ;

		unsigned char *cp = m_RTP_Info.start ;
		cp -= ( m_RTP_Info.FU_flag ? 14 : 12 ) ;
		m_RTP_Info.pRTP = cp ;
		
		unsigned char *cp2 = (unsigned char *)&m_RTP_Info.rtp_hdr ;
		cp[0] = cp2[0] ;
		cp[1] = cp2[1] ;

		cp[2] = ( m_RTP_Info.rtp_hdr.seq >> 8 ) & 0xff ;
		cp[3] = m_RTP_Info.rtp_hdr.seq & 0xff ;

		cp[4] = ( m_RTP_Info.rtp_hdr.ts >> 24 ) & 0xff ;
		cp[5] = ( m_RTP_Info.rtp_hdr.ts >> 16 ) & 0xff ;
		cp[6] = ( m_RTP_Info.rtp_hdr.ts >>  8 ) & 0xff ;
		cp[7] = m_RTP_Info.rtp_hdr.ts & 0xff ;

		cp[8] =  ( m_RTP_Info.rtp_hdr.ssrc >> 24 ) & 0xff ;
		cp[9] =  ( m_RTP_Info.rtp_hdr.ssrc >> 16 ) & 0xff ;
		cp[10] = ( m_RTP_Info.rtp_hdr.ssrc >>  8 ) & 0xff ;
		cp[11] = m_RTP_Info.rtp_hdr.ssrc & 0xff ;
		m_RTP_Info.hdr_len = 12 ;
		/*!
		* /n The FU indicator octet has the following format:
		* /n
		* /n      +---------------+
		* /n MSB  |0|1|2|3|4|5|6|7|  LSB
		* /n      +-+-+-+-+-+-+-+-+
		* /n      |F|NRI|  Type   |
		* /n      +---------------+
		* /n
		* /n The FU header has the following format:
		* /n
		* /n      +---------------+
		* /n      |0|1|2|3|4|5|6|7|
		* /n      +-+-+-+-+-+-+-+-+
		* /n      |S|E|R|  Type   |
		* /n      +---------------+
		*/
		if ( m_RTP_Info.FU_flag )
		{
			// FU indicator  F|NRI|Type
			cp[12] = ( m_RTP_Info.nal.type & 0xe0 ) | 28 ;	//Type is 28 for FU_A
			//FU header		S|E|R|Type
			cp[13] = ( m_RTP_Info.s_bit << 7 ) | ( m_RTP_Info.e_bit << 6 ) | ( m_RTP_Info.nal.type & 0x1f ) ; //R = 0, must be ignored by receiver

			m_RTP_Info.s_bit = m_RTP_Info.e_bit= 0 ;
			m_RTP_Info.hdr_len = 14 ;
		}
		m_RTP_Info.start = &cp[m_RTP_Info.hdr_len] ;	// new start of payload

		*pPacketSize = m_RTP_Info.hdr_len + ( m_RTP_Info.end - m_RTP_Info.start ) ;
		return m_RTP_Info.pRTP ;
	}

private:
	unsigned int StartCode( unsigned char *cp )
	{
		unsigned int d32 ;
		d32 = cp[3] ;
		d32 <<= 8 ;
		d32 |= cp[2] ;
		d32 <<= 8 ;
		d32 |= cp[1] ;
		d32 <<= 8 ;
		d32 |= cp[0] ;
		return d32 ;
	}

private:
	RTP_INFO m_RTP_Info ;
	bool m_bBeginNAL ;
	unsigned short m_MAXRTPPACKSIZE ;
};

// class CH264_RTP_PACK end
//


//
// class CH264_RTP_UNPACK start

class CH264_RTP_UNPACK
{

#define RTP_VERSION 2
#define BUF_SIZE (1024 * 500)

	typedef struct 
	{
		//LITTLE_ENDIAN
		unsigned short   cc:4;		/* CSRC count                 */
		unsigned short   x:1;		/* header extension flag      */
		unsigned short   p:1;		/* padding flag               */
		unsigned short   v:2;		/* packet type                */
		unsigned short   pt:7;		/* payload type               */
		unsigned short   m:1;		/* marker bit                 */

		unsigned short    seq;		/* sequence number            */
		unsigned long     ts;		/* timestamp                  */
		unsigned long     ssrc;		/* synchronization source     */
	} rtp_hdr_t;
public:

	CH264_RTP_UNPACK ( HRESULT &hr, unsigned char H264PAYLOADTYPE = 96 )
		: m_bSPSFound(false)
		, m_bWaitKeyFrame(true)
		, m_bPrevFrameEnd(false)
		, m_bAssemblingFrame(false)
		, m_wSeq(1234)
		, m_ssrc(0)
	{
		m_pBuf = new BYTE[BUF_SIZE] ;
		if ( m_pBuf == NULL )
		{
			hr = E_OUTOFMEMORY ;
			return ;
		}

		m_H264PAYLOADTYPE = H264PAYLOADTYPE ;
		m_pEnd = m_pBuf + BUF_SIZE ;
		m_pStart = m_pBuf ;
		m_dwSize = 0 ;
		hr = S_OK ;
	}

	~CH264_RTP_UNPACK(void)
	{
		delete [] m_pBuf ;
	}

	//pBuf为H264 RTP视频数据包，nSize为RTP视频数据包字节长度，outSize为输出视频数据帧字节长度。
	//返回值为指向视频数据帧的指针。输入数据可能被破坏。
	BYTE* Parse_RTP_Packet ( BYTE *pBuf, unsigned short nSize, int *outSize )
	{
		if ( nSize <= 12 )
		{
			return NULL ;
		}

		BYTE *cp = (BYTE*)&m_RTP_Header ;
		cp[0] = pBuf[0] ;
		cp[1] = pBuf[1] ;

		m_RTP_Header.seq = pBuf[2] ;
		m_RTP_Header.seq <<= 8 ;
		m_RTP_Header.seq |= pBuf[3] ;

		m_RTP_Header.ts = pBuf[4] ;
		m_RTP_Header.ts <<= 8 ;
		m_RTP_Header.ts |= pBuf[5] ;
		m_RTP_Header.ts <<= 8 ;
		m_RTP_Header.ts |= pBuf[6] ;
		m_RTP_Header.ts <<= 8 ;
		m_RTP_Header.ts |= pBuf[7] ;

		m_RTP_Header.ssrc = pBuf[8] ;
		m_RTP_Header.ssrc <<= 8 ;
		m_RTP_Header.ssrc |= pBuf[9] ;
		m_RTP_Header.ssrc <<= 8 ;
		m_RTP_Header.ssrc |= pBuf[10] ;
		m_RTP_Header.ssrc <<= 8 ;
		m_RTP_Header.ssrc |= pBuf[11] ;

		BYTE *pPayload = pBuf + 12 ;
		DWORD PayloadSize = nSize - 12 ;

		// Check the RTP version number (it should be 2):
		if ( m_RTP_Header.v != RTP_VERSION )
		{
			return NULL ;
		}

		/*
		// Skip over any CSRC identifiers in the header:
		if ( m_RTP_Header.cc )
		{
			long cc = m_RTP_Header.cc * 4 ;
			if ( Size < cc )
			{
				return NULL ;
			}

			Size -= cc ;
			p += cc ;
		}

		// Check for (& ignore) any RTP header extension
		if ( m_RTP_Header.x )
		{
			if ( Size < 4 )
			{
				return NULL ;
			}

			Size -= 4 ;
			p += 2 ;
			long l = p[0] ;
			l <<= 8 ;
			l |= p[1] ;
			p += 2 ;
			l *= 4 ;
			if ( Size < l ) ;
			{
				return NULL ;
			}
			Size -= l ;
			p += l ;
		}
		
		// Discard any padding bytes:
		if ( m_RTP_Header.p )
		{
			if ( Size == 0 )
			{
				return NULL ;
			}
			long Padding = p[Size-1] ;
			if ( Size < Padding )
			{
				return NULL ;
			}
			Size -= Padding ;
		}*/

		// Check the Payload Type.
		if ( m_RTP_Header.pt != m_H264PAYLOADTYPE )
		{
			return NULL ;
		}

		int PayloadType = pPayload[0] & 0x1f ;
		int NALType = PayloadType ;
		if ( NALType == 28 ) // FU_A
		{
			if ( PayloadSize < 2 )
			{
				return NULL ;
			}

			NALType = pPayload[1] & 0x1f ;
		}

		if ( m_ssrc != m_RTP_Header.ssrc )
		{
			m_ssrc = m_RTP_Header.ssrc ;
			SetLostPacket () ;
		}
	
		if ( NALType == 0x07 ) // SPS
		{
			m_bSPSFound = true ;
		}

		if ( !m_bSPSFound )
		{
			return NULL ;
		}

		if ( NALType == 0x07 || NALType == 0x08 ) // SPS PPS
		{
			m_wSeq = m_RTP_Header.seq ;
			m_bPrevFrameEnd = true ;

			pPayload -= 4 ;
			*((DWORD*)(pPayload)) = 0x01000000 ;
			*outSize = PayloadSize + 4 ;
			return pPayload ;
		}

		if ( m_bWaitKeyFrame )
		{
			if ( m_RTP_Header.m ) // frame end
			{
				m_bPrevFrameEnd = true ;
				if ( !m_bAssemblingFrame )
				{
					m_wSeq = m_RTP_Header.seq ;
					return NULL ;
				}
			}

			if ( !m_bPrevFrameEnd )
			{
				m_wSeq = m_RTP_Header.seq ;
				return NULL ;
			}
			else
			{
				if ( NALType != 0x05 ) // KEY FRAME
				{
					m_wSeq = m_RTP_Header.seq ;
					m_bPrevFrameEnd = false ;
					return NULL ;
				}
			}
		}


///
			
		if ( m_RTP_Header.seq != (WORD)( m_wSeq + 1 ) ) // lost packet
		{
			m_wSeq = m_RTP_Header.seq ;
			SetLostPacket () ;			
			return NULL ;
		}
		else
		{
			// 码流正常

			m_wSeq = m_RTP_Header.seq ;
			m_bAssemblingFrame = true ;
			
			if ( PayloadType != 28 ) // whole NAL
			{
				*((DWORD*)(m_pStart)) = 0x01000000 ;
				m_pStart += 4 ;
				m_dwSize += 4 ;
			}
			else // FU_A
			{
				if ( pPayload[1] & 0x80 ) // FU_A start
				{
					*((DWORD*)(m_pStart)) = 0x01000000 ;
					m_pStart += 4 ;
					m_dwSize += 4 ;

					pPayload[1] = ( pPayload[0] & 0xE0 ) | NALType ;
					
					pPayload += 1 ;
					PayloadSize -= 1 ;
				}
				else
				{
					pPayload += 2 ;
					PayloadSize -= 2 ;
				}
			}

			if ( m_pStart + PayloadSize < m_pEnd )
			{
				CopyMemory ( m_pStart, pPayload, PayloadSize ) ;
				m_dwSize += PayloadSize ;
				m_pStart += PayloadSize ;
			}
			else // memory overflow
			{
				SetLostPacket () ;
				return NULL ;
			}

			if ( m_RTP_Header.m ) // frame end
			{
				*outSize = m_dwSize ;

				m_pStart = m_pBuf ;
				m_dwSize = 0 ;

				if ( NALType == 0x05 ) // KEY FRAME
				{
					m_bWaitKeyFrame = false ;
				}
				return m_pBuf ;
			}
			else
			{
				return NULL ;
			}
		}
	}

	void SetLostPacket()
	{
		m_bSPSFound = false ;
		m_bWaitKeyFrame = true ;
		m_bPrevFrameEnd = false ;
		m_bAssemblingFrame = false ;
		m_pStart = m_pBuf ;
		m_dwSize = 0 ;
	}

private:
	rtp_hdr_t m_RTP_Header ;

	BYTE *m_pBuf ;

	bool m_bSPSFound ;
	bool m_bWaitKeyFrame ;
	bool m_bAssemblingFrame ;
	bool m_bPrevFrameEnd ;
	BYTE *m_pStart ;
	BYTE *m_pEnd ;
	DWORD m_dwSize ;

	WORD m_wSeq ;

	BYTE m_H264PAYLOADTYPE ;
	DWORD m_ssrc ;
};

// class CH264_RTP_UNPACK end
//



非常感谢谢！！！基于时间戳这一块，困扰我大半个月。。目前圆满解决。我采用的方式跟你的类似，再次谢谢您。
memcpy(dst, nal[0].p_payload, i_frame_size);

if (count > 1) {
struct timeval now;
gettimeofday(&now, NULL);
double val = (now.tv_sec - firstTime.tv_sec) +
(now.tv_usec - firstTime.tv_usec) / 1000000.0;
ts_current= ts_current + val * 90000.0 + 0.5;
firstTime = now;
}
else {
ts_current= 0;
gettimeofday(&firstTime, NULL);
}
count ++;



rtp_newbie 发表于 2013-3-8 15:29:16

时间戳：

class RTP_Timestamp
{
public:

RTP_Timestamp(DWORD unit)
: m_dwUnit(unit)
{
QueryPerformanceFrequency ( (LARGE_INTEGER*)&m_Freq ) ;
}

~RTP_Timestamp(void)
{
}

DWORD GetTime ()
{
__int64 current ;
QueryPerformanceCounter ( (LARGE_INTEGER*)&current ) ;
DWORD ts = current * m_dwUnit / m_Freq ;
return ts ;
}

private:
DWORD m_dwUnit ;
__int64 m_Freq ;
};



RTP_Timestamp TS ( 90000 ) ;
每一帧调用TS.GetTime()获取时间戳。

rtp_newbie 发表于 2013-3-8 15:30:40

另一个版本的时间戳：

memcpy(dst, nal.p_payload, i_frame_size);

if (count > 1) {
struct timeval now;
gettimeofday(&now, NULL);
double val = (now.tv_sec - firstTime.tv_sec) +
(now.tv_usec - firstTime.tv_usec) / 1000000.0;
ts_current= ts_current + val * 90000.0 + 0.5;
firstTime = now;
}
else {
ts_current= 0;
gettimeofday(&firstTime, NULL);
}
count ++; 



http://bbs.rosoo.net/archiver/tid-14972.html



惜海
关注
【FFMPEG】基于RTP的H264视频数据打包解包类
ZhangPY的专栏
04-03 3833
最近考虑使用RTP替换原有的高清视频传输协议，遂上网查找有关H264视频RTP打包、解包的文档和代码。功夫不负有心人，找到不少有价值的文档和代码。参考这些资料，写了H264 RTP打包类、解包类，实现了单个NAL单元包和FU_A分片单元包。对于丢包处理，采用简单的策略：丢弃随后的所有数据包，直到收到关键帧。测试效果还不错，代码贴上来，若能为同道中人借鉴一二，足矣。两个类的使用说明如下(省略了错误处
java h264 rtp_H264 RTP包解析
weixin_42511879的博客
02-16 1441
1. 预备视频：由一副副连续的图像构成，由于数据量比较大，因此为了节省带宽以及存储，就需要进行必要的压缩与解压缩，也就是编解码。h264裸码流：对一个图像或者一个视频序列进行压缩，即产生码流，采用H264编码后形成的码流就是h264裸码流。码流传输：发送端将H264裸码流打包后进行网络传输，接收端接收后进行组包还原裸码流，然后可以再进行存储，转发，或者播放等等相关的处理。存储转发可以直接使用裸码...
（转）基于RTP的H264视频数据打包解包类
weixin_30496431的博客
04-30 88
最近考虑使用RTP替换原有的高清视频传输协议，遂上网查找有关H264视频RTP打包、解包的文档和代码。功夫不负有心人，找到不少有价值的文档和代码。参考这些资料，写了H264 RTP打包类、解包类，实现了单个NAL单元包和FU_A分片单元包。对于丢包处理，采用简单的策略：丢弃随后的所有数据包，直到收到关键帧。测试效果还不错，代码贴上来，若能为同道中人借鉴一二，足矣。两个类的使用说明如下(...
RTP如何打包H264数据
maikforever 的专栏
05-17 1694
<br />拿到H264的裸流数据是，一般码流结构是SPS，PPS，I帧，P帧......SPS，PPS，I帧,P帧...........。用RTP打包H264数据时，SPS和PPS可以不发，直接发I帧和P帧数据即可。还要看I帧和P帧有多大，如果小于MTU就直接加RTP包发送就可以，如果大于MTU就得分片了。具体的分片方法可以参考RFC3984中。<br />　　我用的FU-A，分片方式。<br />　　第一个 FU-A 包的 FU indicator 应该是：F = NALU 头中的 F；NRI = NA
rtp 解包h264
lunan515的博客
10-30 505
修改自vc下的程序，跟打包相反，原理就是从udp接收一个数据包，判断这个数据包是单个发送还是分片发送，进而获取rtp包中的h264NAL数据，并加上0x00000001起始字节一并写进文件中即可。 [cpp] view plaincopy #include &lt;stdio.h&gt;       #include &lt;stdlib.h&gt;       #include &l...
H264 rtp封包解包
sunmeiwei0209的博客
11-18 641
RTP数据包格式 RTP报文头格式（见RFC3550 Page12）： 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 12 3 4 5 6 7 8 9 0 1 ±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±+ |V=2|P|X| CC |M| PT | sequence number | ±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±+ | .
rtp.rar_264 rtp_h.264 rtp _rtp_rtp 264_rtp包
09-20
描述提到“基于H.264的RTP程序包，具有参考价值”，这表明这是一个用于在实时通信中传输H.264视频流的软件开发资源，可能包括源代码、头文件或其他辅助资料。 RTP是一种网络协议，常用于实时音视频传输，如VoIP、...
RTP 协议解包为 H264 裸流
pang_gua的博客
01-24 4794
RTP 协议解包为 H264裸流 一. 为什么使用 RTP 协议？ TCP 传输流媒体数据由于其可靠性，会造成很大的网络延时和卡顿。 UDP 传输由于其不可靠性，会导致丢帧，如果是关键帧，则会花屏一个序列的时长。 RTP 使用了 RTP 和 RTCP 两个子协议来完成。 RTP 使用 UDP 完成流媒体数据传输，保证其时效性。 RTCP 也是使用 UDP，但只传输控制信息，占带宽很小，此时上层...
rtsp rtp h264 数据包
08-16
https://blog.csdn.net/engineer_james/article/details/81743571 配合分析 用来学习，rtsp rtp的dump文件，已经在wireshark 中分类，用wireshark打开
RTP资料大收集——RTP协议，H264负载格式，源码，流媒体，JRTP
08-23
这是我在研究RTP传输264基本流的过程中收集的资料，资料很多，包含了RTP协议，H264负载格式，源码，流媒体，JRTP等等相关的东西，希望对研究RTP的人提供帮助。
H264码流结构及其RTP封装介绍
11-20
详细讲解了H264视频流的码流结构，以及在RTSP实时传输中使用RTP来封装H264实时流的方法，附带RFC3984协议中文版，对于开发RTSP有很大帮助。
接收RTP包保存为h264文件
02-24
接收RTP包保存为h264文件
从pcap文件的rtp包中提取264码流并保存（c语言）202087rtph264.rar
08-07
从pcap文件的rtp包中提取264码流并保存,用udp传输的rtp包，解析了pcap文件，并且发布同名博客介绍这个小程序，主要介绍rtp包数据的提取，需要用自己的pcap文件和src端口号运行程序，记得修改
H264拆包解包参考代码 RTP
jimmywangyue的专栏
06-29 4676
可以通过生成SDP文件给播放器在指定端口接收数据播放,如果你不用动态调整编码器什么的就不用考虑另外发送RTCP. 而且RTCP必须自己实现RTSP服务结合起来用,没有实现RTSP服务,就谈不上实现RTCP. 具体H264字节流拆包和RTP封包方法如下 UINT MediaStreamH264::TransportData(PBYTE pData, UINT dataSize, int pts)
RTP协议解析和H264码流提取
ws1296931325的博客
03-19 297
https://blog.csdn.net/davebobo/article/details/52994596
从RTP包里面得到H264视频数据的方法
sunxiaopengsun的专栏
07-05 2151
// 功能：解码RTP H.264视频 // 参数：1.RTP包缓冲地址 2.RTP包数据大小 3.H264输出地址 4.输出数据大小 // 返回：true:表示一帧结束 false:FU-A分片未结束或帧未结束 #define RTP_HEADLEN 12 bool UnpackRTPH264( void * bufIn, int len, void ** p...
RTP_h264解包源码
hrbeuwhw的专栏
11-01 5756
//// class CH264_RTP_UNPACK  class CH264_RTP_UNPACK  {    #define RTP_VERSION 2  #define BUF_SIZE (1024 * 500)        typedef struct      {          //LITTLE_ENDIAN          unsigned short
RTP_h264解包类分析与代码实现
本文档主要讨论的是一个名为"CH264_RTP_UNPACK"的类，用于解析和解包H.264 (MPEG-4 Part 10) 的Real-time Transport Protocol (RTP) 数据包。RTP是一种网络传输协议，常用于实时音视频通信，如视频会议和在线流媒体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值