程序博客网 > js 文本编辑器

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

来源：互联网 发布：js 文本编辑器 编辑：程序博客网 时间：2024/05/22 12:18
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]

js 文本编辑器 js 文本编辑器
原创粉丝点击
热门IT博客
农村淘宝农村淘宝
奥迪大众什么关系 知乎奥迪大众什么关系 知乎
淘宝摄影报价单
centos配置网络
印度军工很差知乎
ubuntu 删除访客
百度同声传译软件
天涯与知乎
手机淘宝怎么没有彩票
淘宝在线客服怎么设置
网络招聘的优点包括
mac怎么把图标放在桌面
java多线程项目实战
贵州牛屎火锅 知乎
软件人才外派ren
windows pro是啥
saber软件汉化
系统服务蜂窝网络搜索
远程访问服务器数据库
张曼玉演技知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 保持沉默结局 沉默的糕点作品 沉默的证人粤语 沉默证人粤语 保持沉默演员表 沉默的证人上映 夜以沉默心事向谁说是什么歌 秘战沉默似铁 沉默的证人免费观看 沉默的大多数 沉默是金歌词 保持沉默剧情 沉默的证人演员表 沉默的证人在线播放 你有权保持沉默 男人6种沉默证明他爱你 沉默证人演员表 男人六种沉默代表爱你 沉默的证人在线 沉默用英语怎么说 沉默的反义词是什么 沉默什么意思 沉默英语怎么说 沉默的忧伤图片 关于沉默的名言 可贵的沉默阅读答案 沉默的意思是什么 沉默是什么意思 班扎古鲁白玛的沉默 浑沌 沌 沌口 混混沌沌 沌怎么读 武汉沌口体育中心 浑沌记 沌口属于武汉哪个区 沌口体育中心 浑沌无极 神沌星灵 沌口之声

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里