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

最近考虑使用RTP替换原有的高清视频传输协议，遂上网查找有关H264视频RTP打包、解包的文档和代码。功夫不负有心人，找到不少有价值的文档和代码。参考这些资料，写了H264RTP打包类、解包类，实现了单个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;
 WORDinSize;
 int outSize;
 BYTE *pFrame =unpack.Parse_RTP_Packet ( pRtpData, inSize,&outSize ) ;
 if ( pFrame !=NULL )
 {
  // frameprocess
  //...
 }

 // class CH264_RTP_PACK start

class CH264_RTP_PACK
{
    #defineRTP_VERSION 2

    typedefstruct NAL_msg_s
    {
      bool eoFrame ;
      unsigned chartype;      // 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;

    typedefstruct
    {
      //LITTLE_ENDIAN
      unsignedshort  cc:4;      
      unsignedshort  x:1;      
      unsignedshort  p:1;      
      unsignedshort  v:2;      
      unsignedshort  pt:7;      
      unsignedshort  m:1;      

      unsignedshort   seq;      
      unsignedlong    ts;      
      unsignedlong    ssrc;      
    }rtp_hdr_t;

    typedefstruct 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 ints_bit;      // bit in the FU header
      unsigned inte_bit;      // bit in the FU header
      bool FU_flag;      // fragmented NAL Unit flag
    }RTP_INFO;

public:
   CH264_RTP_PACK(unsigned long H264SSRC, unsignedchar 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 longTime_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 thesyncword
                           
      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 NALheader
      }
      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
    unsignedchar* 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;    // limitRTP 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 setat 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 ;
      
      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 byreceiver

         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];    // newstart of payload

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

private:
    unsigned intStartCode( 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_INFOm_RTP_Info ;
    boolm_bBeginNAL ;
    unsignedshort 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)

    typedefstruct
    {
      //LITTLE_ENDIAN
      unsignedshort  cc:4;      
      unsignedshort  x:1;      
      unsignedshort  p:1;      
      unsignedshort  v:2;      
      unsignedshort  pt:7;      
      unsignedshort  m:1;      

      unsignedshort   seq;      
      unsignedlong    ts;      
      unsignedlong    ssrc;      
    }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为H264RTP视频数据包，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 be2):
      if ( m_RTP_Header.v != RTP_VERSION )
      {
         return NULL ;
      }

      

      // 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 ) // SPSPPS
      {
         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_Astart
            {
               *((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 ;
         }
      }
    }

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

private:
    rtp_hdr_tm_RTP_Header ;

    BYTE *m_pBuf;

    boolm_bSPSFound ;
    boolm_bWaitKeyFrame ;
    boolm_bAssemblingFrame ;
    boolm_bPrevFrameEnd ;
    BYTE*m_pStart ;
    BYTE *m_pEnd;
    DWORDm_dwSize ;

    WORD m_wSeq;

    BYTEm_H264PAYLOADTYPE ;
    DWORD m_ssrc;
};

// class CH264_RTP_UNPACK end
//////////////////////////////////////////////////////////////////////////////////////////