mp4dec.h

audio-video-codecs.rar语音编解码器

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

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

#define mp4_ReconstructCoeffsIntraMB_SVH(pInfo, coeffMB, lnz, pat, quant, err) \
{ \
    Ipp32s  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) { \
            mp4_Error("Error: decoding coefficients of Intra block"); \
            goto err; \
        } \
        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, err) \
{ \
    if (pat) { \
        Ipp32s  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) { \
                    mp4_Error("Error: decoding coefficients of Inter block"); \
                    goto err; \
                } \
                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) { \
    Ipp32s   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_DecodeMCInterBlock_SVH(pInfo, quant, pat, pRef, pCur, step, coeffMB, mv, err) \
{ \
    if (pat) { \
        Ipp32s lnz; \
        if (ippiReconstructCoeffsInter_H263_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB, &lnz, quant, 0) != ippStsNoErr) { \
            mp4_Error("Error: decoding coefficients of Inter block"); \
            goto err; \
        } \
        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; \
    Ipp32s              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, err) \
{ \
    if (pat) { \
        Ipp32s  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) { \
                    mp4_Error("Error: decoding coefficients of Inter block"); \
                    goto err; \
                } \
                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, err) \
{ \
    if (pat) { \
        Ipp32s lnz; \
        if (ippiReconstructCoeffsInter_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB, &lnz, rvlc, scan, pInfo->VisualObject.VideoObject.QuantInvInterSpec, quant) != ippStsNoErr) { \
            mp4_Error("Error: decoding coefficients of Inter block"); \
            goto err; \
        } \
        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, err) \
{ \
    if (pat) { \
        Ipp32s lnz; \
        if (ippiReconstructCoeffsInter_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeffMB, &lnz, rvlc, scan, pInfo->VisualObject.VideoObject.QuantInvInterSpec, quant) != ippStsNoErr) { \
            mp4_Error("Error: decoding coefficients of Inter block"); \
            goto err; \
        } \
        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 Ipp32s mp4_GetMacroBlockNumberSize(Ipp32s nmb)
{
    Ipp32s  nb = 0;
    nmb --;
    do {
        nmb >>= 1;
        nb ++;
    } while (nmb);
    return nb;
}

__INLINE Ipp32s 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, Ipp32s *yPattern, Ipp32s 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: decoding CBPY");
        return MP4_STATUS_ERROR;
    } else {
        mp4_FlushBits(pInfo, mp4_cbpy4[code].len);
        return MP4_STATUS_OK;
    }
}

//  decode cbpy for Intra nontransparent MB

__INLINE mp4_Status mp4_DecodeCBPY_I(mp4_Info* pInfo, Ipp32s *yPattern)
{
    Ipp32u      code;

    code = mp4_ShowBits9(pInfo, 6);
    *yPattern = mp4_cbpy4[code].code;
    if (mp4_cbpy4[code].len == 255) {
        mp4_Error("Error: decoding CBPY");
        return MP4_STATUS_ERROR;
    } else {
        mp4_FlushBits(pInfo, mp4_cbpy4[code].len);
        return MP4_STATUS_OK;
    }
}

extern mp4_Status mp4_DecodeMVD(mp4_Info *pInfo, Ipp32s *mvdx,  Ipp32s *mvdy, Ipp32s fcode);
extern mp4_Status mp4_DecodeMV(mp4_Info *pInfo, IppMotionVector *mv, Ipp32s fcode);
extern mp4_Status mp4_Decode4MV(mp4_Info *pInfo, IppMotionVector *mv, Ipp32s fcode);
extern mp4_Status mp4_DecodeMV_Direct(mp4_Info *pInfo, IppMotionVector mvC[4], IppMotionVector mvForw[4], IppMotionVector mvBack[4], Ipp32s TRB, Ipp32s TRD, Ipp32s modb, Ipp32s comb_type);
extern mp4_Status mp4_DecodeMV_DirectField(mp4_Info *pInfo, Ipp32s mb_ftfr, Ipp32s mb_fbfr, IppMotionVector *mvTop, IppMotionVector *mvBottom, IppMotionVector *mvForwTop, IppMotionVector *mvForwBottom, IppMotionVector *mvBackTop, IppMotionVector *mvBackBottom, Ipp32s TRB, Ipp32s TRD, Ipp32s modb);
extern mp4_Status mp4_DecodeIntraMB_SVH(mp4_Info *pInfo, Ipp32s pat, Ipp32s quant, Ipp8u *pR[], Ipp32s stepR[]);
extern mp4_Status mp4_DecodeIntraMB_DP(mp4_Info *pInfo, Ipp16s dct_dc[], Ipp32s x, Ipp32s pat, Ipp32s quant, Ipp32s dcVLC, Ipp32s ac_pred_flag, Ipp8u *pR[], Ipp32s stepR[]);
extern mp4_Status mp4_DecodeIntraMB(mp4_Info *pInfo, Ipp32s x, Ipp32s pat, Ipp32s quant, Ipp32s dcVLC, Ipp32s ac_pred_flag, Ipp8u *pR[], Ipp32s stepR[]);
extern mp4_Status mp4_DecodeInterMB_SVH(mp4_Info *pInfo, Ipp16s *coeffMB, Ipp32s quant, Ipp32s pat);
extern mp4_Status mp4_DecodeInterMB(mp4_Info *pInfo, Ipp16s *coeffMB, Ipp32s quant, Ipp32s pat, Ipp32s scan);
extern mp4_Status mp4_ReconstructCoeffsIntraMB(mp4_Info *pInfo, Ipp32s x, Ipp32s pat, Ipp32s quant, Ipp32s dcVLC, Ipp32s ac_pred_flag, Ipp16s *coeff, Ipp32s lnz[]);
extern mp4_Status mp4_DecodeMCBPC_P(mp4_Info* pInfo, Ipp32s *mbType, Ipp32s *mbPattern, Ipp32s stat);
extern mp4_Status mp4_PredictDecode1MV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, Ipp32s y, Ipp32s x);
extern mp4_Status mp4_PredictDecode4MV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, Ipp32s y, Ipp32s x);
extern mp4_Status mp4_PredictDecodeFMV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, Ipp32s y, Ipp32s 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 void mp4_DCTInvCoeffsInterMB(mp4_Info *pInfo, Ipp16s *coeffMB, Ipp32s lnz[], Ipp32s pat, Ipp32s scan);
extern void mp4_PadFrame(mp4_Info* pInfo);
extern void mp4_OBMC(mp4_Info *pInfo, mp4_MacroBlock *pMBinfo, IppMotionVector *mvCur, Ipp32s colNum, Ipp32s rowNum, IppiRect limitRectL, Ipp8u *pYc, Ipp32s stepYc, Ipp8u *pYr, Ipp32s stepYr, Ipp32s cbpy, Ipp16s *coeffMB, Ipp32s dct_type);
extern mp4_Status mp4_CheckDecodeVideoPacket(mp4_Info* pInfo, Ipp32s *found);
extern Ipp32s     mp4_CheckDecodeGOB_SVH(mp4_Info* pInfo);
extern void       mp4_CopyMacroBlocks(mp4_Frame *rFrame, mp4_Frame *cFrame, Ipp32s mbPerRow, Ipp32s rowNum, Ipp32s colNum, Ipp32s n);

extern mp4_Status mp4_Sprite_Trajectory(mp4_Info* pInfo);
extern mp4_Status mp4_PredictDecodeMV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, Ipp32s frGOB, Ipp32s y, Ipp32s x);
extern mp4_Status mp4_DecodeMCBPC_I(mp4_Info* pInfo, Ipp32s *mbType, Ipp32s *mbPattern);

#ifdef FLOAT_POINT_IDCT

static void fIDCT_16s8u_C1R(Ipp16s *coeff, Ipp8u *pR, int stepR)
{
    __ALIGN16(Ipp32f, c, 64);
    int  i, j;

    for (i = 0; i < 64; i ++)
        c[i] = coeff[i];
    ippiDCT8x8Inv_32f_C1I(c);
    for (i = 0; i < 8; i ++)
        for (j = 0; j < 8; j ++)
            pR[i*stepR+j] = c[i*8+j] < 0 ? 0 : c[i*8+j] > 255 ? 255 : (Ipp16s)(c[i*8+j] + 0.5f);
}

static void fIDCT_16s_C1I(Ipp16s *coeff)
{
    __ALIGN16(Ipp32f, c, 64);
    int  i;

    for (i = 0; i < 64; i ++)
        c[i] = coeff[i];
    ippiDCT8x8Inv_32f_C1I(c);
    for (i = 0; i < 64; i ++)
        coeff[i] = c[i] < 0 ? (Ipp16s)(c[i] - 0.5f) : (Ipp16s)(c[i] + 0.5f);
}

#define ippiDCT8x8Inv_16s8u_C1R(coeff, pR, stepR) \
    fIDCT_16s8u_C1R(coeff, pR, stepR)

#define ippiDCT8x8Inv_2x2_16s_C1I(coeff) \
    fIDCT_16s_C1I(coeff)

#define ippiDCT8x8Inv_4x4_16s_C1I(coeff) \
    fIDCT_16s_C1I(coeff)

#define ippiDCT8x8Inv_16s_C1I(coeff) \
    fIDCT_16s_C1I(coeff)

#endif

#ifdef __cplusplus
}
#endif

#endif // __MP4DEC_H__