mp4dec.h

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

        ((Ipp32u*)(pDst))[i+5] = v; \
        ((Ipp32u*)(pDst))[i+6] = v; \
        ((Ipp32u*)(pDst))[i+7] = v; \
    } \
}

#endif



#define mp4_MC_HP(pat, pRef, stepRef, pCur, stepCur, coeffMB, mv, rc) \
{ \
    if (pat) { \
        mp4_Add8x8HP_16s8u(pRef, stepRef, coeffMB, pCur, stepCur, mv, rc); \
    } else { \
        mp4_Copy8x8HP_8u(pRef, stepRef, pCur, stepCur, mv, rc); \
    } \
}


#define mp4_AddResidual(pat, pc, stepc, coeffMB) \
{ \
    if (pat) { \
        mp4_Add8x8_16s8u(pc, coeffMB, stepc); \
    } \
}


#define mp4_DCTInvCoeffsIntraMB(coeffMB, lnz, pFc, stepFc) \
{ \
    int  i; \
    for (i = 0; i < 6; i ++) { \
        if (lnz[i] > 0) \
            ippiDCT8x8Inv_16s8u_C1R(&coeffMB[i*64], pFc[i], stepFc[i]); \
        else \
            mp4_Set8x8_8u(pFc[i], stepFc[i], (Ipp8u)((coeffMB[i*64] + 4) >> 3)); \
    } \
}


#define mp4_ReconstructCoeffsIntraMB_SVH(pInfo, coeffMB, lnz, pat, quant) \
{ \
    int  i, pm = 32; \
    for (i = 0; i < 6; i ++) { \
        if (ippiReconstructCoeffsIntra_H263_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB+i*64, &lnz[i], pat & pm, quant, 0, IPPVC_SCAN_ZIGZAG, 0) != ippStsNoErr) \
            return MP4_STATUS_ERROR; \
        if (pat & pm) { \
            mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_AC); \
        } else { \
            mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_DC); \
        } \
        pm >>= 1; \
    } \
}


#define mp4_ReconstructCoeffsInterMB_SVH(pInfo, coeffMB, lnz, pat, quant) \
{ \
    if (pat) { \
        int  i, pm = 32; \
        for (i = 0; i < 6; i ++) { \
            if (pat & pm) { \
                if (ippiReconstructCoeffsInter_H263_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB+i*64, &lnz[i], quant, 0) != ippStsNoErr) \
                    return MP4_STATUS_ERROR; \
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C); \
            } else { \
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
            } \
            pm >>= 1; \
        } \
    } else { \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
    } \
}


#define mp4_DCTInvCoeffsInterMB_SVH(coeffMB, lastNZ, pat)  \
if (pat) { \
    int   i, lnz, pm = 32; \
    Ipp16s *coeff = coeffMB; \
    for (i = 0; i < 6; i ++) { \
        if ((pat) & pm) { \
            lnz = lastNZ[i]; \
            if (lnz != 0) { \
                if ((lnz <= 4) && (coeff[16] == 0)) \
                    ippiDCT8x8Inv_2x2_16s_C1I(coeff); \
                else if ((lnz <= 13) && (coeff[32] == 0)) \
                    ippiDCT8x8Inv_4x4_16s_C1I(coeff); \
                else \
                    ippiDCT8x8Inv_16s_C1I(coeff); \
            } else \
                mp4_Set64_16s((Ipp16s)((coeff[0] + 4) >> 3), coeff); \
        } \
        pm >>= 1; \
        coeff += 64; \
    } \
}


#define mp4_CheckDecodeGOB_SVH(pInfo, nmb, frGOB, curRow, quant) \
{ \
    nmb ++; \
    if (nmb == pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_macroblocks_in_gob && \
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number < (pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_gobs_in_vop - 1)) { \
        Ipp32u  code; \
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number ++; \
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_header_empty = 1; \
        code = mp4_ShowBits(pInfo, 17); /* check gob_resync_marker */ \
        if (code != 1) { \
            code = mp4_ShowBitsAlign(pInfo, 17);  /* check next aligned bits are gob_resync_marker */ \
            if (code == 1) \
                mp4_AlignBits(pInfo); \
        } \
        if (code == 1) { \
            mp4_FlushBits(pInfo, 17); \
            pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_header_empty = 0; \
            code = mp4_GetBits9(pInfo, 5); /* gob_number */ \
            /* //f if (pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number != code) error; */ \
            pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_frame_id = mp4_GetBits9(pInfo, 2); \
            pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.quant_scale = mp4_GetBits9(pInfo, 5); \
            quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.quant_scale; \
            frGOB = curRow + 1; \
        } \
        nmb = 0; \
    } \
}


#define mp4_DecodeMCInterBlock_SVH(pInfo, quant, pat, pRef, pCur, step, coeffMB, mv) \
{ \
    if (pat) { \
        int lnz; \
        if (ippiReconstructCoeffsInter_H263_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB, &lnz, quant, 0) != ippStsNoErr) { \
            mp4_Error("Error when decode coefficients of Inter block"); \
            return MP4_STATUS_ERROR; \
        } \
        if (lnz != 0) { \
            if ((lnz <= 4) && (coeffMB[16] == 0)) \
                ippiDCT8x8Inv_2x2_16s_C1I(coeffMB); \
            else if ((lnz <= 13) && (coeffMB[32] == 0)) \
                ippiDCT8x8Inv_4x4_16s_C1I(coeffMB); \
            else \
                ippiDCT8x8Inv_16s_C1I(coeffMB); \
        } else { \
            mp4_Set64_16s((Ipp16s)((coeffMB[0] + 4) >> 3), coeffMB); \
        } \
        mp4_Add8x8HP_16s8u(pRef, step, coeffMB, pCur, step, mv, 0); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C); \
    } else { \
        mp4_Copy8x8HP_8u(pRef, step, pCur, step, mv, 0); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
    } \
}


// reset Intra prediction buffer on new Video_packet
#define mp4_ResetIntraPredBuffer(pInfo) \
{ \
    mp4_IntraPredBlock  *b = pInfo->VisualObject.VideoObject.IntraPredBuff.dcB; \
    int                 i; \
    b[3].dct_dc = b[4].dct_dc = b[5].dct_dc = -1; \
    b = pInfo->VisualObject.VideoObject.IntraPredBuff.block; \
    for (i = 0; i <= pInfo->VisualObject.VideoObject.MacroBlockPerRow; i ++) { \
        b[i*6+0].dct_dc = b[i*6+1].dct_dc = b[i*6+2].dct_dc = b[i*6+3].dct_dc = b[i*6+4].dct_dc = b[i*6+5].dct_dc = -1; \
    } \
}


// reset B-prediction blocks on new row
#define mp4_ResetIntraPredBblock(pInfo) \
{ \
    pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[3].dct_dc = \
    pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[4].dct_dc = \
    pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[5].dct_dc = -1; \
}


// mark current MB as invalid for Intra prediction and rotate buffer
#define mp4_UpdateIntraPredBuffInvalid(pInfo, colNum) \
{ \
    mp4_IntraPredBlock  *b = &pInfo->VisualObject.VideoObject.IntraPredBuff.block[colNum*6+6]; \
    pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[3].dct_dc = b[3].dct_dc; \
    pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[4].dct_dc = b[4].dct_dc; \
    pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[5].dct_dc = b[5].dct_dc; \
    b[0].dct_dc = b[1].dct_dc = b[2].dct_dc = b[3].dct_dc = b[4].dct_dc = b[5].dct_dc = -1; \
    /* pInfo->VisualObject.VideoObject.IntraPredBuff.quant[colNum+1] = (Ipp8u)quant; */ \
}


#define mp4_ReconstructCoeffsInterMB(pInfo, coeffMB, lnz, pat, rvlc, scan, quant) \
{ \
    if (pat) { \
        int  i, pm = 32; \
        for (i = 0; i < 6; i ++) { \
            if (pat & pm) { \
                if (ippiReconstructCoeffsInter_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB+i*64, &lnz[i], rvlc, scan, pInfo->VisualObject.VideoObject.QuantInvInterSpec, quant) != ippStsNoErr) \
                    return MP4_STATUS_ERROR; \
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C); \
            } else { \
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
            } \
            pm >>= 1; \
        } \
    } else { \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
    } \
}


/* 2x2 and 4x4 DCT decision suitable for Classical Zigzag Scan only */
#define mp4_DecodeMCBlockInter_MPEG4(pat, pr, stepr, pc, stepc, mv, rt) \
{ \
    if (pat) { \
        int lnz; \
        if (ippiReconstructCoeffsInter_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB, &lnz, rvlc, scan, pInfo->VisualObject.VideoObject.QuantInvInterSpec, quant) != ippStsNoErr) { \
            mp4_Error("Error when decode coefficients of Inter block"); \
            return MP4_STATUS_ERROR; \
        } \
        if (pInfo->VisualObject.VideoObject.quant_type == 0 || (coeffMB[63] == 0)) { \
            if (lnz != 0) { \
                if ((lnz <= 4) && (coeffMB[16] == 0)) \
                    ippiDCT8x8Inv_2x2_16s_C1I(coeffMB); \
                else if ((lnz <= 13) && (coeffMB[32] == 0)) \
                    ippiDCT8x8Inv_4x4_16s_C1I(coeffMB); \
                else \
                    ippiDCT8x8Inv_16s_C1I(coeffMB); \
            } else { \
                mp4_Set64_16s((Ipp16s)((coeffMB[0] + 4) >> 3), coeffMB); \
            } \
        } else { \
            ippiDCT8x8Inv_16s_C1I(coeffMB); \
        } \
        mp4_Add8x8HP_16s8u(pr, stepr, coeffMB, pc, stepc, &mv, rt); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C); \
    } else { \
        mp4_Copy8x8HP_8u(pr, stepr, pc, stepc, &mv, rt); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
    } \
}


/* 2x2 and 4x4 DCT decision suitable for Classical Zigzag Scan only */
#define mp4_DecodeReconBlockInter_MPEG4(pat, pc, stepc) \
{ \
    if (pat) { \
        int lnz; \
        if (ippiReconstructCoeffsInter_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB, &lnz, rvlc, scan, pInfo->VisualObject.VideoObject.QuantInvInterSpec, quant) != ippStsNoErr) { \
            mp4_Error("Error when decode coefficients of Inter block"); \
            return MP4_STATUS_ERROR; \
        } \
        if (pInfo->VisualObject.VideoObject.quant_type == 0 || (coeffMB[63] == 0)) { \
            if (lnz != 0) { \
                if ((lnz <= 4) && (coeffMB[16] == 0)) \
                    ippiDCT8x8Inv_2x2_16s_C1I(coeffMB); \
                else if ((lnz <= 13) && (coeffMB[32] == 0)) \
                    ippiDCT8x8Inv_4x4_16s_C1I(coeffMB); \
                else \
                    ippiDCT8x8Inv_16s_C1I(coeffMB); \
                } else { \
                    mp4_Set64_16s((Ipp16s)((coeffMB[0] + 4) >> 3), coeffMB); \
                } \
            } else { \
                ippiDCT8x8Inv_16s_C1I(coeffMB); \
        } \
        mp4_Add8x8_16s8u(pc, coeffMB, stepc); \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C); \
    } else { \
        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); \
    } \
}



__INLINE int mp4_GetMacroBlockNumberSize(int nmb)
{
    int  nb = 0;
    nmb --;
    do {
        nmb >>= 1;
        nb ++;
    } while (nmb);
    return nb;
}

__INLINE int mp4_GetConvRatio(mp4_Info* pInfo)
{
    if (mp4_GetBit(pInfo) == 1)
        return 0;
    else
        return (mp4_GetBit(pInfo) == 0 ? 2 : 4);
}


//  decode cbpy for Inter nontransparent MB
__INLINE mp4_Status mp4_DecodeCBPY_P(mp4_Info* pInfo, int *yPattern, int mbType)
{
    Ipp32u      code;

    code = mp4_ShowBits9(pInfo, 6);
    if (mbType < IPPVC_MBTYPE_INTRA)
        *yPattern = 15 - mp4_cbpy4[code].code;
    else
        *yPattern = mp4_cbpy4[code].code;
    if (mp4_cbpy4[code].len == 255) {
        mp4_Error("Error when decode cbpy of P-VOP macroblock");
        return MP4_STATUS_ERROR;
    } else {
        mp4_FlushBits(pInfo, mp4_cbpy4[code].len);
        return MP4_STATUS_OK;
    }
}


extern mp4_Status mp4_DecodeMVD(mp4_Info *pInfo, int *mvdx,  int *mvdy, int fcode);
extern mp4_Status mp4_DecodeMV(mp4_Info *pInfo, IppMotionVector *mv, int fcode);
extern mp4_Status mp4_Decode4MV(mp4_Info *pInfo, IppMotionVector *mv, int fcode);
extern mp4_Status mp4_DecodeMV_Direct(mp4_Info *pInfo, IppMotionVector mvC[4], IppMotionVector mvForw[4], IppMotionVector mvBack[4], int TRB, int TRD, int modb, int comb_type);
extern mp4_Status mp4_DecodeMV_DirectField(mp4_Info *pInfo, int mb_ftfr, int mb_fbfr, IppMotionVector *mvTop, IppMotionVector *mvBottom, IppMotionVector *mvForwTop, IppMotionVector *mvForwBottom, IppMotionVector *mvBackTop, IppMotionVector *mvBackBottom, int TRB, int TRD, int modb);
extern mp4_Status mp4_DecodeIntraMB_SVH(mp4_Info *pInfo, int pat, int quant, Ipp8u *pR[], int stepR[]);
extern mp4_Status mp4_DecodeIntraMB_DP(mp4_Info *pInfo, Ipp16s dct_dc[], int x, int pat, int quant, int dcVLC, int ac_pred_flag, Ipp8u *pR[], int stepR[]);
extern mp4_Status mp4_DecodeIntraMB(mp4_Info *pInfo, int x, int pat, int quant, int dcVLC, int ac_pred_flag, Ipp8u *pR[], int stepR[]);
extern mp4_Status mp4_DecodeInterMB(mp4_Info *pInfo, Ipp16s *coeffMB, int quant, int pat, int scan);
extern mp4_Status mp4_ReconstructCoeffsIntraMB(mp4_Info *pInfo, int x, int pat, int quant, int dcVLC, int ac_pred_flag, Ipp16s *coeff, int lnz[]);
extern mp4_Status mp4_DecodeMCBPC_P(mp4_Info* pInfo, int *mbType, int *mbPattern, int stat);
extern mp4_Status mp4_PredictDecode1MV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int y, int x);
extern mp4_Status mp4_PredictDecode4MV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int y, int x);
extern mp4_Status mp4_PredictDecodeFMV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int y, int x, IppMotionVector *mvT, IppMotionVector *mvB);
extern mp4_Status mp4_DecodeVideoObjectPlane(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_I(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_P(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_B(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_S(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_I_MT(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_P_MT(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_B_MT(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_S_MT(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVOP_I_Shape(mp4_Info* pInfo);
extern void mp4_DCTInvCoeffsInterMB(mp4_Info *pInfo, Ipp16s *coeffMB, int lnz[], int pat, int scan);
extern void mp4_PadFrame(mp4_Info* pInfo);
extern void mp4_OBMC(mp4_Info *pInfo, mp4_MacroBlock *pMBinfo, IppMotionVector *mvCur, int colNum, int rowNum, IppiRect limitRectL, Ipp8u *pYc, int stepYc, Ipp8u *pYr, int stepYr, int cbpy, Ipp16s *coeffMB, int dct_type);


extern void mp4_DecodeBABtype(mp4_Info* pInfo, int colNum, int rowNum, mp4_ShapeInfo *curShapeInfo, int mbPerRow);
extern Ipp8u mp4_CheckTransparency(Ipp8u *p, int step);


#ifdef __cplusplus
}
#endif

#endif  //_MP4DEC_H_