video_decode.c

sample on embedded linux

    pthread_t SendStream2Vo;
    int u32Chn;
    u32Chn = chnId;

    /*
      if the stream from newwork we don't need to control the framerate
      else if the stream form the file we need to control the framerate
    */
#if 0
    pthread_create (&SendStream2Dec, NULL, HI_DVS_DEC_SendStream2Dec, (void *)u32Chn);
#endif
    pthread_create (&SendStream2Vo, NULL, HI_DVS_DEC_SendStream2VO, (void *)u32Chn);

    return HI_SUCCESS;
}


int HI_DVS_DEC_init ()
{
    int ret;
    
    /*start video decode task,with D1 mode ,don't change it */
    ret = HI_DVS_DEC_CreateAllDecodeCH();
    if (HI_SUCCESS != ret)
    {
        HI_DVS_DEC_DEBUG("create all decode channel failed\n");
        goto decodeErr;
    }
    /*init VO public*/
    ret = HI_DVS_DEC_CreateAllVoCH(g_Normal, g_Mode);
    if (HI_SUCCESS != ret)
    {
        HI_DVS_DEC_DEBUG("create all decode channel failed\n");
        goto voErr;
    }
    return HI_SUCCESS;
voErr:
    HI_DVS_DEC_DestroyAllVoCH();
decodeErr:    
    HI_DVS_DEC_DestroyAllDecodeCH();

    return HI_FAILURE;    
}
int HI_DVS_DEC_TaskSwitch (int normal, int DisPlayMode)
{
    int i;
    int ret;
    
    /*close all the channel*/
    for (i = 0; i < 4; i ++)
    {
        HI_DVS_DEC_Close(i);
    }
    sleep (1);
    /*close vo */
    ret = HI_DVS_DEC_DestroyAllVoCH();
    if (HI_SUCCESS != ret)
    {
         HI_DVS_DEC_DEBUG("destroy all vo  failed\n");
    }
    /*open vo in new mode*/
    ret = HI_DVS_DEC_CreateAllVoCH(normal, DisPlayMode);
    if (HI_SUCCESS != ret)
    {
         HI_DVS_DEC_DEBUG("create all vo failed\n");
    }
    return ret; 
}
int HI_DVS_DEC_Open(int chnId, int mode)
{
    if ((chnId < 0)|| (chnId > 3))
    {
        HI_DVS_DEC_DEBUG("the channel id out of range");
        return HI_FAILURE;
    }

    if ((mode < 0) || (mode > 2))
    {
        HI_DVS_DEC_DEBUG("the channel id out of range");
        return HI_FAILURE;
    }

    /*change the work mode*/
    if (g_Mode != mode)
    {
        g_Mode = mode;
        HI_DVS_DEC_TaskSwitch (g_Normal, g_Mode);
    }

	/*reopen the same channel*/
	if (START_TASK == g_ChnStatus[chnId])
	{
		printf("reopen the same channel: %d\n", chnId);
        return HI_SUCCESS;
	}
    /*set the start flag, this flag must be at front*/
    g_ChnStatus[chnId] = START_TASK;
    
	printf ("open channel: %d\n", chnId);
    /*start the thread for VO and Vdec*/
    HI_DVS_DEC_StartDataStream(chnId);

    return HI_SUCCESS;
}

int HI_DVS_DEC_Close(int chnId)
{
    if ((chnId < 0)|| (chnId > 3))
    {
        HI_DVS_DEC_DEBUG("the channel id out of range");
        return HI_FAILURE;
    }
	printf ("close task channel: %d\n", chnId);
    g_ChnStatus[chnId] = STOP_TASK;
    return HI_SUCCESS;
}

int HI_DVS_DEC_GetStatus(int chnID, int*pMode)
{
    /*all the channel with the same mode*/
    *pMode = g_Mode;
    return HI_SUCCESS;
}

int HI_DVS_DEC_DeInit ()
{
    int i;
    /*close all the task channel*/
    for (i = 0; i < 4; i ++)
    {
        HI_DVS_DEC_Close(i);
    }   

    /*close all the decode*/
    HI_DVS_DEC_DestroyAllDecodeCH();

    /*close vo device*/
    HI_DVS_DEC_DestroyAllVoCH();

    return HI_SUCCESS;
}

/*this is used for read data from file*/
#define FILE_BUFFER 10240
typedef struct hiFILE_BUFFER_S
{
    FILE   *pFile;
    HI_U32  u32FileLen;
    
    HI_U32  u32BufEndPos;
    HI_U32  u32BufCurPos;
    HI_U32  u32BufLen;
    HI_U8   u8Buf[FILE_BUFFER];
} FILE_BUFFER_S;

int File_Init(FILE_BUFFER_S *pFileBuf, char *fname)
{
    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);
    
    pFileBuf->u32BufCurPos = 0;
    pFileBuf->u32BufEndPos = 0;
    pFileBuf->u32BufLen    = FILE_BUFFER;

    pFileBuf->pFile        = fopen(fname, "rb");
    ASSERT_RETURN((NULL != pFileBuf->pFile), HI_FAILURE);

    printf("File %s is Open!\n", fname);
    
    fseek(pFileBuf->pFile, 0, SEEK_END);
    pFileBuf->u32FileLen = ftell(pFileBuf->pFile);

    rewind(pFileBuf->pFile);
    
}

int File_DeInit(FILE_BUFFER_S *pFileBuf)
{
    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);
    ASSERT_RETURN((NULL != pFileBuf->pFile), HI_FAILURE);

    fclose(pFileBuf->pFile);

    return HI_SUCCESS;
}

/* Read stream from file */
int File_ReadStream(FILE_BUFFER_S *pFileBuf)
{
    int readlen, nFillPos, nFillLen;
    FILE *pFile;
    
    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);
    ASSERT_RETURN((NULL != pFileBuf->pFile), HI_FAILURE);

    nFillPos = pFileBuf->u32BufEndPos;
    nFillLen = pFileBuf->u32BufLen - pFileBuf->u32BufEndPos;
    pFile    = pFileBuf->pFile;

    if(feof(pFile))
    {
        return -1;
    }

    if(pFileBuf->u32FileLen  > nFillLen + ftell(pFile))
    {
        readlen = fread(&pFileBuf->u8Buf[nFillPos], nFillLen, 1, pFile);
        ASSERT_RETURN((1 == readlen), HI_FAILURE);

        readlen = nFillLen;
    }
    else
    {
        readlen = fread(&pFileBuf->u8Buf[nFillPos], 1, nFillLen, pFile);
        ASSERT_RETURN((readlen > 0), HI_FAILURE);
    }
    
    pFileBuf->u32BufEndPos = nFillPos + readlen;

    return HI_SUCCESS;
}

/* Get one slice from the file buffer */
int File_SearchNextSlice(FILE_BUFFER_S *pFileBuf)
{
    int      nPos, nSliceLen = -1;
    HI_U8   *pu8Buf;

    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);

    nPos   = pFileBuf->u32BufCurPos + 4;
    pu8Buf = pFileBuf->u8Buf;
    
    if (nPos + 4 > pFileBuf->u32BufEndPos)
    {
        return -1;
    }

    while((pu8Buf[nPos] !=0x00)   || (pu8Buf[nPos+1]!=0x00) ||
          (pu8Buf[nPos+2] !=0x00) || (pu8Buf[nPos+3]!=0x01))
    {
        nPos ++;
        if (nPos + 4 >= pFileBuf->u32BufEndPos)
        {
            break;
        }
    }
    
    if (nPos + 4 < pFileBuf->u32BufEndPos)
    {
        nSliceLen = nPos - pFileBuf->u32BufCurPos;
    }
    else
    {
        return -1;
    }
    
    return  nSliceLen;
}

int File_CopyData2Head(FILE_BUFFER_S *pFileBuf)
{
    HI_U8   *pu8Buf;
    int      nCurPos, nLen;

    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);

    pu8Buf  = pFileBuf->u8Buf;
    nCurPos = pFileBuf->u32BufCurPos;
    nLen    = pFileBuf->u32BufEndPos - nCurPos;

    if(nLen > 0)
    {
        memmove (pu8Buf, &pu8Buf[nCurPos], nLen);
    }
    
    pFileBuf->u32BufEndPos = nLen;
    pFileBuf->u32BufCurPos = 0;

    return 0;
}

int File_GetSlice(FILE_BUFFER_S *pFileBuf, HI_U8 **ppAddr, HI_U32 *pLen)
{
    HI_S32 s32FileRet = HI_SUCCESS;
    HI_S32 s32SliceLen;
    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);

    while(1)
    {
        s32FileRet = HI_SUCCESS;
        if(pFileBuf->u32BufEndPos < pFileBuf->u32BufLen)
        {
            s32FileRet = File_ReadStream(pFileBuf);
        }

        s32SliceLen = File_SearchNextSlice(pFileBuf);
        if(s32SliceLen <= 0)
        {
            File_CopyData2Head(pFileBuf);
            s32SliceLen = pFileBuf->u32BufEndPos - pFileBuf->u32BufCurPos;
            if((s32SliceLen > 0))
            {
                /*
                ** If file is empty means this is the last slice.
                ** If file is not empty then read the file continue.
                */
                if(HI_SUCCESS != s32FileRet)
                {
                    *pLen   = s32SliceLen;
                    *ppAddr = pFileBuf->u8Buf;
                    pFileBuf->u32BufEndPos = 0;
                    break;
                }
            }
            else
            {
                if(HI_SUCCESS != s32FileRet)
                {
                    /* The file is empty means thers has no slice */
                    return HI_FAILURE;
                }
            }
        }
        else
        {
            *pLen   = s32SliceLen;
            *ppAddr = &(pFileBuf->u8Buf[pFileBuf->u32BufCurPos]);
            pFileBuf->u32BufCurPos += s32SliceLen;
            break;
        }
    }

    return HI_SUCCESS;
}

int File_Rewind(FILE_BUFFER_S *pFileBuf)
{
    
    ASSERT_RETURN((NULL != pFileBuf), HI_FAILURE);
    ASSERT_RETURN((NULL != pFileBuf->pFile), HI_FAILURE);
    rewind(pFileBuf->pFile);

    return HI_SUCCESS;
}
/*

*/
void decMulFileWithSinThread(void *param)
{
    /*open all the file*/
    int fileCount = *(int *)(param);
    FILE_BUFFER_S  fBuf[4];    
    unsigned char  *pAddr;
    VDEC_STREAM_S  vdecStream;
    int s32Len;
    int i = 0;
    int s32Ret;
    
    /*open the file to decode*/
    for (i = 0; i < fileCount; i++)
    {
        HI_DVS_DEC_Open (i, g_Mode);
        File_Init(&fBuf[i], args[i + 1]);
    }

    while (g_StopFlieFlag != HI_TRUE)
    {
        for (i = 0; i < fileCount; i++)
        {
            s32Ret = File_GetSlice(&fBuf[i], &pAddr, &s32Len);
            if (s32Ret != HI_SUCCESS)
                File_Rewind(&fBuf[i]);
            
            vdecStream.Dataaddr = (ADDR)pAddr;
            vdecStream.Datalen  = s32Len;
            vdecStream.pts      = 0;
            s32Ret = HI_VDEC_SendStream(i, &vdecStream, HI_TRUE);
            while (s32Ret != HI_SUCCESS)
            {
                if(HI_ERR_VDEC_NO_PAYLOAD == s32Ret)break;
                s32Ret = HI_VDEC_SendStream(i, &vdecStream, HI_TRUE);    
            }
            
            //usleep(1);
        }
    }
    
    /*send stream to video decoder*/
    for (i = 0; i < fileCount; i++)
    {
        File_DeInit(&fBuf[i]);
        HI_DVS_DEC_Close (i);
    }
    printf("exit thread_coding\n");
    return;
}

void* threadSend2vdec(void *parm)
{
    VDEC_CHN       vdec_chn = (int)parm;
    VDEC_STREAM_S  vdecStream;
    HI_S32         i,s32Ret;
    FILE_BUFFER_S  fBuf;
    HI_U8         *pAddr;
    HI_S32         s32Len;
    
    s32Ret = File_Init(&fBuf, args[vdec_chn + 1]);
    ASSERT_RETURN((HI_SUCCESS == s32Ret), NULL);
    
    while (g_StopFlieFlag != HI_TRUE)
    {
        //if(0 == vdec_chn){sleep(1); continue;}
        
        while(HI_SUCCESS == File_GetSlice(&fBuf, &pAddr, &s32Len))
        {
            vdecStream.Dataaddr = (ADDR)pAddr;
            vdecStream.Datalen  = s32Len;
            vdecStream.pts      = 0;
            s32Ret = HI_VDEC_SendStream(vdec_chn, &vdecStream, HI_TRUE);
            while (HI_SUCCESS != s32Ret)
            {
                if(HI_ERR_VDEC_NO_PAYLOAD == s32Ret)break;
                s32Ret = HI_VDEC_SendStream(vdec_chn, &vdecStream, HI_TRUE);
            }
            usleep(1);
            //if(HI_SUCCESS != s32Ret) printf("Channel %d Code 0x%08x\n", vdec_chn, s32Ret);
            //ASSERT_RETURN((HI_SUCCESS == s32Ret), NULL);
        }

        File_Rewind(&fBuf);
    }
    
    File_DeInit(&fBuf);
    
    printf("exit thread_coding\n");

    return NULL;
}
void decMulFileWithMulThread(int fileCount)
{
    /*open all the file*/
    pthread_t vdecThread[4];
    
    int i = 0;

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

    for (i = 0; i < fileCount; i++)
    {
        pthread_create(&vdecThread[i], NULL, (void *)threadSend2vdec, (void *)i);
    }
    printf("exit thread_coding\n");

    return ;
}

/*analy the net module*/
#define RECEIVEBUF_NUM 100
#define PACKET_HEADER_SIZE 8

typedef struct hiBUF_INFO_S
{
    HI_U32   u32ReadP;
    HI_U32   u32WriteP;
    HI_U32   u32RcvCount;
    HI_CHAR  u8RecBuf[RECEIVEBUF_NUM][2048+PACKET_HEADER_SIZE];/*it can be used for receive slice mode*/
}BUF_INFO_S;

typedef unsigned int HANDLE;

HI_S32 HI_DVS_CreateBuf (HANDLE * pHBuf)
{
    BUF_INFO_S *pBufInfo;
    
    /*malloc the memory for buffer*/    
    pBufInfo  = (BUF_INFO_S *)malloc (sizeof(BUF_INFO_S));
    if (HI_NULL_PTR == pBufInfo)
    {
        HI_DVS_DEC_DEBUG("malloc for create buffer failed\n");
        *pHBuf = (HANDLE)pBufInfo;
        return HI_FAILURE;
    }

    /*init the buffer struct*/
    pBufInfo->u32RcvCount = 0;
    pBufInfo->u32ReadP = 0;
    pBufInfo->u32WriteP = 0;
    memset (pBufInfo->u8RecBuf[0], 0, sizeof(pBufInfo->u8RecBuf));

    /*return the hannle to user*/
    *pHBuf = (HANDLE)pBufInfo;
    printf ("--------------->>>%d: addr:%x\n",sizeof(BUF_INFO_S), *pHBuf);
    return HI_SUCCESS;
}

/*release the buffer*/
HI_S32 HI_DVS_DestroyBuf (HANDLE HBuf)
{
    free ((HI_VOID *)HBuf);
    return HI_SUCCESS;
}

/*get data from buffer and send it to video decoder*/