mp4decvops.c

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

                        } else {
                            if (quarter_sample) {
                                mp4_Limit4MVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8);
                                mp4_ComputeChroma4MVQ(pMBinfo->mv, &mvCbCr);
                            } else {
                                mp4_Limit4MV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8);
                                mp4_ComputeChroma4MV(pMBinfo->mv, &mvCbCr);
                            }
                            mp4_LimitMV(&mvCbCr, &mvCbCr, &limitRectC, dx >> 1, dy >> 1, 8);
                        }
                    } else {
                        if (quarter_sample) {
                            mp4_LimitFMVQ(&pMVField[0], &mvCur[0], &limitRectL, dx, dy, 16);
                            mp4_LimitFMVQ(&pMVField[1], &mvCur[2], &limitRectL, dx, dy, 16);
                            mvTmpT.dx = (Ipp16s)mp4_Div2(mvCur[0].dx);
                            mvTmpT.dy = (Ipp16s)(mp4_Div2(mvCur[0].dy << 1) >> 1);
                            mvTmpB.dx = (Ipp16s)mp4_Div2(mvCur[2].dx);
                            mvTmpB.dy = (Ipp16s)(mp4_Div2(mvCur[2].dy << 1) >> 1);
                            mp4_ComputeChromaMV(&mvTmpT, &mvCbCrT);
                            mp4_ComputeChromaMV(&mvTmpB, &mvCbCrB);
                        } else {
                            mp4_LimitFMV(&pMVField[0], &mvCur[0], &limitRectL, dx, dy, 16);
                            mp4_LimitFMV(&pMVField[1], &mvCur[2], &limitRectL, dx, dy, 16);
                            mp4_ComputeChromaMV(&mvCur[0], &mvCbCrT);
                            mp4_ComputeChromaMV(&mvCur[2], &mvCbCrB);
                        }
                    }
                    if (pat)
                        mp4_DCTInvCoeffsInterMB(pInfo, coeffMB, pMBinfoMT->lnz, pat, scan);
                    if (obmc_disable || field_prediction) {
                        if (!field_prediction) {
                            if (quarter_sample) {
                                if (mb_type == IPPVC_MBTYPE_INTER4V) {
                                    mp4_Copy8x8QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt);
                                    mp4_Copy8x8QP_8u(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], rt);
                                    mp4_Copy8x8QP_8u(pYr+8*stepYr, stepYr, pYc+8*stepYc, stepYc, &mvCur[2], rt);
                                    mp4_Copy8x8QP_8u(pYr+8*stepYr+8, stepYr, pYc+8*stepYc+8, stepYc, &mvCur[3], rt);
                                } else
                                    mp4_Copy16x16QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt);
                            } else {
                                if (mb_type == IPPVC_MBTYPE_INTER4V) {
                                    mp4_Copy8x8HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt);
                                    mp4_Copy8x8HP_8u(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], rt);
                                    mp4_Copy8x8HP_8u(pYr+8*stepYr, stepYr, pYc+8*stepYc, stepYc, &mvCur[2], rt);
                                    mp4_Copy8x8HP_8u(pYr+8*stepYr+8, stepYr, pYc+8*stepYc+8, stepYc, &mvCur[3], rt);
                                } else
                                    mp4_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt);
                            }
                        } else {
                            if (quarter_sample) {
                                mp4_Copy16x8QP_8u(pYr+stepYr*mb_ftfr, stepYr*2, pYc, stepYc*2, &mvCur[0], rt);
                                mp4_Copy16x8QP_8u(pYr+stepYr*mb_fbfr, stepYr*2, pYc+stepYc, stepYc*2, &mvCur[2], rt);
                            } else {
                                mp4_Copy16x8HP_8u(pYr+stepYr*mb_ftfr, stepYr*2, pYc, stepYc*2, &mvCur[0], rt);
                                mp4_Copy16x8HP_8u(pYr+stepYr*mb_fbfr, stepYr*2, pYc+stepYc, stepYc*2, &mvCur[2], rt);
                            }
                        }
                        if (!dct_type) {
                            mp4_AddResidual(pat & 32, pYc, stepYc, coeffMB);
                            mp4_AddResidual(pat & 16, pYc+8, stepYc, coeffMB+64);
                            mp4_AddResidual(pat & 8, pYc+stepYc*8, stepYc, coeffMB+128);
                            mp4_AddResidual(pat & 4, pYc+stepYc*8+8, stepYc, coeffMB+192);
                        } else {
                            mp4_AddResidual(pat & 32, pYc, stepYc*2, coeffMB);
                            mp4_AddResidual(pat & 16, pYc+8, stepYc*2, coeffMB+64);
                            mp4_AddResidual(pat & 8, pYc+stepYc, stepYc*2, coeffMB+128);
                            mp4_AddResidual(pat & 4, pYc+stepYc+8, stepYc*2, coeffMB+192);
                        }
                        if (!field_prediction) {
                            mp4_MC_HP(pat & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt);
                            mp4_MC_HP(pat & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt);
                        } else {
                            mp4_Copy8x4HP_8u(pCbr+(mb_ftfr ? stepCbr : 0), stepCbr*2, pCbc, stepCbc*2, &mvCbCrT, rt);
                            mp4_Copy8x4HP_8u(pCrr+(mb_ftfr ? stepCrr : 0), stepCrr*2, pCrc, stepCrc*2, &mvCbCrT, rt);
                            mp4_Copy8x4HP_8u(pCbr+(mb_fbfr ? stepCbr : 0), stepCbr*2, pCbc+stepCbc, stepCbc*2, &mvCbCrB, rt);
                            mp4_Copy8x4HP_8u(pCrr+(mb_fbfr ? stepCrr : 0), stepCrr*2, pCrc+stepCrc, stepCrc*2, &mvCbCrB, rt);
                            mp4_AddResidual(pat & 2, pCbc, stepCbc, coeffMB+256);
                            mp4_AddResidual(pat & 1, pCrc, stepCrc, coeffMB+320);
                        }
                    }
                }
                if (!obmc_disable && !field_prediction) {
                    if (mb_not_coded) {
                        ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc);
                        ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc);
                        pat = 0;
                        mp4_Zero4MV(mvCur);
                    } else {
                        mp4_MC_HP(pat & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt);
                        mp4_MC_HP(pat & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt);
                    }
                    mp4_OBMC(pInfo, pMBinfo, mvCur, j, curRow, limitRectL, pYc, stepYc, pYr, stepYr, pat >> 2, coeffMB, dct_type);
                }
            }
        }
        pMBinfo ++;
        pMBinfoMT ++;
        pMVField += 2;
        pYc += 16; pCrc += 8; pCbc += 8;
        pYr += 16; pCrr += 8; pCbr += 8;
        dx += 16;
    }
}


mp4_Status mp4_DecodeVOP_S_MT(mp4_Info* pInfo)
{
    int        i, mbPerCol, mbPerRow, fcode_forward;
    IppiRect   spriteRect, vopRect;
    mp4_Status sts = MP4_STATUS_OK;

    // init WarpSpec for Sprites or GMC
    vopRect.x = 0;
    vopRect.y = 0;
    vopRect.width = pInfo->VisualObject.VideoObject.width;
    vopRect.height = pInfo->VisualObject.VideoObject.height;
    if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_STATIC) {
        spriteRect.x = pInfo->VisualObject.VideoObject.sprite_left_coordinate;
        spriteRect.y = pInfo->VisualObject.VideoObject.sprite_top_coordinate;
        spriteRect.width = pInfo->VisualObject.VideoObject.sprite_width;
        spriteRect.height = pInfo->VisualObject.VideoObject.sprite_height;
        fcode_forward = 1;
    } else {
        spriteRect = vopRect; // for shapes they may be different !!!!!!
        fcode_forward = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_forward;
    }
    ippiWarpInit_MPEG4(pInfo->VisualObject.VideoObject.WarpSpec,
        pInfo->VisualObject.VideoObject.VideoObjectPlane.warping_mv_code_du,
        pInfo->VisualObject.VideoObject.VideoObjectPlane.warping_mv_code_dv,
        pInfo->VisualObject.VideoObject.sprite_warping_points,
        pInfo->VisualObject.VideoObject.sprite_enable,
        pInfo->VisualObject.VideoObject.sprite_warping_accuracy,
        pInfo->VisualObject.VideoObject.VideoObjectPlane.rounding_type,
        pInfo->VisualObject.VideoObject.quarter_sample, fcode_forward,
        &spriteRect, &vopRect);
    // decode basic sprites
    if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_STATIC) {
        int  h;
        //if (pInfo->VisualObject.VideoObject.shape != MP4_SHAPE_TYPE_RECTANGULAR) {
        //    if (mp4_InitVOPShape(pInfo) != MP4_STATUS_OK)
        //        return MP4_STATUS_ERROR;
        //}
        h = (vopRect.height / pInfo->num_threads) & (~1); // must be even
#ifdef _OPENMP
#pragma  omp parallel shared(pInfo, h)
#endif
        {
            IppiRect   vopRect;
            int               idThread = 0;
#ifdef _OPENMP
            idThread = omp_get_thread_num();
#endif
            vopRect.x = 0;
            vopRect.width = pInfo->VisualObject.VideoObject.width;
            vopRect.y = idThread * h;
            vopRect.height = h;
            if (idThread == (pInfo->num_threads - 1))
                vopRect.height = pInfo->VisualObject.VideoObject.height - vopRect.y;
            ippiWarpLuma_MPEG4_8u_C1R(pInfo->VisualObject.sFrame.pY, pInfo->VisualObject.sFrame.stepY,
                pInfo->VisualObject.cFrame.pY + vopRect.y * pInfo->VisualObject.cFrame.stepY,
                pInfo->VisualObject.cFrame.stepY, &vopRect, pInfo->VisualObject.VideoObject.WarpSpec);
            if (pInfo->VisualObject.VideoObject.sprite_brightness_change)
                ippiChangeSpriteBrightness_MPEG4_8u_C1IR(pInfo->VisualObject.cFrame.pY, pInfo->VisualObject.cFrame.stepY, vopRect.width, vopRect.height, pInfo->VisualObject.VideoObject.VideoObjectPlane.brightness_change_factor);
            vopRect.y >>= 1; vopRect.width >>= 1; vopRect.height >>= 1;
            ippiWarpChroma_MPEG4_8u_P2R(pInfo->VisualObject.sFrame.pCb, pInfo->VisualObject.sFrame.stepCb,
                pInfo->VisualObject.sFrame.pCr, pInfo->VisualObject.sFrame.stepCr,
                pInfo->VisualObject.cFrame.pCb + vopRect.y * pInfo->VisualObject.cFrame.stepCb, pInfo->VisualObject.cFrame.stepCb,
                pInfo->VisualObject.cFrame.pCr + vopRect.y * pInfo->VisualObject.cFrame.stepCr, pInfo->VisualObject.cFrame.stepCr,
                &vopRect, pInfo->VisualObject.VideoObject.WarpSpec);
        }
        return MP4_STATUS_OK;
    }
    // decode S(GMC)-VOP
    mbPerCol = pInfo->VisualObject.VideoObject.MacroBlockPerCol;
    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    mp4_ResetIntraPredBuffer(pInfo);
    i = 0;
#ifdef _OPENMP
#pragma  omp parallel shared(pInfo, i, mbPerCol, mbPerRow, sts) num_threads(2)
#endif
    {
        int               idThread = 0;   /* the thread id of the calling thread. */
        int               curRow;
        mp4_MacroBlockMT* pMBinfoMT;

#ifdef _OPENMP
        idThread = omp_get_thread_num();
#endif
        pMBinfoMT = pInfo->pMBinfoMT + mbPerRow * idThread;
        curRow = i;
        while (curRow < mbPerCol) {
#ifdef _OPENMP
#pragma omp critical(HI_FOXY)
#endif
            {
                curRow = i;
                i ++;
                if (curRow < mbPerCol)
                    if (mp4_DecodeVOP_S_DecodeSlice(pInfo, curRow, pMBinfoMT) != MP4_STATUS_OK) {
                        sts = MP4_STATUS_ERROR;
                        curRow = mbPerCol;
                    }
            }
            if (curRow < mbPerCol)
                if (sts == MP4_STATUS_OK)
                    mp4_DecodeVOP_S_ReconSlice(pInfo, curRow, pMBinfoMT);
            curRow ++;
        }
    }
    // skip stuffing
    while (mp4_ShowBits(pInfo, 10) == 1)
        mp4_FlushBits(pInfo, 10);
    return sts;
}

#endif // _OMP_KARABAS