video_decode.c

sample on embedded linux

        return HI_SUCCESS;
    }
    
    if (pRtpStream->runState == RTP_RUNSTATE_RUNNING)
    {
        HI_RTP_Recv_Stop(pRtpStream);
    }
    HI_CloseSocket(pRtpStream->sock);

    return HI_SUCCESS;
    
}


HI_PORT HI_SOCKET_Udp_GetPort(HI_SOCKET fd)
{
    int namelen = sizeof(struct sockaddr_in);
    struct sockaddr_in *s;
    
    if (getsockname (fd, (struct sockaddr *) s, &namelen))
    {
        return 0;
    }
    return ntohs( s->sin_port );
}

HI_SOCKET HI_SOCKET_Udp_Open(HI_PORT port)
{
    HI_SOCKET fd;
    struct sockaddr_in addr;

    if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        printf("UDP Socket Open error: create socket error.\n");
        return -1;
    }

    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);
    memset(&(addr.sin_zero), '\0', 8); // zero the rest of the struct

    if (bind (fd, (struct sockaddr *)&addr, sizeof (addr)))
    {
        HI_CloseSocket(fd);
        printf("UDP Socket Open error: bind socket error.\n");
        return -1;
    }
    #if 0
    /* set to non-blocking */
    if (ioctlsocket(f, FIONBIO, &on) < 0)
    {
        WRITE_LOG_DEBUG("UDP Socket Open error: set to nonblock mode error.\n");
        return -1;
    }
    #endif
    return fd;
}

#define RTP_DEFAULT_SSRC 41030
HI_S32 HI_RTP_Sender_Create(RTP_SENDER_S ** ppRtpStream, RTP_PT_E    pt)
{
    RTP_SENDER_S* pSender;
    
    HI_SOCKET sock;
    HI_PORT port = 0;
    
    pSender = (RTP_SENDER_S*)malloc(sizeof(RTP_SENDER_S));
    if (NULL == pSender)
    {
        printf("create new rtp sender error. not enough memory.\n");
        return -1;
    }
    
    memset(pSender, 0 , sizeof(RTP_SENDER_S));

    //INIT_LIST_HEAD(&pSender->targethosts);
    memset(pSender->targethosts, 0, sizeof(pSender->targethosts));

    pSender->bActive = HI_FALSE;
    pSender->last_ts = 3600;
    *ppRtpStream = pSender;
    pSender->pt = pt;
    pSender->ssrc = RTP_DEFAULT_SSRC;

    sock = HI_SOCKET_Udp_Open(0);
    
    if (sock < 0 ) 
    {
        printf("<RTP>create socket error.\n"); 
        return -1;
    }

    port = HI_SOCKET_Udp_GetPort(sock);
        
    if (port & 0x1) /*奇数*/
    {
        pSender->rtcpport = port;
        close(sock);
        
        port -= 1;
        sock = HI_SOCKET_Udp_Open(0);
        
        if ( sock < 0 ) 
        {
            printf("<RTP>create socket error.\n"); 
            return -1;
        }
        port = HI_SOCKET_Udp_GetPort(sock);
    }
    
    pSender->rtpport = port;    
    pSender->rtcpport = port + 1;
    pSender->sock = sock;

    int yes = 1;
    if (setsockopt(pSender->sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) 
    {
        printf("HI_ERR_RTP_SOCKET\n");
        return -1;
    }

    
    printf("Create RTP Sender at port: %d", pSender->rtpport );
    
    return HI_SUCCESS;
    
}

RTP_TARGETHOST_S* HI_RTP_Sender_Find(IN RTP_SENDER_S* pRtpStream,
                         IN HI_CHAR* ip,
                         IN HI_PORT  port)
{
    int i = 0;
    for (i = 0 ; i < RTP_MAX_SENDER ; i++)
    {
        
        if ((strcmp(ip, pRtpStream->targethosts[i].remote_ip) == 0) && 
            (port == pRtpStream->targethosts[i].remote_port))
        {
            return (&pRtpStream->targethosts[i]);
        }
    }
    return NULL;
}

RTP_TARGETHOST_S* HI_RTP_Sender_FindAvail(IN RTP_SENDER_S* pRtpStream)
{
    int i = 0;
    for (i = 0 ; i < RTP_MAX_SENDER ; i++)
    {
        if (pRtpStream->targethosts[i].bActive == HI_FALSE)
        {
            //WRITE_LOG_DEBUG("rtp host avail %d \n", i);
            return (&pRtpStream->targethosts[i]);
        }
        
    }
    return NULL;
    
}

HI_S32 HI_RTP_Sender_Add(IN RTP_SENDER_S* pRtpStream,
                         IN HI_CHAR* ip,
                         IN HI_PORT  port)
{
    RTP_TARGETHOST_S* pTarget = NULL;
    printf("rtp sender add ip, %s:%d", ip, port);
    pTarget = HI_RTP_Sender_Find(pRtpStream, ip, port);

    if (pTarget == NULL)
    {
        pTarget = HI_RTP_Sender_FindAvail(pRtpStream);

        if (pTarget == NULL)
        {
            return -1;
        }
        memset(pTarget, 0 , sizeof(RTP_TARGETHOST_S));
        strcpy(pTarget->remote_ip, ip);
        pTarget->remote_port = port;

        pTarget->remote_addr.sin_family = AF_INET; // host byte order
        pTarget->remote_addr.sin_port = htons(pTarget->remote_port); // short, network byte order
        pTarget->remote_addr.sin_addr.s_addr = inet_addr(pTarget->remote_ip);
        memset(&(pTarget->remote_addr.sin_zero), '\0', 8); // zero the rest of the struct

    }
    pTarget->hostState = RTP_TARGETHOST_STATE_REQ_IFrame;
    pTarget->bActive = HI_TRUE; 

    return HI_SUCCESS;
}

/*带有同步头*/
HI_S32 HI_RTP_Packet(IN RTP_SENDER_S * pRtpStream , HI_S32 ts_inc, HI_U32 marker,
                 HI_CHAR *pPayload, HI_S32 len)
{
    RTP_HDR_S* pRtpHdr = NULL;


    memset(pRtpStream->buff, 0, RPT_MAX_PACKET_BUFF);
    pRtpStream->buffLen = 0;
    
    pRtpHdr = (RTP_HDR_S*)pRtpStream->buff;

    RTP_HDR_SET_VERSION(pRtpHdr, RTP_VERSION);
    RTP_HDR_SET_P(pRtpHdr, 0);
    RTP_HDR_SET_X(pRtpHdr, 0);
    RTP_HDR_SET_CC(pRtpHdr, 0);

    RTP_HDR_SET_M(pRtpHdr, marker);
    RTP_HDR_SET_PT(pRtpHdr, pRtpStream->pt);

    RTP_HDR_SET_SEQNO(pRtpHdr, htons(pRtpStream->last_sn));
    
    RTP_HDR_SET_TS(pRtpHdr, htonl(pRtpStream->last_ts));

    RTP_HDR_SET_SSRC(pRtpHdr, htonl(pRtpStream->ssrc));
    
    pRtpStream->last_sn++;
    pRtpStream->last_ts   += ts_inc;
        
    memcpy(pRtpStream->buff + RTP_HDR_LEN, pPayload, len);

    pRtpStream->buffLen = RTP_HDR_LEN + len;

    return HI_SUCCESS;
}


HI_S32 HI_RTP_Send(IN RTP_SENDER_S * pRtpStream)
{
    RTP_TARGETHOST_S* pHost = NULL;
    HI_S32 iRet;
    int i = 0;

    for(i = 0;i < RTP_MAX_SENDER;i++)
    {
        pHost = &pRtpStream->targethosts[i];
        //WRITE_LOG_DEBUG("***Active: %d, BuffLen: %d, hostState:%d**\n", 
        //    pHost->bActive ,pRtpStream->buffLen ,pHost->hostState );
        if (pHost->bActive && pRtpStream->buffLen > 0 )
        {
            iRet = sendto(pRtpStream->sock, pRtpStream->buff, 
                              pRtpStream->buffLen, 0, 
                              (struct sockaddr*)&pHost->remote_addr, 
                              sizeof(struct sockaddr) );
            
            if (iRet != pRtpStream->buffLen)
            {
                perror("send rtp error.");
                pRtpStream->stats.sent_error++;
                printf("<RTP>send packet error. %s", strerror(errno));
                //HI_ERRNO(HI_ERR_RTP_SEND);
            }
            else
            {
                pRtpStream->stats.sent_byte += pRtpStream->buffLen;
                pRtpStream->stats.sent_packet++;
            }
            if (pRtpStream->buffLen <= 16)
                exit(-1);
            
        }
    }
    
    return HI_SUCCESS;
}
/********************rtp over************************/

/*task for decode net data*/
HANDLE HBuf[4];
int u32Test = 100;
#define default_port 6666 /*0:default_port 1:default_port + 1, 2:default_port + 2, 3:default_port + 3*/
HI_VOID threadSendBufData2Vdec (HI_VOID *parm)
{
    HI_S32 u32Ret;
    HI_U32 chnId = (HI_U32)parm;
    VDEC_STREAM_S stream;
        
    while(g_StopFlieFlag != HI_TRUE)
    {
        u32Ret = HI_DVS_GetDataFromBuf(HBuf[chnId], (HI_CHAR **)&stream.Dataaddr, &stream.Datalen, (HI_U32 *)&stream.pts);
        if (HI_SUCCESS != u32Ret)
        {
            usleep (100);
            continue;
        }
                
        u32Ret = HI_VDEC_SendStream (chnId, &stream, HI_TRUE);
        while (HI_SUCCESS != u32Ret)
        {
            if(HI_ERR_VDEC_NO_PAYLOAD == u32Ret)break;
            u32Ret = HI_VDEC_SendStream (chnId, &stream, HI_TRUE);            
        }
        
    }
    pthread_exit(0);
}

RTP_RECV_S* pRtpRecvStream[4];

HI_S32 GetDataFromNet (IN struct hiRTP_RECV_S  * pRtpStream, unsigned char * pBuff,  unsigned int len, int *ext_args)
{
    HI_U16 chnId;
    RTP_HDR_S *pheader = (RTP_HDR_S *)pBuff;
    HI_CHAR pTmp[2048] ;
    HANDLE handle;
    
    chnId = pRtpStream->listen_port - default_port;
    
    HI_DVS_SendDataToBuf(HBuf[chnId], (HI_CHAR *)(pBuff + 12), len - 12, pheader->ts);
    
    return 1;
}
/*send data to video deocoder*/
void decDataFromNet(HI_U32 fileCount)
{
    pthread_t vdecThread[4];
    pthread_t netThread[4];

    /*open 4 vo and vdec channel*/
    int i = 0;

    for (i = 0; i < fileCount; i++)
    {   
        HI_DVS_DEC_Open (i, g_Mode);
    }

    /*init the buffer*/
    for (i = 0; i < fileCount; i++)
    {   
        HI_DVS_CreateBuf(&HBuf[i]);
        printf ("the addr creat: %x\n", HBuf[i]);
    }

    /*open 4 thread to send stream to video decoder*/
    for (i = 0; i < fileCount; i++)
    {
        pthread_create(&vdecThread[i], NULL, (void *)threadSendBufData2Vdec, (void *)i);
    }

    /*open 4 thread , receive data with udp*/
    for (i = 0; i < fileCount; i++)
    {
        /*0:default_port 1:default_port + 1, 2:default_port + 2, 3:default_port + 3*/
        if (HI_SUCCESS == HI_RTP_Recv_Create(&pRtpRecvStream[i], default_port + i, GetDataFromNet, &i))
        {
            printf("Create RTP Recevier OK.\n");
        }

        /*启动rtp接收线程*/
        HI_RTP_Recv_Start(pRtpRecvStream[i]);
    }
 
    printf("deccode stream form network\n");
    return;
}


static HI_S32 parsearg(int argc)
{
	HI_S32 hiRet;
    VENC_CHN venc_chn;
    if (0 == strcmp("switch", args[0]) && strlen(args[1]) != 0 && argc == 2)
    {
                
    }
    else if (0 == strcmp("decfiles", args[0]) && argc <=5)
    {
        pthread_t decThread;
        static int  fileCount;        
        fileCount = argc - 1;
        pthread_create (&decThread, NULL, (void *)decMulFileWithSinThread, &fileCount);
        return HI_SUCCESS;        
    }
    else if (0 == strcmp("decfilestop", args[0]) && argc == 2)
    {
        g_StopFlieFlag = HI_TRUE;
        return HI_SUCCESS;
    }
    else if (0 == strcmp("decfilem", args[0]) && argc <=5)
    {
        pthread_t decThread;
        static int  fileCount;        
        fileCount = argc - 1;
        decMulFileWithMulThread(fileCount);
        return HI_SUCCESS;        
    }
    else if (0 == strcmp("decnet", args[0]))
    {
        decDataFromNet(4);  
        return HI_SUCCESS;
    }
    else
	{
	    printf("use \"rtsp://10.71.148.181/x\" to get channle x's stream\n\n");
	    
	    printf("cmd: \n");
	    printf("decfiles               : decfile with a single thread\n");
        printf("decfilem f1 f1 f3 f4   : decode file with multiple thread\n");
	    printf("decnet                 : dec data stream from net x\n");
	    printf("q                      : exit\n");
	}
    
    return HI_SUCCESS;
}
static int adjust_str(char *ptr)
{
	int i;
	while(*ptr==' ' && *ptr++ != '\0');

	for(i=strlen(ptr);i>0;i--)
	{
		if(*(ptr+i-1) == 0x0a || *(ptr+i-1) == ' ')
			*(ptr+i-1) = '\0';
		else
			break;
	}

	for(i=0;i<10;i++)
	{
		int j = 0;
		while(*ptr==' ' && *ptr++ != '\0');
		
		while((*ptr !=' ') && (*ptr!='\0'))
		{
			args[i][j++] = *ptr++;
		}

		args[i][j] = '\0';
		if('\0' == *ptr)
		{
			i++;
			break;
		}
		args[i][j] = '\0';
	}

	return i;
}

int main(int argc, char* argv[])
{
    char buffer[256];
    char *ptr;    
    HI_S32 hiRet, i;
    
    printf("Sample: ./dvsdemo mode normal\n");
    printf("mode[qcif~0 cif~1 hd1~2 d1~3 md1~4 qvga~5 vga~6 sxga~7], normal[n~0 p~1]\n");
    printf("------------------------------------------------------------------------\n");
    
    if(argc >= 2)
    {
        if(0 == strcmp("cif", argv[1]))
        {
            g_Mode = MODE_CIF;
        }
        else if(0 == strcmp("hd1", argv[1]))
        {
            g_Mode = MODE_HD1;
        }
        else if(0 == strcmp("d1", argv[1]))
        {
            g_Mode = MODE_D1;
        }
    }

    if(argc >= 3)
    {
        if(0 == strcmp("p", argv[2]))
        {
            g_Normal = PAL;
        }
        else if(0 == strcmp("n", argv[2]))
        {
            g_Normal = NTSC;
        }
    }
    
    printf("Mode set as %d, normal set as %d\n", g_Mode, g_Normal);

    HI_DVS_DEC_init ();
    for(;;)
    {
        printf("> ");
        ptr = fgets(buffer, 255, stdin);

        memset(args, 0, sizeof(args));
        argc = adjust_str(ptr);
        if(0 == strcmp("q", args[0]) || 0 == strcmp("Q", args[0]))
        {
            printf("Please wait...\n");
            sleep(1);
           return 0;
        }
        parsearg(argc);
    }
    HI_DVS_DEC_DeInit();
    return 0;
}