流媒体协议.之（RTP，RTCP，RTSP，RTMP，HTTP）（二）

继续上篇介绍，本篇介绍一下封装RTP的数据格式，如何将摄像头采集的码流，音频的码流，封装到rtp里，传输。
有自己私有协议例子，有rtp协议，参考代码。注意不是rtsp协议。

一、私有协议

玩过tcp协议都知道，有这么一层关系

玩过网络开发的，应该都自己定义封装过私有协议。

我把tcp，udp，网络传输封装在另一个文件，网络传输层。然后分一个模块，私有协议，封装有效数据，数据封装层。

封装一个协议头

typedef struct MediumPrivateHead
{SX_U32 	u32Mf;SX_U16 	u16Type;SX_U32 	u32Ts;SX_U16 	u16Seqno;SX_U32 	u32Length;SX_U8 	u8Ch;SX_U8 	u8Of;SX_U8 	u8Marker;SX_U8 	u8X;
}T_MediumPrivateHead, *PT_MediumPrivateHead;
#pragma pack()typedef enum PacketType
{PACKET_TYPE_H264 = 118,PACKET_TYPE_JPEG = 119,PACKET_TYPE_AAC  = 120,PACKET_TYPE_G711 = 121,PACKET_TYPE_H265 = 122,PACKET_TYPE_ADPCM_DVI4 = 123,PACKET_TYPE_G721 = 124,PACKET_TYPE_RS422 = 125,PACKET_TYPE_BUTT = 126,
}E_PacketType;

分片发送，数据包太大，进行分包传输，不管是什么协议，都需要调用这个函数来分包传输，传入一个bufer数据指针。

static SX_U32 MEDIUM_UDP_WriteFrame1( SX_S32 ch, SX_S8 ePacketType, void *handle, SX_S8 *ps8Buffer, SX_U32 u32Length, SX_U64 u64Pts, SX_S8 *ps8TsString )
{PT_Medium ptTmp = (PT_Medium)handle;SX_U32 u32Pos = 0;SX_U32 u32LeftLen = u32Length;SX_S8 *ps8Tmp = ps8Buffer;int allow_send_max_len = 0;//if(ptTmp->u32FragmentLen < 300) // len too short//ptTmp->u32FragmentLen = 300;allow_send_max_len = ptTmp->u32FragmentLen - sizeof(T_MediumPrivateHead);if( u32LeftLen <= allow_send_max_len ){if( MEDIUM_UDP_WritePrivatePacket( ch, ePacketType, handle, ps8Tmp, u32LeftLen, u64Pts, 1, 0 ) < 0 )return 0;	}else{while( u32LeftLen > allow_send_max_len ){if( MEDIUM_UDP_WritePrivatePacket( ch, ePacketType, handle, ps8Tmp + u32Pos, allow_send_max_len, u64Pts, 0, 0 ) < 0 )return 0;u32LeftLen -= allow_send_max_len;u32Pos += allow_send_max_len;}if( MEDIUM_UDP_WritePrivatePacket( ch, ePacketType, handle, ps8Tmp + u32Pos, u32LeftLen, u64Pts, 1, 0 ) < 0 )return 0;}return u32Length;
}

封装私有协议包，供上面函数调用，如果是其他协议，就封装另一个函数。将有效数据和协议头封装，打包，通过udp或tcp的接口sendto发送出去

static SX_S32 MEDIUM_UDP_WritePrivatePacket( SX_S32 ch, SX_S8 ePacketType, void *handle, SX_S8 *ps8Buffer, SX_U32 u32Length, SX_U64 u64Pts, SX_U32 u32Marker, SX_U32 u32X )
{if(ch < 0 || ch >= MEDIUM_MAX_CH)return -1;SX_U32 u32Pos = 0;PT_Medium ptTmp 	= (PT_Medium)handle;pthread_mutex_lock( &ptTmp->mutex);SX_S8 *ps8Buf	= ptTmp->ps8Buffer;memset(ps8Buf ,0 ,MAX_CONFIG_FILE_LEN);SX_U32 u32myframeLen;if( u32Length > ptTmp->u32FragmentLen - sizeof(T_MediumPrivateHead))u32myframeLen = ptTmp->u32FragmentLen- sizeof(T_MediumPrivateHead);elseu32myframeLen = u32Length;//file private head	//PT_VedioDataPkt pkthead1 = (PT_VedioDataPkt)(ps8Buf);//PT_MediumPrivateHead ptHead2 = (PT_MediumPrivateHead)(&pkthead1->headprivate);PT_MediumPrivateHead ptHead2 = (PT_MediumPrivateHead)(ps8Buf);memset((SX_U8 *)ptHead2, 0, sizeof(T_MediumPrivateHead) );ptHead2->u32Mf 	            = (SX_U32)0x4b4e4148;ptHead2->u16Type           = (SX_U16)ePacketType;ptHead2->u32Ts 	            = (SX_U32)u64Pts;	//not usedptHead2->u16Seqno 	    = ((ePacketType ==  PACKET_TYPE_AAC )? (SX_U16)ptTmp->u16AudioSeqno[ch] : (SX_U16)ptTmp-  >u16VedioSeqno[ch]);ptHead2->u32Length        = (SX_U32)u32myframeLen;ptHead2->u8Ch 	            = (SX_U8)ch;ptHead2->u8Of 		    = (SX_U8)0x19;ptHead2->u8Marker 	    = (SX_U8)u32Marker;ptHead2->u8X 		    = (SX_U8)u32X;u32Pos 				    = sizeof(T_MediumPrivateHead);//filevedio frame datamemcpy( ps8Buf + u32Pos, ps8Buffer, u32myframeLen );//CRC32 	= 0xC4C3C2C1;*(ps8Buf + u32Pos + u32myframeLen + 0)= 0xC1;*(ps8Buf + u32Pos + u32myframeLen + 1)= 0xC2;*(ps8Buf + u32Pos + u32myframeLen + 2)= 0xC3;*(ps8Buf + u32Pos + u32myframeLen + 3)= 0xC4;if(ePacketType ==  PACKET_TYPE_AAC){//printf("++   u16AudioSeqno  %ld    u32Length  %ld ++\r\n",ptTmp->u16AudioSeqno[ch],sizeof(T_MediumPrivateHead) + ptHead2->u32Length + 4);ptTmp->u16AudioSeqno[ch]++;}else{ptTmp->u16VedioSeqno[ch]++;}if(ptTmp->u16AudioSeqno[ch] > 65536)ptTmp->u16AudioSeqno[ch] = 0;if(ptTmp->u16VedioSeqno[ch] > 65536)ptTmp->u16VedioSeqno[ch] = 0;
#endifpthread_mutex_unlock( &ptTmp->mutex);ts1 = get_sys_ms();if( sendto(ptTmp->fd,ps8Buf,sizeof(T_MediumPrivateHead) + u32myframeLen + 4,	//headlen + datalen + crclen,0,(struct sockaddr *)&ptTmp->other[(ePacketType ==  PACKET_TYPE_AAC) ? 1 : 0],sizeof(struct sockaddr_in)) < 0 )	            TRACE( DL_WARNING, "udp send failed\n" );return 0;
}

二、 RTP协议

RTP传输音视频过程如下：

如果不按我上面私有协议传输，那就需要封装一个RTP协议，要熟悉协议格式，进行封装。

RTP报文格式

用C语言来封装，如下

取一段抓包数据

三、RTP封装视频

3.1、RTP封装H264

首先看一下H264 NALU头部定义：一个字节，是8位，按位进行划分，代表的意义。

F: 1 个比特. 一般为0 forbidden_zero_bit. 在 H.264 规范中规定了这一位必须为 0.
NRI: 2 个比特. nal_ref_idc. 取 00 ~ 11, 指示nalu单元的重要性，, 如 00 的 NALU 解码器可以丢弃而不影响图像的回放. 不过一般情况下不太关心这个属性.
Type: 5 个比特.nal_unit_type. 这个 NALU 单元的类型.

RTP打包原则

RTP的包长度必须要小于MTU(最大传输单元)，IP协议中MTU的最大长度为1500字节。除去IP报头（20字节）、UDP报头（8字节）、RTP头（12字节），所有RTP有效载荷（即NALU内容）的长度不得超过1460字节。TCP(20字节)。上面我的例子代码有参考，分包。

RTP有三种封包模式：单一封包模式，组合封包模式，分片封包模式









这是我的协议，我所有的通信协议，都会加上这么一个起始头，用来区别本系统，发送的数据包开始字段




3.4、PES分组头部

可以看到RTP数据头，协议，非常多，没什么难度，就是多，一般我们都不会从新造轮子，网上很多大佬，开源分享，移植过来，修改就OK了，下篇，直接贴代码，封装协议，要老命，自己去手撸出来，手撸linux内核代码没必要。

找到一个博主封装的h264，封包，解包

RTP荷载H264的代码参考：
http://blog.csdn.net/dengzikun/article/details/5807694

RTP荷载PS流的代码参考：

http://www.pudn.com/downloads33/sourcecode/windows/multimedia/detail105823.html
http://www.oschina.net/code/snippet_99626_23737

这是他说的
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  

四、推拉流测试

另一个博主封装了一个推拉流的demo，可以移植到项目中，对h264，aac，感谢博主的热心分享。
他用FFmpeg去对一个事先准备好的mp4文件，读取流，然后通过RTSP协议，推流到一个文件夹，然后写了个客户端，rtsp，拉流，播放。
如果我么要移植到ipc项目中，这里需要修改一下，将soc采集到的视频流，放到rtp包里，去掉FFmpeg解码，也不需要移植FFmpeg。

原文链接：https://blog.csdn.net/weixin_43147845/article/details/140923649

地址：https://github.com/BreakingY/simple-rtsp-client

1、准备

simple-rtsp-server依赖ffmpeg，版本要求>=4.x。支持系统：Linux

依赖安装：

sudo apt-get -y install autoconf automake build-essential libass-dev libfreetype6-dev libsdl2-dev libtheora-dev libtool libva-dev libvdpau-dev libvorbis-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev pkg-config texinfo zlib1g-dev

汇编库：

sudo apt-get install yasm
sudo apt-get install nasm

视频库：

sudo apt-get install libx264-dev
sudo apt-get install libx265-dev

音频库：

sudo apt-get install libfdk-aac-dev
sudo apt-get install libmp3lame-dev
sudo apt-get install libopus-dev

ffmpeg源码下载：

wget https://ffmpeg.org//releases/ffmpeg-4.0.5.tar.bz2

tar xjvf ffmpeg-4.0.5.tar.bz2

cd ffmpeg-4.0.5

编译安装：

./configure --prefix=/usr/local --enable-libx264 --disable-x86asm --enable-nonfree --enable-libfdk-aac  --enable-shared --enable-gpl --enable-libmp3lame --enable-libopus  --extra-cflags=-I/usr/local/include --extra-ldflags=-L/usr/local/libmakemake install

2、simple-rtsp-server下载编译
下载后

cd simple-rtsp-servermkdir buildcd buildcmake ..make -j

3、运行

cp -r ../mp4path ../rtsp_server 0 (0-不鉴权；1-鉴权)

4、拉流测试
项目中mp4path自带了测试文件，后面把想回放的视频放到mp4path中即可

TCP拉流：

ffmpeg -rtsp_transport tcp -i "rtsp://192.168.10.17:8554/test_h264_aac.mp4" -vcodec copy -acodec copy  test_h264_aac_tcp.mp4

UDP拉流：

ffmpeg -i "rtsp://192.168.10.17:8554/test_h264_aac.mp4" -vcodec copy -acodec copy  test_h264_aac_udp.mp4

也可通过VLC直接播放，点击媒体->打开网络串流，输入rtsp地址即可。默认是udp拉流，要使用TCP需要打开工具->偏好设置->输入/编解码器，拉到最下方，选择“RTP over RTSP（TCP）”

他也写了一个客户端拉流，不用上面测试命令FFmpeg

二、RTSP Client实战项目

地址：https://github.com/BreakingY/simple-rtsp-client

支持RTP OVER UDP、RTP OVER TCP，支持H264/H265、AAC/PCMA、支持鉴权。

不需要任何依赖。

1、下载后编译

mkdir buildcd buildcmake ..make -j

2、测试
./rtsp_client rtsp_url

客户端会把收到的音视频写入文件，H264/H265写入到test_out.h26x，AAC写入到test_out.aac，PCMA写入到test_out.pcma。

另一个比较厉害的，比较全
https://github.com/ireader/media-server