Exemple #1
0
/******************************************************************************
* funciton : get stream from each channels and save them
******************************************************************************/
HI_VOID* SAMPLE_COMM_VENC_GetVencStreamProc(HI_VOID *p)
{
    HI_S32 i;
    HI_S32 s32ChnTotal;
    VENC_CHN_ATTR_S stVencChnAttr;
    SAMPLE_VENC_GETSTREAM_PARA_S *pstPara;
    HI_S32 maxfd = 0;
    struct timeval TimeoutVal;
    fd_set read_fds;
    HI_S32 VencFd[VENC_MAX_CHN_NUM];
    HI_CHAR aszFileName[VENC_MAX_CHN_NUM][64];
    FILE *pFile[VENC_MAX_CHN_NUM];
    char szFilePostfix[10];
    VENC_CHN_STAT_S stStat;
    VENC_STREAM_S stStream;
    HI_S32 s32Ret;
    VENC_CHN VencChn;
    PAYLOAD_TYPE_E enPayLoadType[VENC_MAX_CHN_NUM];
    
    pstPara = (SAMPLE_VENC_GETSTREAM_PARA_S*)p;
    s32ChnTotal = pstPara->s32Cnt;

    /******************************************
     step 1:  check & prepare save-file & venc-fd
    ******************************************/
    if (s32ChnTotal >= VENC_MAX_CHN_NUM)
    {
        SAMPLE_PRT("input count invaild\n");
        return NULL;
    }
    for (i = 0; i < s32ChnTotal; i++)
    {
        /* decide the stream file name, and open file to save stream */
        VencChn = i;
        s32Ret = HI_MPI_VENC_GetChnAttr(VencChn, &stVencChnAttr);
        if(s32Ret != HI_SUCCESS)
        {
            SAMPLE_PRT("HI_MPI_VENC_GetChnAttr chn[%d] failed with %#x!\n", \
                   VencChn, s32Ret);
            return NULL;
        }
        enPayLoadType[i] = stVencChnAttr.stVeAttr.enType;

        s32Ret = SAMPLE_COMM_VENC_GetFilePostfix(enPayLoadType[i], szFilePostfix);
        if(s32Ret != HI_SUCCESS)
        {
            SAMPLE_PRT("SAMPLE_COMM_VENC_GetFilePostfix [%d] failed with %#x!\n", \
                   stVencChnAttr.stVeAttr.enType, s32Ret);
            return NULL;
        }
        sprintf(aszFileName[i], "stream_chn%d%s", i, szFilePostfix);
        pFile[i] = fopen(aszFileName[i], "wb");
        if (!pFile[i])
        {
            SAMPLE_PRT("open file[%s] failed!\n", 
                   aszFileName[i]);
            return NULL;
        }

        /* Set Venc Fd. */
        VencFd[i] = HI_MPI_VENC_GetFd(i);
        if (VencFd[i] < 0)
        {
            SAMPLE_PRT("HI_MPI_VENC_GetFd failed with %#x!\n", 
                   VencFd[i]);
            return NULL;
        }
        if (maxfd <= VencFd[i])
        {
            maxfd = VencFd[i];
        }
    }

    /******************************************
     step 2:  Start to get streams of each channel.
    ******************************************/
    while (HI_TRUE == pstPara->bThreadStart)
    {
        FD_ZERO(&read_fds);
        for (i = 0; i < s32ChnTotal; i++)
        {
            FD_SET(VencFd[i], &read_fds);
        }

        TimeoutVal.tv_sec  = 2;
        TimeoutVal.tv_usec = 0;
        s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);
        if (s32Ret < 0)
        {
            SAMPLE_PRT("select failed!\n");
            break;
        }
        else if (s32Ret == 0)
        {
            SAMPLE_PRT("get venc stream time out, exit thread\n");
            continue;
        }
        else
        {
            for (i = 0; i < s32ChnTotal; i++)
            {
                if (FD_ISSET(VencFd[i], &read_fds))
                {
                    /*******************************************************
                     step 2.1 : query how many packs in one-frame stream.
                    *******************************************************/
                    memset(&stStream, 0, sizeof(stStream));
                    s32Ret = HI_MPI_VENC_Query(i, &stStat);
                    if (HI_SUCCESS != s32Ret)
                    {
                        SAMPLE_PRT("HI_MPI_VENC_Query chn[%d] failed with %#x!\n", i, s32Ret);
                        break;
                    }

                    /*******************************************************
                     step 2.2 : malloc corresponding number of pack nodes.
                    *******************************************************/
                    stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
                    if (NULL == stStream.pstPack)
                    {
                        SAMPLE_PRT("malloc stream pack failed!\n");
                        break;
                    }
                    
                    /*******************************************************
                     step 2.3 : call mpi to get one-frame stream
                    *******************************************************/
                    stStream.u32PackCount = stStat.u32CurPacks;
                    s32Ret = HI_MPI_VENC_GetStream(i, &stStream, HI_TRUE);
                    if (HI_SUCCESS != s32Ret)
                    {
                        free(stStream.pstPack);
                        stStream.pstPack = NULL;
                        SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", \
                               s32Ret);
                        break;
                    }

                    /*******************************************************
                     step 2.4 : save frame to file
                    *******************************************************/
                    s32Ret = SAMPLE_COMM_VENC_SaveStream(enPayLoadType[i], pFile[i], &stStream);
                    if (HI_SUCCESS != s32Ret)
                    {
                        free(stStream.pstPack);
                        stStream.pstPack = NULL;
                        SAMPLE_PRT("save stream failed!\n");
                        break;
                    }
                    /*******************************************************
                     step 2.5 : release stream
                    *******************************************************/
                    s32Ret = HI_MPI_VENC_ReleaseStream(i, &stStream);
                    if (HI_SUCCESS != s32Ret)
                    {
                        free(stStream.pstPack);
                        stStream.pstPack = NULL;
                        break;
                    }
                    /*******************************************************
                     step 2.6 : free pack nodes
                    *******************************************************/
                    free(stStream.pstPack);
                    stStream.pstPack = NULL;
                }
            }
        }
    }

    /*******************************************************
    * step 3 : close save-file
    *******************************************************/
    for (i = 0; i < s32ChnTotal; i++)
    {
        fclose(pFile[i]);
    }

    return NULL;
}
Exemple #2
0
HI_S32 main(int argc, char* argv[])
{
    HI_S32 s32Ret;
    HI_S32 s32EncChn;
    HI_CHAR para[16];
    HI_U32 value = 0;
    HI_U32 i;
    VENC_RC_MODE_E eMode;

    VENC_RC_PARAM_S stVencRcParam;
    VENC_CHN_ATTR_S stVencChnAttr;

    if (argc < 3)
    {
        USAGE_HELP();
        return -1;
    }
    s32EncChn = 0;
    s32EncChn = atoi(argv[1]);
    strcpy(para, argv[2]);

    s32Ret = HI_MPI_VENC_GetRcParam(s32EncChn, &stVencRcParam);
    CHECK_RET(s32Ret, "get Rc param");
    s32Ret = HI_MPI_VENC_GetChnAttr(s32EncChn, &stVencChnAttr);
    CHECK_RET(s32Ret, "get Rc Attr");

    eMode = stVencChnAttr.stRcAttr.enRcMode;


    if (0 == strcmp(para, "?"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            printf("\tstattime %d\n", stVencChnAttr.stRcAttr.stAttrH264Cbr.u32StatTime);
            printf("\tbitrate %d\n", stVencChnAttr.stRcAttr.stAttrH264Cbr.u32BitRate);
            printf("\tgop %d\n", stVencChnAttr.stRcAttr.stAttrH264Cbr.u32Gop);
            printf("\tqpdelta %d\n", stVencRcParam.stParamH264Cbr.s32IPQPDelta);
            printf("\tmaxqp %d\n", stVencRcParam.stParamH264Cbr.u32MaxQp);
        }
        else
        {
            printf("\tstattime %d\n", stVencChnAttr.stRcAttr.stAttrH265Cbr.u32StatTime);
            printf("\tbitrate %d\n", stVencChnAttr.stRcAttr.stAttrH265Cbr.u32BitRate);
            printf("\tgop %d\n", stVencChnAttr.stRcAttr.stAttrH265Cbr.u32Gop);
            printf("\tqpdelta %d\n", stVencRcParam.stParamH265Cbr.s32IPQPDelta);
            printf("\tmaxqp %d\n", stVencRcParam.stParamH265Cbr.u32MaxQp);
        }

        printf("\tmqpdelta %d\n", stVencRcParam.u32RowQpDelta);
        return 0;
    }
    value = atoi(argv[3]);
    printf("chn %d, para %s, value %d\n", s32EncChn, para, value);
    if (0 == strcmp(para, "stattime"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencChnAttr.stRcAttr.stAttrH264Cbr.u32StatTime = value;
        }
        else
        {
            stVencChnAttr.stRcAttr.stAttrH265Cbr.u32StatTime = value;
        }
    }
    if (0 ==  strcmp(para, "thresh") && argc == 15)
    {
        for (i = 0; i < 12; i++)
        {
            stVencRcParam.u32ThrdI[i] = atoi(argv[i + 3]);
            stVencRcParam.u32ThrdP[i] = atoi(argv[i + 3]);
        }
    }
    if (0 ==  strcmp(para, "pthresh") && argc == 15)
    {
        for (i = 0; i < 12; i++)
        {
            stVencRcParam.u32ThrdP[i] = atoi(argv[i + 3]);
        }
    }
    else if (0 == strcmp(para, "bitrate"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencChnAttr.stRcAttr.stAttrH264Cbr.u32BitRate = value;
        }
        else
        {
            stVencChnAttr.stRcAttr.stAttrH265Cbr.u32BitRate = value;
        }
    }
    else if ( 0 == strcmp(para, "framerate"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencChnAttr.stRcAttr.stAttrH264Cbr.fr32DstFrmRate = value;
        }
        else
        {
            stVencChnAttr.stRcAttr.stAttrH265Cbr.fr32DstFrmRate = value;
        }
    }
    else if (0 == strcmp(para, "gop"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencChnAttr.stRcAttr.stAttrH264Cbr.u32Gop = value;
        }
        else
        {

            stVencChnAttr.stRcAttr.stAttrH265Cbr.u32Gop = value;
        }
    }
    else if (0 == strcmp(para, "flut"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencChnAttr.stRcAttr.stAttrH264Cbr.u32FluctuateLevel = value;
        }
        else
        {
            stVencChnAttr.stRcAttr.stAttrH265Cbr.u32FluctuateLevel = value;
        }
    }
    else if (0 == strcmp(para, "qpdelta"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencRcParam.stParamH264Cbr.s32IPQPDelta = value;
        }
        else
        {
            stVencRcParam.stParamH265Cbr.s32IPQPDelta = value;
        }
    }
    else if (0 == strcmp(para, "maxqp"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencRcParam.stParamH264Cbr.u32MaxQp = value;

        }
        else
        {
            stVencRcParam.stParamH265Cbr.u32MaxQp = value;
        }
    }
    else if (0 == strcmp(para, "level"))
    {
        if (eMode == VENC_RC_MODE_H264CBR)
        {
            stVencRcParam.stParamH264Cbr.s32QualityLevel = value;
        }
        else
        {
            stVencRcParam.stParamH265Cbr.s32QualityLevel = value;
        }
    }
    else if (0 == strcmp(para, "mqpdelta"))
    {
        stVencRcParam.u32RowQpDelta = value;
    }
    else if ( 0 == strcmp(para, "deblock"))
    {
        VENC_PARAM_H264_DBLK_S stH264Dblk;
        s32Ret = HI_MPI_VENC_GetH264Dblk(0, &stH264Dblk);
        CHECK_RET(s32Ret, "get deblock");
        stH264Dblk.disable_deblocking_filter_idc = 2;
        stH264Dblk.slice_alpha_c0_offset_div2 = value;
        stH264Dblk.slice_beta_offset_div2 = value;
        s32Ret = HI_MPI_VENC_SetH264Dblk(0, &stH264Dblk);
        CHECK_RET(s32Ret, "get deblock");
    }

    s32Ret = HI_MPI_VENC_SetChnAttr(s32EncChn, &stVencChnAttr);
    CHECK_RET(s32Ret, "set Chn Attr");

    s32Ret = HI_MPI_VENC_SetRcParam(s32EncChn, &stVencRcParam);
    CHECK_RET(s32Ret, "set Rc param");

    return 0;
}