video_decode.c

sample on embedded linux

HI_S32 HI_DVS_GetDataFromBuf (HANDLE HBuf, HI_CHAR **ppBuff, HI_U32 * pLen, HI_U32 *pts)
{
    BUF_INFO_S *pBufInfo;
    pBufInfo = (BUF_INFO_S *)HBuf;

    if (pBufInfo->u32ReadP == pBufInfo->u32WriteP)
    {
        return HI_FAILURE;
    }
    *ppBuff = (HI_CHAR *)&pBufInfo->u8RecBuf[pBufInfo->u32ReadP][8];
    *pLen = *((HI_S32 *)(&pBufInfo->u8RecBuf[pBufInfo->u32ReadP][0]));
    *pts = *((HI_S32 *)(&pBufInfo->u8RecBuf[pBufInfo->u32ReadP][4]));

    pBufInfo->u32ReadP += 1;
    if (RECEIVEBUF_NUM == pBufInfo->u32ReadP)
        pBufInfo->u32ReadP = 0;    
    return HI_SUCCESS;
}

/*the network send data to buffer*/
HI_S32 HI_DVS_SendDataToBuf (HANDLE HBuf, HI_CHAR *pBuff, HI_U32 u32Len, HI_U32 pts)
{
    BUF_INFO_S *pBufInfo;
    pBufInfo = (BUF_INFO_S *)HBuf;

    pBufInfo->u32RcvCount += 1;

    if (pBufInfo->u32ReadP <= pBufInfo->u32WriteP)
    {
        /*overload warning*/
        if (pBufInfo->u32WriteP - pBufInfo->u32ReadP >=  RECEIVEBUF_NUM*4/5)
        {
            //printf ("receif buff is nearly full!\n");
            return;
        }
        if (pBufInfo->u32ReadP + RECEIVEBUF_NUM == pBufInfo->u32WriteP + 1)
        {
            printf("no receive buf !\n");
            exit(-1);
            return 1;
        }
        *((HI_S32 *)(&pBufInfo->u8RecBuf[pBufInfo->u32WriteP][0])) = u32Len;
        *((HI_S32 *)(&pBufInfo->u8RecBuf[pBufInfo->u32WriteP][4])) = pts;
        memcpy(&pBufInfo->u8RecBuf[pBufInfo->u32WriteP][8],(void *)pBuff, u32Len);

        pBufInfo->u32WriteP += 1;
        if(RECEIVEBUF_NUM == pBufInfo->u32WriteP)
        {
            pBufInfo->u32WriteP = 0;
        }
    }
    else
    {
        /*overload warning*/
        if (pBufInfo->u32WriteP + RECEIVEBUF_NUM - pBufInfo->u32ReadP >=  RECEIVEBUF_NUM*4/5)
        {
            //printf ("receif buff is nearly full!\n");
            return;
        }
        if (pBufInfo->u32ReadP == pBufInfo->u32WriteP + 1)
        {
            printf("no receive buf !\n");
            exit(-1);
            return 1;
        }
        *((HI_S32 *)(&pBufInfo->u8RecBuf[pBufInfo->u32WriteP][0])) = u32Len;
        *((HI_S32 *)(&pBufInfo->u8RecBuf[pBufInfo->u32WriteP][4])) = pts;
        memcpy(&pBufInfo->u8RecBuf[pBufInfo->u32WriteP][8],(void *)pBuff, u32Len);

        pBufInfo->u32WriteP += 1;
    }
    if (u32Len > 0x800)printf("stream.Datalen %x\n", u32Len);
    return HI_SUCCESS;
}

/*rtp protocol***************************************************************/
#define IN
#define OUT
#define IO
#define RPT_MAX_PACKET_BUFF 4096
#define HI_SockLen_T socklen_t
#define HI_Pthread_T pthread_t
#define HI_SSIZE_T ssize_t
typedef unsigned short  HI_PORT;
typedef int RTP_SOCKET;

/*RTP Payload type define*/
typedef enum hiRTP_PT_E
{
    RTP_PT_ULAW             = 0,        /* mu-law */
    RTP_PT_GSM              = 3,        /* GSM */
    RTP_PT_G723             = 4,        /* G.723 */
    RTP_PT_ALAW             = 8,        /* a-law */
    RTP_PT_G722             = 9,        /* G.722 */
    RTP_PT_S16BE_STEREO     = 10,       /* linear 16, 44.1khz, 2 channel */
    RTP_PT_S16BE_MONO       = 11,       /* linear 16, 44.1khz, 1 channel */
    RTP_PT_MPEGAUDIO        = 14,       /* mpeg audio */
    RTP_PT_JPEG             = 26,       /* jpeg */
    RTP_PT_H261             = 31,       /* h.261 */
    RTP_PT_MPEGVIDEO        = 32,       /* mpeg video */
    RTP_PT_MPEG2TS          = 33,       /* mpeg2 TS stream */
    RTP_PT_H263             = 34,       /* old H263 encapsulation */
                            
    //RTP_PT_PRIVATE          = 96,       
    RTP_PT_H264             = 96,       /* hisilicon define as h.264 */
    RTP_PT_G726             = 97,       /* hisilicon define as G.726 */
    RTP_PT_ADPCM            = 98,       /* hisilicon define as ADPCM */

    RTP_PT_INVALID          = 127
}RTP_PT_E;

typedef struct hiRTP_STATS_S
{
    HI_U64  sent_packet;    /* number of packets send */
    HI_U64  sent_byte;      /* bytes sent */
    HI_U64  sent_error;     /* error times when send */
    HI_U64  recv_packet;    /* number of packets received */
    HI_U64  recv_byte;      /* bytes of payload received */
    HI_U64  unavaillable;   /* packets not availlable when they were queried */
    HI_U64  bad;            /* packets that did not appear to be RTP */
    HI_U64  discarded;      /* incoming packets discarded because the queue exceeds its max size */
    HI_U64  timeout_cnt;
} RTP_STATS_S;

struct hiRTP_RECV_S;

typedef  int (*RTP_ON_RECV_CB)(struct hiRTP_RECV_S * , unsigned char *,  unsigned int, int *);    

typedef enum hiRTP_RUNSTATE_E
{
    RTP_RUNSTATE_STOP    = 0,
    RTP_RUNSTATE_RUNNING = 1
}RTP_RUNSTATE_E;

#define RTP_DATA_MAX_LENGTH 2048

typedef struct hiRTP_RECV_S
{
    
    HI_Pthread_T        thd;       /* thread to recv cmd */

    HI_PORT             listen_port;
    
    RTP_SOCKET          sock;         /*send/recv socket*/

    RTP_PT_E            pt;           /*payload type*/
    
    HI_U16              last_sn;      /*last recv sn*/
    HI_U32              last_ts;      /*last recv sn*/
    
    RTP_STATS_S         stats;          /*stats*/

    RTP_ON_RECV_CB      rtp_on_recv;
    volatile RTP_RUNSTATE_E      runState;

    HI_U8               buff[RTP_DATA_MAX_LENGTH];

    int                 *ext_args;
}RTP_RECV_S;

/* total 12Bytes */
typedef struct hiRTP_HDR_S
{

#if (BYTE_ORDER == LITTLE_ENDIAN)
    /* byte 0 */
    HI_U16 cc      :4;   /* CSRC count */
    HI_U16 x       :1;   /* header extension flag */
    HI_U16 p       :1;   /* padding flag */
    HI_U16 version :2;   /* protocol version */

    /* byte 1 */
    HI_U16 pt      :7;   /* payload type */
    HI_U16 marker  :1;   /* marker bit */
#elif (BYTE_ORDER == BIG_ENDIAN)
    /* byte 0 */
    HI_U16 version :2;   /* protocol version */
    HI_U16 p       :1;   /* padding flag */
    HI_U16 x       :1;   /* header extension flag */
    HI_U16 cc      :4;   /* CSRC count */
    /*byte 1*/
    HI_U16 marker  :1;   /* marker bit */
    HI_U16 pt      :7;   /* payload type *//
#else
    #error YOU MUST DEFINE BYTE_ORDER == LITTLE_ENDIAN OR BIG_ENDIAN !  
#endif


    /* bytes 2, 3 */
    HI_U16 seqno  :16;   /* sequence number */

    /* bytes 4-7 */
    HI_U32 ts;            /* timestamp in ms */
  
    /* bytes 8-11 */
    HI_U32 ssrc;          /* synchronization source */
} RTP_HDR_S;

typedef enum hiRTP_TARGETHOST_STATE
{
    RTP_TARGETHOST_STATE_INIT = 0,
    RTP_TARGETHOST_STATE_REQ_IFrame = 1,    
    RTP_TARGETHOST_STATE_REQ_PARA = 2,    
    RTP_TARGETHOST_STATE_Sending = 3,
    RTP_TARGETHOST_STATE_BUTT
}RTP_TARGETHOST_STATE_E;

typedef char HI_IP_ADDR[64];
typedef int HI_SOCKET;
typedef struct hiRTP_TARGETHOST
{
    //struct list_head   ptr;
    HI_IP_ADDR          remote_ip;
    HI_PORT             remote_port;
    
    /*only use for sender*/
    struct sockaddr_in  remote_addr;
    HI_SOCKET           sock;
    HI_BOOL             bActive;     /*是否激活，如果false， 不发送*/
    RTP_TARGETHOST_STATE_E hostState;
    
    
}RTP_TARGETHOST_S;

/*定义了一个Sender 最多处理的发送数目*/
#define RTP_MAX_SENDER 8

typedef struct hiRTP_SENDER_S
{
    RTP_TARGETHOST_S    targethosts[RTP_MAX_SENDER];
    RTP_PT_E            pt;           /*payload type*/
    HI_U32              ssrc;
    
    HI_U16              last_sn;      /*last recv sn*/
    HI_U16              resv;
    HI_U32              last_ts;      /*last recv sn*/
    
    
    RTP_STATS_S         stats;          /*stats*/

    HI_BOOL             bActive;     /*是否激活，如果false， 不发送*/

    RTP_SOCKET          sock;         /*send/recv socket*/
    
    HI_PORT             rtpport;         /*本地udp port*/
    HI_PORT             rtcpport;         /*本地udp port*/

    HI_U8               buff[RPT_MAX_PACKET_BUFF];
    HI_U32              buffLen;

    
}RTP_SENDER_S;

#define RTP_HDR_SET_VERSION(pHDR, val)  ((pHDR)->version = val)
#define RTP_HDR_SET_P(pHDR, val)        ((pHDR)->p       = val)
#define RTP_HDR_SET_X(pHDR, val)        ((pHDR)->x       = val) 
#define RTP_HDR_SET_CC(pHDR, val)       ((pHDR)->cc      = val)

#define RTP_HDR_SET_M(pHDR, val)        ((pHDR)->marker  = val)
#define RTP_HDR_SET_PT(pHDR, val)       ((pHDR)->pt      = val)

#define RTP_HDR_SET_SEQNO(pHDR, _sn)    ((pHDR)->seqno  = (_sn))
#define RTP_HDR_SET_TS(pHDR, _ts)       ((pHDR)->ts     = (_ts))

#define RTP_HDR_SET_SSRC(pHDR, _ssrc)    ((pHDR)->ssrc  = _ssrc)

#define RTP_HDR_LEN  sizeof(RTP_HDR_S)

#define RTP_DATA_MAX_LENGTH 2048

#define RTP_VERSION    2


HI_S32 HI_RTP_Recv_Create(IO RTP_RECV_S ** ppRtpStream, 
                          IN HI_S32 _listen_port, 
                          IN RTP_ON_RECV_CB _on_recv_fh,
                          int *ext_args );

HI_S32 HI_RTP_Recv_Start(IN RTP_RECV_S * pRtpStream);

HI_S32 HI_RTP_Recv_Stop(IO RTP_RECV_S * pRtpStream);

HI_S32 HI_RTP_Recv_Destroy(IO RTP_RECV_S *pRtpStream);

/*创建socket*/
HI_S32 HI_Socket( HI_S32 af, HI_S32 type,HI_S32 protocol )
{
    return socket(af,type,protocol);
}

/*在非连接上接收数据*/
HI_SSIZE_T HI_Recvfrom( HI_S32 s,
                          HI_CHAR *buf,
                          HI_S32        len,
                          HI_S32        flags,
                          struct sockaddr *pfrom,
                          HI_S32       *pfromlen )
{
    return recvfrom( s, buf,  len,  flags, (struct sockaddr *)pfrom, pfromlen);
}

HI_S32  HI_SetSockOpt(HI_S32 s,  HI_S32  level,  HI_S32  optname,  const HI_VOID  *optval,   HI_SockLen_T optlen)
{
    return setsockopt( s,  level, optname, optval,  optlen);
}

/*关闭socket*/
HI_S32 HI_CloseSocket(HI_S32 ulSocket)
{
    return close(ulSocket);
}


/*将地址绑定到一个socket*/                         
HI_S32 HI_Bind( HI_S32       s,
                      const struct sockaddr *paddr,
                      HI_S32        addrlen )
{
    return bind(s, (struct sockaddr *)paddr,  addrlen);
}


/* 创建一个*/
HI_S32 HI_RTP_Recv_Create(IO RTP_RECV_S ** ppRtpStream, 
                          IN HI_S32 _listen_port, 
                          IN RTP_ON_RECV_CB _on_recv_fh,
                          int *ext_args )
{
    RTP_RECV_S* pRecv;
    struct sockaddr_in local_addr; 
    int socket_opt_value = 1;

       
    pRecv = (RTP_RECV_S*)malloc(sizeof(RTP_RECV_S));
    if (NULL == pRecv)
    {
        printf("create new rtp receiver error. not enough memory.\n");
        return -1;
    }
    
    memset(pRecv, 0 , sizeof(RTP_RECV_S));
    pRecv->rtp_on_recv = _on_recv_fh;
    pRecv->ext_args = ext_args;
    pRecv->runState    = RTP_RUNSTATE_STOP;
    pRecv->listen_port = _listen_port;

    if (( pRecv->sock = HI_Socket(AF_INET, SOCK_DGRAM, 0)) == -1) 
    {
        printf("<RTP>create socket error.\n"); 
        return -1;
    }
    socket_opt_value = 1;
    if (HI_SetSockOpt(pRecv->sock ,SOL_SOCKET,SO_REUSEADDR,&socket_opt_value,sizeof(int)) == -1) 
    {
        printf("HI_SetSockOpt failed!\n");
        return -1;
    }
    
    socket_opt_value = 0xFFFFFFFF;
    if (HI_SetSockOpt(pRecv->sock,SOL_SOCKET,SO_RCVBUF,(void*)(&socket_opt_value),sizeof(int)) == -1) 
    {
        
    }
    local_addr.sin_family = AF_INET; // host byte order
    local_addr.sin_port  =  htons(pRecv->listen_port); // short, network byte order
    local_addr.sin_addr.s_addr = htonl(INADDR_ANY);// automatically fill with my IP

    memset(&(local_addr.sin_zero), '\0', 8); // zero the rest of the struct    
    if (HI_Bind(pRecv->sock, (struct sockaddr *)&local_addr, sizeof(struct sockaddr)) == -1) 
    {
        printf("<RTP>socket bind error.\n"); 
        return -1;
    }

    printf("<RTP> Receiver socket create ok.\n");

 


    *ppRtpStream = pRecv;

    
    return HI_SUCCESS;
}

static HI_VOID* HI_RTP_RecvHandle(HI_VOID* args)
{
    RTP_RECV_S   *pRtpStream = NULL;
    HI_U8         RtpRecvBuff[RPT_MAX_PACKET_BUFF];
    struct sockaddr from;
    struct timeval tv;
    HI_S32 from_len = 0;

    HI_S32 nRet = 0;
    HI_S32 nByteRecv = 0;

    fd_set readfds;
    
    printf ("the address: %x\n", RtpRecvBuff);
    if (NULL == args)
    {
        printf("<RTP>recv thread create error. pass null para.\n"); 
        return NULL;
    }

    
        pRtpStream  = (RTP_RECV_S*)args;
        from_len = sizeof(struct sockaddr);
    
    if (pRtpStream->sock == 0)
    {
        printf("<RTP>recv thread create error. no active socket.\n"); 
        return NULL;
    }
    
    
    printf("<RTP>Receiver thread start ok!\n");

    tv.tv_sec = 0;
    tv.tv_usec = 5000;
    
    pRtpStream->runState = RTP_RUNSTATE_RUNNING ;

    while(pRtpStream->runState == RTP_RUNSTATE_RUNNING)
    {
        tv.tv_sec = 0;
        tv.tv_usec = 50000;
        
        memset(RtpRecvBuff, 0, RPT_MAX_PACKET_BUFF);        
        
        FD_ZERO(&readfds);
        FD_SET(pRtpStream->sock, &readfds);

        nRet = select(pRtpStream->sock + 1, &readfds, NULL, NULL, &tv);

        if(nRet == -1)
        {
            //printf("<RTP-Error> Receiver select error. %s", strerror(errno));
        }
        else if (nRet == 0)
        {
            //printf("<RTP-Error>TimeOut times: %llu", ++pRtpStream->stats.timeout_cnt);
        }
        else
        {
            if(FD_ISSET(pRtpStream->sock, &readfds))
            {
                nByteRecv = HI_Recvfrom(pRtpStream->sock, RtpRecvBuff, RPT_MAX_PACKET_BUFF, 0, &from, &from_len);
                //printf("<RTP>Recv--port: %d------ %d bytes.\n", pRtpStream->listen_port, nByteRecv);
                if (nByteRecv > 0 )
                {
                    /* Stat recv bytes */
                    pRtpStream->stats.recv_byte += nByteRecv;
                    pRtpStream->stats.recv_packet++;
                    
                    if (pRtpStream->rtp_on_recv)
                    {
                        if(1 != pRtpStream->rtp_on_recv(pRtpStream, RtpRecvBuff, nByteRecv, pRtpStream->ext_args))
                        {
                            return NULL;
                        }
                    }
                }
                else
                {
                    printf("<RTP-ERROR>winsocket error code: %d", errno);
                }
            }
            else
            {
                printf("<RTP>unknown error. ");
            }
        }
    }
    printf("end of rtp handle\n");
    return NULL;
}

/* 开启接收服务 */                  
HI_S32 HI_RTP_Recv_Start(IN RTP_RECV_S * pRtpStream)
{
    //void * thdRet;

    if (NULL == pRtpStream)
    {
        printf("<RTP>null pointer input.\n"); 
        return -1;
    }
    
    pthread_create(&(pRtpStream->thd), NULL, HI_RTP_RecvHandle, (HI_VOID*)pRtpStream);
    return HI_SUCCESS;
}

HI_S32 HI_RTP_Recv_Stop(IO RTP_RECV_S * pRtpStream)
{
    if (pRtpStream)
    {
        pRtpStream->runState = RTP_RUNSTATE_STOP ;
    }
    return (HI_S32)pthread_join(pRtpStream->thd, NULL);
}

HI_S32 HI_RTP_Recv_Destroy(IO RTP_RECV_S *pRtpStream)
{
    if (pRtpStream == NULL)
    {