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

于 2013-09-05 15:52:21 发布
阅读量923 收藏
点赞数
分类专栏： 编解码
本文介绍了一种H.264视频数据的RTP打包和解包方法，通过C++代码实现H.264 NAL单元的RTP封装与解封装。该方法能够处理不同类型的NAL单元，并支持FU-A分片。

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

RTP打包H264 NALU类使用范例代码：
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 
 // ... 
} 
RTP 承载H.264 Payload NALU 的打包类源码
// 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 ) 
        {
// limit RTP packetsize to 1472 bytes
            m_RTP_Info.end = m_RTP_Info.start + maxSize ;
        } 
        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 ; 
            } 
        }
// should be set at EofFrame
        m_RTP_Info.rtp_hdr.m =    m_RTP_Info.nal.eoFrame ? 1 : 0 ;
        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



RTP 承载H.264 Payload的解包类源码

// class CH264_RTP_UNPACK start

         
         
  1. class CH264_RTP_UNPACK 
  2. { 
  3.  
  4. #define RTP_VERSION 2 
  5. #define BUF_SIZE (1024 * 500) 
  6.  
  7.     typedef struct 
  8.     { 
  9.         //LITTLE_ENDIAN 
  10.         unsigned short   cc:4;/* CSRC count                 */ 
  11.         unsigned short   x:1; /* header extension flag      */ 
  12.         unsigned short   p:1; /* padding flag               */ 
  13.         unsigned short   v:2; /* packet type                */ 
  14.         unsigned short   pt:7;/* payload type               */ 
  15.         unsigned short   m:1; /* marker bit                 */ 
  16.  
  17.         unsigned short    seq;/* sequence number            */ 
  18.         unsigned long     ts; /* timestamp                  */ 
  19.         unsigned long     ssrc;/*synchronization source     */ 
  20.     } rtp_hdr_t; 
  21. public: 
  22.  
  23.     CH264_RTP_UNPACK ( HRESULT &hr, unsigned char H264PAYLOADTYPE = 96 ) 
  24.         : m_bSPSFound(false) 
  25.         , m_bWaitKeyFrame(true) 
  26.         , m_bPrevFrameEnd(false) 
  27.         , m_bAssemblingFrame(false) 
  28.         , m_wSeq(1234) 
  29.         , m_ssrc(0) 
  30.     { 
  31.         m_pBuf = new BYTE[BUF_SIZE] ; 
  32.         if ( m_pBuf == NULL ) 
  33.         { 
  34.             hr = E_OUTOFMEMORY ; 
  35.             return ; 
  36.         } 
  37.  
  38.         m_H264PAYLOADTYPE = H264PAYLOADTYPE ; 
  39.         m_pEnd = m_pBuf + BUF_SIZE ; 
  40.         m_pStart = m_pBuf ; 
  41.         m_dwSize = 0 ; 
  42.         hr = S_OK ; 
  43.     } 
  44.  
  45.     ~CH264_RTP_UNPACK(void) 
  46.     { 
  47.         delete [] m_pBuf ; 
  48.     } 
  49.  
  50. //pBuf为H264 RTP视频数据包，nSize为RTP视频数据包字节长度，outSize为输出视频数据帧字节长度。 
  51. //返回值为指向视频数据帧的指针。输入数据可能被破坏。 
  52.     BYTE* Parse_RTP_Packet ( BYTE *pBuf, unsigned short nSize, int *outSize ) 
  53.     { 
  54.         if ( nSize <= 12 ) 
  55.         { 
  56.             return NULL ; 
  57.         } 
  58.  
  59.         BYTE *cp = (BYTE*)&m_RTP_Header ; 
  60.         cp[0] = pBuf[0] ; 
  61.         cp[1] = pBuf[1] ; 
  62.  
  63.         m_RTP_Header.seq = pBuf[2] ; 
  64.         m_RTP_Header.seq <<= 8 ; 
  65.         m_RTP_Header.seq |= pBuf[3] ; 
  66.  
  67.         m_RTP_Header.ts = pBuf[4] ; 
  68.         m_RTP_Header.ts <<= 8 ; 
  69.         m_RTP_Header.ts |= pBuf[5] ; 
  70.         m_RTP_Header.ts <<= 8 ; 
  71.         m_RTP_Header.ts |= pBuf[6] ; 
  72.         m_RTP_Header.ts <<= 8 ; 
  73.         m_RTP_Header.ts |= pBuf[7] ; 
  74.  
  75.         m_RTP_Header.ssrc = pBuf[8] ; 
  76.         m_RTP_Header.ssrc <<= 8 ; 
  77.         m_RTP_Header.ssrc |= pBuf[9] ; 
  78.         m_RTP_Header.ssrc <<= 8 ; 
  79.         m_RTP_Header.ssrc |= pBuf[10] ; 
  80.         m_RTP_Header.ssrc <<= 8 ; 
  81.         m_RTP_Header.ssrc |= pBuf[11] ; 
  82.  
  83.         BYTE *pPayload = pBuf + 12 ; 
  84.         DWORD PayloadSize = nSize - 12 ; 
  85.  
  86.         // Check the RTP version number (it should be 2): 
  87.         if ( m_RTP_Header.v != RTP_VERSION ) 
  88.         { 
  89.             return NULL ; 
  90.         } 
  91.  
  92.         /* 
  93.         // Skip over any CSRC identifiers in the header: 
  94.         if ( m_RTP_Header.cc ) 
  95.         { 
  96.             long cc = m_RTP_Header.cc * 4 ; 
  97.             if ( Size < cc ) 
  98.             { 
  99.                 return NULL ; 
  100.             } 
  101.  
  102.             Size -= cc ; 
  103.             p += cc ; 
  104.         } 
  105.  
  106.         // Check for (& ignore) any RTP header extension 
  107.         if ( m_RTP_Header.x ) 
  108.         { 
  109.             if ( Size < 4 ) 
  110.             { 
  111.                 return NULL ; 
  112.             } 
  113.  
  114.             Size -= 4 ; 
  115.             p += 2 ; 
  116.             long l = p[0] ; 
  117.             l <<= 8 ; 
  118.             l |= p[1] ; 
  119.             p += 2 ; 
  120.             l *= 4 ; 
  121.             if ( Size < l ) ; 
  122.             { 
  123.                 return NULL ; 
  124.             } 
  125.             Size -= l ; 
  126.             p += l ; 
  127.         } 
  128.         
  129.         // Discard any padding bytes: 
  130.         if ( m_RTP_Header.p ) 
  131.         { 
  132.             if ( Size == 0 ) 
  133.             { 
  134.                 return NULL ; 
  135.             } 
  136.             long Padding = p[Size-1] ; 
  137.             if ( Size < Padding ) 
  138.             { 
  139.                 return NULL ; 
  140.             } 
  141.             Size -= Padding ; 
  142.         }*/ 
  143.  
  144.         // Check the Payload Type. 
  145.         if ( m_RTP_Header.pt != m_H264PAYLOADTYPE ) 
  146.         { 
  147.             return NULL ; 
  148.         } 
  149.  
  150.         int PayloadType = pPayload[0] & 0x1f ; 
  151.         int NALType = PayloadType ; 
  152.         if ( NALType == 28 ) // FU_A 
  153.         { 
  154.             if ( PayloadSize < 2 ) 
  155.             { 
  156.                 return NULL ; 
  157.             } 
  158.  
  159.             NALType = pPayload[1] & 0x1f ; 
  160.         } 
  161.  
  162.         if ( m_ssrc != m_RTP_Header.ssrc ) 
  163.         { 
  164.             m_ssrc = m_RTP_Header.ssrc ; 
  165.             SetLostPacket () ; 
  166.         } 
  167.     
  168.         if ( NALType == 0x07 ) // SPS 
  169.         { 
  170.             m_bSPSFound = true ; 
  171.         } 
  172.  
  173.         if ( !m_bSPSFound ) 
  174.         { 
  175.             return NULL ; 
  176.         } 
  177.  
  178.         if ( NALType == 0x07 || NALType == 0x08 ) // SPS PPS 
  179.         { 
  180.             m_wSeq = m_RTP_Header.seq ; 
  181.             m_bPrevFrameEnd = true ; 
  182.  
  183.             pPayload -= 4 ; 
  184.             *((DWORD*)(pPayload)) = 0x01000000 ; 
  185.             *outSize = PayloadSize + 4 ; 
  186.             return pPayload ; 
  187.         } 
  188.  
  189.         if ( m_bWaitKeyFrame ) 
  190.         { 
  191.             if ( m_RTP_Header.m ) // frame end 
  192.             { 
  193.                 m_bPrevFrameEnd = true ; 
  194.                 if ( !m_bAssemblingFrame ) 
  195.                 { 
  196.                     m_wSeq = m_RTP_Header.seq ; 
  197.                     return NULL ; 
  198.                 } 
  199.             } 
  200.  
  201.             if ( !m_bPrevFrameEnd ) 
  202.             { 
  203.                 m_wSeq = m_RTP_Header.seq ; 
  204.                 return NULL ; 
  205.             } 
  206.             else 
  207.             { 
  208.                 if ( NALType != 0x05 ) // KEY FRAME 
  209.                 { 
  210.                     m_wSeq = m_RTP_Header.seq ; 
  211.                     m_bPrevFrameEnd = false ; 
  212.                     return NULL ; 
  213.                 } 
  214.             }
  215.         }
  216.         if ( m_RTP_Header.seq != (WORD)( m_wSeq + 1 ) )//lost packet 
  217.         { 
  218.             m_wSeq = m_RTP_Header.seq ; 
  219.             SetLostPacket () ;            
  220.             return NULL ; 
  221.         } 
  222.         else 
  223.         { 
  224.             // 码流正常 
  225.  
  226.             m_wSeq = m_RTP_Header.seq ; 
  227.             m_bAssemblingFrame = true ; 
  228.             
  229.             if ( PayloadType != 28 ) // whole NAL 
  230.             { 
  231.                 *((DWORD*)(m_pStart)) = 0x01000000 ; 
  232.                 m_pStart += 4 ; 
  233.                 m_dwSize += 4 ; 
  234.             } 
  235.             else // FU_A 
  236.             { 
  237.                 if ( pPayload[1] & 0x80 ) // FU_A start 
  238.                 { 
  239.                     *((DWORD*)(m_pStart)) = 0x01000000 ; 
  240.                     m_pStart += 4 ; 
  241.                     m_dwSize += 4 ; 
  242.  
  243.                     pPayload[1] = ( pPayload[0] & 0xE0 ) | NALType ; 
  244.                     
  245.                     pPayload += 1 ; 
  246.                     PayloadSize -= 1 ; 
  247.                 } 
  248.                 else 
  249.                 { 
  250.                     pPayload += 2 ; 
  251.                     PayloadSize -= 2 ; 
  252.                 } 
  253.             } 
  254.  
  255.             if ( m_pStart + PayloadSize < m_pEnd ) 
  256.             { 
  257.                 CopyMemory ( m_pStart, pPayload, PayloadSize ) ; 
  258.                 m_dwSize += PayloadSize ; 
  259.                 m_pStart += PayloadSize ; 
  260.             } 
  261.             else // memory overflow 
  262.             { 
  263.                 SetLostPacket () ; 
  264.                 return NULL ; 
  265.             } 
  266.  
  267.             if ( m_RTP_Header.m ) // frame end 
  268.             { 
  269.                 *outSize = m_dwSize ; 
  270.  
  271.                 m_pStart = m_pBuf ; 
  272.                 m_dwSize = 0 ; 
  273.  
  274.                 if ( NALType == 0x05 ) // KEY FRAME 
  275.                 { 
  276.                     m_bWaitKeyFrame = false ; 
  277.                 } 
  278.                 return m_pBuf ; 
  279.             } 
  280.             else 
  281.             { 
  282.                 return NULL ; 
  283.             } 
  284.         } 
  285.     } 
  286.  
  287.     void SetLostPacket() 
  288.     { 
  289.         m_bSPSFound = false ; 
  290.         m_bWaitKeyFrame = true ; 
  291.         m_bPrevFrameEnd = false ; 
  292.         m_bAssemblingFrame = false ; 
  293.         m_pStart = m_pBuf ; 
  294.         m_dwSize = 0 ; 
  295.     } 
  296.  
  297. private: 
  298.     rtp_hdr_t m_RTP_Header ; 
  299.  
  300.     BYTE *m_pBuf ; 
  301.  
  302.     bool m_bSPSFound ; 
  303.     bool m_bWaitKeyFrame ; 
  304.     bool m_bAssemblingFrame ; 
  305.     bool m_bPrevFrameEnd ; 
  306.     BYTE *m_pStart ; 
  307.     BYTE *m_pEnd ; 
  308.     DWORD m_dwSize ; 
  309.  
  310.     WORD m_wSeq ; 
  311.  
  312.     BYTE m_H264PAYLOADTYPE ; 
  313.     DWORD m_ssrc ; 
  314. }; 
  315.  
  316. // class CH264_RTP_UNPACK end 

使用范例：

         
         
  1. HRESULT hr ; 
  2. CH264_RTP_UNPACK unpack ( hr ) ; 
  3. BYTE *pRtpData ; 
  4. WORD inSize; 
  5. int outSize ; 
  6. BYTE *pFrame = unpack.Parse_RTP_Packet ( pRtpData, inSize, &outSize ) ; 
  7. if ( pFrame != NULL ) 
  8. { 
  9. // frame process 
  10. // ... 
  11. } 
文章转载自： 罗索实验室 [ http://www.rosoo.net/a/201101/10763.html]

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值