(转)VLC播放RTP打包发送的.264文件

VLC播放RTP打包发送的.264文件

1,要有一个发送RTP包的264文件的服务器;

具体代码如下:

rtp.h

#include <WinSock2.h>
#pragma comment(lib,"ws2_32.lib")

#define PACKET_BUFFER_END            (unsigned int)0x00000000
#define MAX_RTP_PKT_LENGTH     1400
#define DEST_IP                "172.18.191.194"
#define DEST_PORT            554
#define H264                    96 

typedef struct
{
    /**//* byte 0 */
    unsigned char csrc_len:;        /**//* expect 0 */
    unsigned char extension:;        /**//* expect 1, see RTP_OP below */
    unsigned char padding:;        /**//* expect 0 */
    unsigned char version:;        /**//* expect 2 */
    /**//* byte 1 */
    unsigned char payload:;        /**//* RTP_PAYLOAD_RTSP */
    unsigned char marker:;        /**//* expect 1 */
    /**//* bytes 2, 3 */
    unsigned short seq_no;
    /**//* bytes 4-7 */
    unsigned  long timestamp;
    /**//* bytes 8-11 */
    unsigned long ssrc;            /**//* stream number is used here. */
} RTP_FIXED_HEADER; 

typedef struct {
    //byte 0
    unsigned char TYPE:;
    unsigned char NRI:;
    unsigned char F:;     

} NALU_HEADER; /**//* 1 BYTES */ 

typedef struct {
    //byte 0
    unsigned char TYPE:;
    unsigned char NRI:;
    unsigned char F:;     

} FU_INDICATOR; /**//* 1 BYTES */ 

typedef struct {
    //byte 0
    unsigned char TYPE:;
    unsigned char R:;
    unsigned char E:;
    unsigned char S:;
} FU_HEADER; /**//* 1 BYTES */

rtp.cpp

#include "rtp.h"
#include <stdio.h>

FILE * bits = NULL;                //!< the bit stream file
static int FindStartCode2 (unsigned char *Buf);//查找开始字符0x000001
static int FindStartCode3 (unsigned char *Buf);//查找开始字符0x00000001
//static bool flag = true;
static int info2=, info3=;
RTP_FIXED_HEADER        *rtp_hdr; 

NALU_HEADER     *nalu_hdr;
FU_INDICATOR    *fu_ind;
FU_HEADER       *fu_hdr;

typedef struct
{
    int startcodeprefix_len;      //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)
    unsigned len;                 //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)
    unsigned max_size;            //! Nal Unit Buffer size
    int forbidden_bit;            //! should be always FALSE
    int nal_reference_idc;        //! NALU_PRIORITY_xxxx
    int nal_unit_type;            //! NALU_TYPE_xxxx
    char *buf;                    //! contains the first byte followed by the EBSP
    unsigned short lost_packets;  //! true, if packet loss is detected
} NALU_t; 

BOOL InitWinsock()
{
    int Error;
    WORD VersionRequested;
    WSADATA WsaData;
    VersionRequested=MAKEWORD(,);
    Error=WSAStartup(VersionRequested,&WsaData); //启动WinSock2
    if(Error!=)
    {
        return FALSE;
    }
    else
    {
        if(LOBYTE(WsaData.wVersion)!=||HIBYTE(WsaData.wHighVersion)!=)
        {
            WSACleanup();
            return FALSE;
        }

    }
    return TRUE;
}

//为NALU_t结构体分配内存空间
NALU_t *AllocNALU(int buffersize)
{
    NALU_t *n; 

    if ((n = (NALU_t*)calloc (, sizeof (NALU_t))) == NULL)
    {
        printf("AllocNALU: n");
        exit();
    } 

    n->max_size=buffersize; 

    if ((n->buf = (char*)calloc (buffersize, sizeof (char))) == NULL)
    {
        free (n);
        printf ("AllocNALU: n->buf");
        exit();
    } 

    return n;
} 

//释放
void FreeNALU(NALU_t *n)
{
    if (n)
    {
        if (n->buf)
        {
            free(n->buf);
            n->buf=NULL;
        }
        free (n);
    }
} 

//这个函数输入为一个NAL结构体，主要功能为得到一个完整的NALU并保存在NALU_t的buf中，获取他的长度，填充F,IDC,TYPE位。
//并且返回两个开始字符之间间隔的字节数，即包含有前缀的NALU的长度
int GetAnnexbNALU (NALU_t *nalu)
{
    int pos = ;
    int StartCodeFound, rewind;
    unsigned char *Buf; 

    if ((Buf = (unsigned char*)calloc (nalu->max_size , sizeof(char))) == NULL)
        printf ("GetAnnexbNALU: Could not allocate Buf memory\n"); 

    nalu->startcodeprefix_len=;//初始化码流序列的开始字符为3个字节 

    if ( != fread (Buf, , , bits))//从码流中读3个字节
    {
        free(Buf);
        return ;
    }
    info2 = FindStartCode2 (Buf);//判断是否为0x000001
    if(info2 != )
    {
        //如果不是，再读一个字节
        if( != fread(Buf+, , , bits))//读一个字节
        {
            free(Buf);
            return ;
        }
        info3 = FindStartCode3 (Buf);//判断是否为0x00000001
        if (info3 != )//如果不是，返回-1
        {
            free(Buf);
            return -;
        }
        else
        {
            //如果是0x00000001,得到开始前缀为4个字节
            pos = ;
            nalu->startcodeprefix_len = ;
        }
    } 

    else
    {
        //如果是0x000001,得到开始前缀为3个字节
        nalu->startcodeprefix_len = ;
        pos = ;
    }
    //查找下一个开始字符的标志位
    StartCodeFound = ;
    info2 = ;
    info3 = ; 

    while (!StartCodeFound)
    {
        if (feof (bits))//判断是否到了文件尾
        {
            nalu->len = (pos-)-nalu->startcodeprefix_len;
            memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
            nalu->forbidden_bit = nalu->buf[] & 0x80; //1 bit
            nalu->nal_reference_idc = nalu->buf[] & 0x60; // 2 bit
            nalu->nal_unit_type = (nalu->buf[]) & 0x1f;// 5 bit
            free(Buf);
            return pos-;
        }
        Buf[pos++] = fgetc (bits);//读一个字节到BUF中
        info3 = FindStartCode3(&Buf[pos-]);//判断是否为0x00000001
        if(info3 != )
            info2 = FindStartCode2(&Buf[pos-]);//判断是否为0x000001
        StartCodeFound = (info2 ==  || info3 == );
    } 

    // Here, we have found another start code (and read length of startcode bytes more than we should
    // have.  Hence, go back in the file
    rewind = (info3 == )? - : -; 

    if ( != fseek (bits, rewind, SEEK_CUR))//把文件指针指向前一个NALU的末尾
    {
        free(Buf);
        printf("GetAnnexbNALU: Cannot fseek in the bit stream file");
    } 

    // Here the Start code, the complete NALU, and the next start code is in the Buf.
    // The size of Buf is pos, pos+rewind are the number of bytes excluding the next
    // start code, and (pos+rewind)-startcodeprefix_len is the size of the NALU excluding the start code 

    nalu->len = (pos+rewind)-nalu->startcodeprefix_len;
    memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);//拷贝一个完整NALU，不拷贝起始前缀0x000001或0x00000001
    nalu->forbidden_bit = nalu->buf[] & 0x80; //1 bit
    nalu->nal_reference_idc = nalu->buf[] & 0x60; // 2 bit
    nalu->nal_unit_type = (nalu->buf[]) & 0x1f;// 5 bit
    free(Buf); 

    return (pos+rewind);//返回两个开始字符之间间隔的字节数，即包含有前缀的NALU的长度
} 

//输出NALU长度和TYPE
void dump(NALU_t *n)
{
    if (!n)return;
    //printf("a new nal:");
    printf(" len: %d  ", n->len);
    printf("nal_unit_type: %x\n", n->nal_unit_type);
} 

int main(int argc, char* argv[])
{
    NALU_t * n;
    char* nalu_payload;
    char sendbuf[];
    unsigned short seq_num =;
    int bytes=; 

    SOCKET    socket1;
    struct sockaddr_in server;
    int len =sizeof(server);
    float framerate=;
    unsigned int timestamp_increase=,ts_current=;
    timestamp_increase=(unsigned int)(90000.0 / framerate); //+0.5); 

    bits=fopen("my.h264","rb");
    InitWinsock(); //初始化套接字库 

    server.sin_family=AF_INET;
    server.sin_port=htons(DEST_PORT);
    server.sin_addr.s_addr=inet_addr(DEST_IP);
    socket1=socket(AF_INET,SOCK_DGRAM,);
    connect(socket1, (const struct sockaddr *)&server, len) ;//申请UDP套接字
    n = AllocNALU();//为结构体nalu_t及其成员buf分配空间。返回值为指向nalu_t存储空间的指针 

    while(!feof(bits))
    {
        GetAnnexbNALU(n);//每执行一次，文件的指针指向本次找到的NALU的末尾，下一个位置即为下个NALU的起始码0x000001
        dump(n);//输出NALU长度和TYPE 

        memset(sendbuf,,);//清空sendbuf；此时会将上次的时间戳清空，因此需要ts_current来保存上次的时间戳值
        //rtp固定包头，为12字节,该句将sendbuf[0]的地址赋给rtp_hdr，以后对rtp_hdr的写入操作将直接写入sendbuf。
        rtp_hdr =(RTP_FIXED_HEADER*)&sendbuf[];
        //设置RTP HEADER，
        rtp_hdr->payload     = H264;  //负载类型号，
        rtp_hdr->version     = ;  //版本号，此版本固定为2
        rtp_hdr->marker    = ;   //标志位，由具体协议规定其值。
        rtp_hdr->ssrc        = htonl();    //随机指定为10，并且在本RTP会话中全局唯一 

        //  当一个NALU小于1400字节的时候，采用一个单RTP包发送
        if(n->len<=)
        {
            //设置rtp M 位；
            rtp_hdr->marker=;
            rtp_hdr->seq_no     = htons(seq_num ++); //序列号，每发送一个RTP包增1
            //设置NALU HEADER,并将这个HEADER填入sendbuf[12]
            nalu_hdr =(NALU_HEADER*)&sendbuf[]; //将sendbuf[12]的地址赋给nalu_hdr，之后对nalu_hdr的写入就将写入sendbuf中；
            nalu_hdr->F=n->forbidden_bit;
            nalu_hdr->NRI=n->nal_reference_idc>>;//有效数据在n->nal_reference_idc的第6，7位，需要右移5位才能将其值赋给nalu_hdr->NRI。
            nalu_hdr->TYPE=n->nal_unit_type; 

            nalu_payload=&sendbuf[];//同理将sendbuf[13]赋给nalu_payload
            memcpy(nalu_payload,n->buf+,n->len-);//去掉nalu头的nalu剩余内容写入sendbuf[13]开始的字符串。 

            ts_current=ts_current+timestamp_increase;
            rtp_hdr->timestamp=htonl(ts_current);
            bytes=n->len +  ;                      //获得sendbuf的长度,为nalu的长度（包含NALU头但除去起始前缀）加上rtp_header的固定长度12字节
            send( socket1, sendbuf, bytes,  );//发送rtp包
            //sleep(1);
            //fwrite(sendbuf,bytes, 1, stream);
        } 

        else if(n->len>)
        {
            //得到该nalu需要用多少长度为1400字节的RTP包来发送
            int k=,l=;
            k=n->len/;//需要k个1400字节的RTP包
            l=n->len%;//最后一个RTP包的需要装载的字节数
            int t=;//用于指示当前发送的是第几个分片RTP包
            ts_current=ts_current+timestamp_increase;
            rtp_hdr->timestamp=htonl(ts_current);
            while(t<=k)
            {
                rtp_hdr->seq_no = htons(seq_num ++); //序列号，每发送一个RTP包增1
                if(!t)//发送一个需要分片的NALU的第一个分片，置FU HEADER的S位
                {
                    //设置rtp M 位；
                    rtp_hdr->marker=;
                    //设置FU INDICATOR,并将这个HEADER填入sendbuf[12]
                    fu_ind =(FU_INDICATOR*)&sendbuf[]; //将sendbuf[12]的地址赋给fu_ind，之后对fu_ind的写入就将写入sendbuf中；
                    fu_ind->F=n->forbidden_bit;
                    fu_ind->NRI=n->nal_reference_idc>>;
                    fu_ind->TYPE=; 

                    //设置FU HEADER,并将这个HEADER填入sendbuf[13]
                    fu_hdr =(FU_HEADER*)&sendbuf[];
                    fu_hdr->E=;
                    fu_hdr->R=;
                    fu_hdr->S=;
                    fu_hdr->TYPE=n->nal_unit_type; 

                    nalu_payload=&sendbuf[];//同理将sendbuf[14]赋给nalu_payload
                    memcpy(nalu_payload,n->buf+,);//去掉NALU头 

                    bytes=+;                      //获得sendbuf的长度,为nalu的长度（除去起始前缀和NALU头）加上rtp_header，fu_ind，fu_hdr的固定长度14字节
                    send( socket1, sendbuf, bytes,  );//发送rtp包
                    //fwrite(sendbuf,bytes, 1, stream);
                    //sleep(1);
                    t++; 

                }
                //发送一个需要分片的NALU的非第一个分片，清零FU HEADER的S位，如果该分片是该NALU的最后一个分片，置FU HEADER的E位
                else if(k==t)//发送的是最后一个分片，注意最后一个分片的长度可能超过1400字节（当l>1386时）。
                { 

                    //设置rtp M 位；当前传输的是最后一个分片时该位置1
                    rtp_hdr->marker=;
                    //设置FU INDICATOR,并将这个HEADER填入sendbuf[12]
                    fu_ind =(FU_INDICATOR*)&sendbuf[]; //将sendbuf[12]的地址赋给fu_ind，之后对fu_ind的写入就将写入sendbuf中；
                    fu_ind->F=n->forbidden_bit;
                    fu_ind->NRI=n->nal_reference_idc>>;
                    fu_ind->TYPE=; 

                    //设置FU HEADER,并将这个HEADER填入sendbuf[13]
                    fu_hdr =(FU_HEADER*)&sendbuf[];
                    fu_hdr->R=;
                    fu_hdr->S=;
                    fu_hdr->TYPE=n->nal_unit_type;
                    fu_hdr->E=; 

                    nalu_payload=&sendbuf[];//同理将sendbuf[14]的地址赋给nalu_payload
                    memcpy(nalu_payload,n->buf+t*+,l-);//将nalu最后剩余的l-1(去掉了一个字节的NALU头)字节内容写入sendbuf[14]开始的字符串。
                    bytes=l-+;       //获得sendbuf的长度,为剩余nalu的长度l-1加上rtp_header，FU_INDICATOR,FU_HEADER三个包头共14字节
                    send( socket1, sendbuf, bytes,  );//发送rtp包
                    //fwrite(sendbuf,bytes, 1, stream);
                    t++;
                    //sleep(1);
                }
                else if(t<k&&!=t)
                {
                    //设置rtp M 位；
                    rtp_hdr->marker=;
                    //设置FU INDICATOR,并将这个HEADER填入sendbuf[12]
                    fu_ind =(FU_INDICATOR*)&sendbuf[]; //将sendbuf[12]的地址赋给fu_ind，之后对fu_ind的写入就将写入sendbuf中；
                    fu_ind->F=n->forbidden_bit;
                    fu_ind->NRI=n->nal_reference_idc>>;
                    fu_ind->TYPE=; 

                    //设置FU HEADER,并将这个HEADER填入sendbuf[13]
                    fu_hdr =(FU_HEADER*)&sendbuf[];
                    //fu_hdr->E=0;
                    fu_hdr->R=;
                    fu_hdr->S=;
                    fu_hdr->E=;
                    fu_hdr->TYPE=n->nal_unit_type; 

                    nalu_payload=&sendbuf[];//同理将sendbuf[14]的地址赋给nalu_payload
                    memcpy(nalu_payload,n->buf+t*+,);//去掉起始前缀的nalu剩余内容写入sendbuf[14]开始的字符串。
                    bytes=+;                      //获得sendbuf的长度,为nalu的长度（除去原NALU头）加上rtp_header，fu_ind，fu_hdr的固定长度14字节
                    send( socket1, sendbuf, bytes,  );//发送rtp包
                    //fwrite(sendbuf,bytes, 1, stream);
                    //sleep(1);
                    t++;
                }
            }
        }
        //usleep(40000);
    }
    FreeNALU(n); 

    return ;
} 

static int FindStartCode2 (unsigned char *Buf)
{
    if(Buf[]!= || Buf[]!= || Buf[] !=) return ; //判断是否为0x000001,如果是返回1
    else return ;
} 

static int FindStartCode3 (unsigned char *Buf)
{
    if(Buf[]!= || Buf[]!= || Buf[] != || Buf[] !=) return ;//判断是否为0x00000001,如果是返回1
    else return ;
} 

2,下载vlc;

3,进行如下设置:
1>设置w.sdp
a,打开vlc->Media->Open network stream
b,-->network->rtp://@192.168.1.101:1234
c,-->file->add...w.sdp->play
这里要讲一下sdp文件，sdp文件时vlc播放是需要的文件，这里是必须的，否则是无法播放的，w.sdp文件其实只是几句话，这里我贴出来：

m=video  RTP/AVP  //96表示的是动态净荷类型号 意思就是负载类型不确定，要通过其他方式来确定
a=rtpmap: H264
a=framerate:
c=IN IP4 192.168.0.30

上面的1234和192.168.1.101就是RTP的端口和IP

2〉点击vlc播放按钮 
3〉再运行264文件的RTP包发送的服务器
4〉一会儿就看看vlc播放视频了

参考:

1,VLC播放RTP打包发送的.264文件

http://blog.csdn.net/liuzongming1988/article/details/8292455