mp4decvop.c

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

    ippsFree(pInfo->VisualObject.cFrame.apCb); pInfo->VisualObject.cFrame.apCb = pInfo->VisualObject.cFrame.pCb = NULL;
    ippsFree(pInfo->VisualObject.cFrame.apCr); pInfo->VisualObject.cFrame.apCr = pInfo->VisualObject.cFrame.pCr = NULL;
    ippsFree(pInfo->VisualObject.VideoObject.MBinfo); pInfo->VisualObject.VideoObject.MBinfo = NULL;

    ippsFree(pInfo->VisualObject.VideoObject.ShapeInfo); pInfo->VisualObject.VideoObject.ShapeInfo = NULL;
    ippsFree(pInfo->VisualObject.cFrame.apB);  pInfo->VisualObject.cFrame.apB = pInfo->VisualObject.cFrame.pB = NULL;
    if (pInfo->VisualObject.VideoObject.shape == MP4_SHAPE_TYPE_GRAYSCALE) {
        int  i;
        for (i = 0; i < mp4_aux_comp_count[pInfo->VisualObject.VideoObject.shape_extension]; i ++) {
            ippsFree(pInfo->VisualObject.cFrame.apA[i]);  pInfo->VisualObject.cFrame.apA[i] = pInfo->VisualObject.cFrame.pA[i] = NULL;
        }
    }
    return MP4_STATUS_OK;
}


mp4_Status mp4_DecodeMVD(mp4_Info *pInfo, int *mvdx, int *mvdy, int fcode)
{
    const mp4_VLC1 *pTab;
    int             mvd, sign;
    Ipp32u          code;
    int             factor = fcode - 1;

    /* decode MVDx */
    code = mp4_ShowBits(pInfo, 12);
    if (code >= 128)
        pTab = mp4_MVD_B12_2 + ((code - 128) >> 5);
    else if (code >= 2)
        pTab = mp4_MVD_B12_1 + (code - 2);
    else
        return MP4_STATUS_ERROR;
    mvd = pTab->code;
    mp4_FlushBits(pInfo, pTab->len);
    if (mvd) {
        sign = mp4_GetBit(pInfo);
        if (factor) {
            code = mp4_GetBits9(pInfo, factor);
            mvd = ((mvd - 1) << factor) + code + 1;
        }
        if (sign)
            mvd = -mvd;
    }
    *mvdx = mvd;
    /* decode MVDy */
    code = mp4_ShowBits(pInfo, 12);
    if (code >= 128)
        pTab = mp4_MVD_B12_2 + ((code - 128) >> 5);
    else if (code >= 2)
        pTab = mp4_MVD_B12_1 + (code - 2);
    else
        return MP4_STATUS_ERROR;
    mvd = pTab->code;
    mp4_FlushBits(pInfo, pTab->len);
    if (mvd) {
        sign = mp4_GetBit(pInfo);
        if (factor) {
            code = mp4_GetBits9(pInfo, factor);
            mvd = ((mvd - 1) << factor) + code + 1;
        }
        if (sign)
            mvd = -mvd;
    }
    *mvdy = mvd;
    return MP4_STATUS_OK;
}


mp4_Status mp4_DecodeMV(mp4_Info *pInfo, IppMotionVector *mv, int fcode)
{
    int  mvdx, mvdy, range, dx, dy;

    if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, fcode) != MP4_STATUS_OK)
        return MP4_STATUS_ERROR;
    range = 16 << fcode;
    dx = mv->dx + mvdx;
    if (dx < -range)
        dx = (dx + (range << 1));
    else if (dx >= range)
        dx = (dx - (range << 1));
    mv->dx = (Ipp16s)dx;
    dy = mv->dy + mvdy;
    if (dy < -range)
        dy = (dy + (range << 1));
    else if (dy >= range)
        dy = (dy - (range << 1));
    mv->dy = (Ipp16s)dy;
    return MP4_STATUS_OK;
}


mp4_Status mp4_Decode4MV(mp4_Info *pInfo, IppMotionVector *mv, int fcode)
{
    int  i, mvdx, mvdy, range, dx, dy;

    for (i = 0; i < 4; i ++) {
        if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, fcode) != MP4_STATUS_OK)
            return MP4_STATUS_ERROR;
        range = 16 << fcode;
        dx = mv[i].dx + mvdx;
        if (dx < -range)
            dx = (dx + (range << 1));
        else if (dx >= range)
            dx = (dx - (range << 1));
        mv[i].dx = (Ipp16s)dx;
        dy = mv[i].dy + mvdy;
        if (dy < -range)
            dy = (dy + (range << 1));
        else if (dy >= range)
            dy = (dy - (range << 1));
        mv[i].dy = (Ipp16s)dy;
    }
    return MP4_STATUS_OK;
}


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)
{
    int  mvdx, mvdy, i;

    if (modb == 2) {
        if (comb_type != IPPVC_MBTYPE_INTER4V) {
            mvForw[0].dx = mvForw[1].dx = mvForw[2].dx = mvForw[3].dx = (Ipp16s)((TRB * mvC[0].dx) / TRD);
            mvForw[0].dy = mvForw[1].dy = mvForw[2].dy = mvForw[3].dy = (Ipp16s)((TRB * mvC[0].dy) / TRD);
            mvBack[0].dx = mvBack[1].dx = mvBack[2].dx = mvBack[3].dx = (Ipp16s)(((TRB - TRD) * mvC[0].dx) / TRD);
            mvBack[0].dy = mvBack[1].dy = mvBack[2].dy = mvBack[3].dy = (Ipp16s)(((TRB - TRD) * mvC[0].dy) / TRD);
        } else
            for (i = 0; i < 4; i ++) {
                mvForw[i].dx = (Ipp16s)((TRB * mvC[i].dx) / TRD);
                mvForw[i].dy = (Ipp16s)((TRB * mvC[i].dy) / TRD);
                mvBack[i].dx = (Ipp16s)(((TRB - TRD) * mvC[i].dx) / TRD);
                mvBack[i].dy = (Ipp16s)(((TRB - TRD) * mvC[i].dy) / TRD);
            }
    } else {
        if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, 1) != MP4_STATUS_OK)
            return MP4_STATUS_ERROR;
        if (comb_type != IPPVC_MBTYPE_INTER4V) {
            mvForw[0].dx = mvForw[1].dx = mvForw[2].dx = mvForw[3].dx = (Ipp16s)((TRB * mvC[0].dx) / TRD + mvdx);
            mvForw[0].dy = mvForw[1].dy = mvForw[2].dy = mvForw[3].dy = (Ipp16s)((TRB * mvC[0].dy) / TRD + mvdy);
            if (mvdx == 0)
                mvBack[0].dx = mvBack[1].dx = mvBack[2].dx = mvBack[3].dx = (Ipp16s)(((TRB - TRD) * mvC[0].dx) / TRD);
            else
                mvBack[0].dx = mvBack[1].dx = mvBack[2].dx = mvBack[3].dx = (Ipp16s)(mvForw[0].dx - mvC[0].dx);
            if (mvdy == 0)
                mvBack[0].dy = mvBack[1].dy = mvBack[2].dy = mvBack[3].dy = (Ipp16s)(((TRB - TRD) * mvC[0].dy) / TRD);
            else
                mvBack[0].dy = mvBack[1].dy = mvBack[2].dy = mvBack[3].dy = (Ipp16s)(mvForw[0].dy - mvC[0].dy);
        } else
            for (i = 0; i < 4; i++) {
                mvForw[i].dx = (Ipp16s)((TRB * mvC[i].dx) / TRD + mvdx);
                mvForw[i].dy = (Ipp16s)((TRB * mvC[i].dy) / TRD + mvdy);
                if (mvdx == 0)
                    mvBack[i].dx = (Ipp16s)(((TRB - TRD) * mvC[i].dx) / TRD);
                else
                    mvBack[i].dx = (Ipp16s)(mvForw[i].dx - mvC[i].dx);
                if (mvdy == 0)
                    mvBack[i].dy = (Ipp16s)(((TRB - TRD) * mvC[i].dy) / TRD);
                else
                    mvBack[i].dy = (Ipp16s)(mvForw[i].dy - mvC[i].dy);
            }
    }
    return MP4_STATUS_OK;
}


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)
{
    // field direct mode
    int  TRDt, TRDb, TRBt, TRBb, deltaTop, deltaBottom, mvdx, mvdy;

    deltaTop = mb_ftfr;
    deltaBottom = mb_fbfr - 1;
    if (pInfo->VisualObject.VideoObject.VideoObjectPlane.top_field_first) {
        deltaTop = -deltaTop;
        deltaBottom = -deltaBottom;
    }
    TRDt = mp4_DivRoundInf(TRD, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaTop;
    TRDb = mp4_DivRoundInf(TRD, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaBottom;
    TRBt = mp4_DivRoundInf(TRB, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaTop;
    TRBb = mp4_DivRoundInf(TRB, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaBottom;
    if (modb == 2) {
        // delta == 0
        mvdx = mvdy = 0;
    } else {
        if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, 1) != MP4_STATUS_OK)
            return MP4_STATUS_ERROR;
    }
    mvForwTop->dx = (Ipp16s)((TRBt * mvTop->dx) / TRDt + mvdx);
    if (mvdx == 0)
        mvBackTop->dx = (Ipp16s)(((TRBt - TRDt) * mvTop->dx) / TRDt);
    else
        mvBackTop->dx = (Ipp16s)(mvForwTop->dx - mvTop->dx);
    mvForwTop->dy = (Ipp16s)((TRBt * mvTop->dy * 2) / TRDt + mvdy);
    if (mvdy == 0)
        mvBackTop->dy = (Ipp16s)(((TRBt - TRDt) * mvTop->dy * 2) / TRDt);
    else
        mvBackTop->dy = (Ipp16s)(mvForwTop->dy - mvTop->dy * 2);
    mvForwBottom->dx = (Ipp16s)((TRBb * mvBottom->dx) / TRDb + mvdx);
    if (mvdx == 0)
        mvBackBottom->dx = (Ipp16s)(((TRBb - TRDb) * mvBottom->dx) / TRDb);
    else
        mvBackBottom->dx = (Ipp16s)(mvForwBottom->dx - mvBottom->dx);
    mvForwBottom->dy = (Ipp16s)((TRBb * mvBottom->dy * 2) / TRDb + mvdy);
    if (mvdy == 0)
        mvBackBottom->dy = (Ipp16s)(((TRBb - TRDb) * mvBottom->dy * 2) / TRDb);
    else
        mvBackBottom->dy = (Ipp16s)(mvForwBottom->dy - mvBottom->dy * 2);
    mvForwTop->dy >>= 1;
    mvBackTop->dy >>= 1;
    mvForwBottom->dy >>= 1;
    mvBackBottom->dy >>= 1;
    return MP4_STATUS_OK;
}


static void mp4_ExpandFrameReplicate(Ipp8u *pSrcDstPlane, int frameWidth, int frameHeight, int expandPels, int step)
{
    Ipp8u   *pDst1, *pDst2, *pSrc1, *pSrc2;
    int     i, j;
    Ipp32u  t1, t2;

    pDst1 = pSrcDstPlane + step * expandPels;
    pDst2 = pDst1 + frameWidth + expandPels;
    if (expandPels == 8) {
        for (i = 0; i < frameHeight; i ++) {
            t1 = pDst1[8] + (pDst1[8] << 8);
            t2 = pDst2[-1] + (pDst2[-1] << 8);
            t1 = (t1 << 16) + t1;
            t2 = (t2 << 16) + t2;
            ((Ipp32u*)pDst1)[0] = t1;
            ((Ipp32u*)pDst1)[1] = t1;
            ((Ipp32u*)pDst2)[0] = t2;
            ((Ipp32u*)pDst2)[1] = t2;
            pDst1 += step;
            pDst2 += step;
        }
    } else if (expandPels == 16) {
        for (i = 0; i < frameHeight; i ++) {
            t1 = pDst1[16] + (pDst1[16] << 8);
            t2 = pDst2[-1] + (pDst2[-1] << 8);
            t1 = (t1 << 16) + t1;
            t2 = (t2 << 16) + t2;
            ((Ipp32u*)pDst1)[0] = t1;
            ((Ipp32u*)pDst1)[1] = t1;
            ((Ipp32u*)pDst1)[2] = t1;
            ((Ipp32u*)pDst1)[3] = t1;
            ((Ipp32u*)pDst2)[0] = t2;
            ((Ipp32u*)pDst2)[1] = t2;
            ((Ipp32u*)pDst2)[2] = t2;
            ((Ipp32u*)pDst2)[3] = t2;
            pDst1 += step;
            pDst2 += step;
        }
    } else {
        for (i = 0; i < frameHeight; i ++) {
            ippsSet_8u(pDst1[expandPels], pDst1, expandPels);
            ippsSet_8u(pDst2[-1], pDst2, expandPels);
            pDst1 += step;
            pDst2 += step;
        }
    }
    pDst1 = pSrcDstPlane;
    pSrc1 = pSrcDstPlane + expandPels * step;
    pDst2 = pSrc1 + frameHeight * step;