mp4decvops.c

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

                                    }
                                    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 {
                                IppMotionVector  mvFT, mvFB;
                                if (mp4_PredictDecodeFMV(pInfo, pMBinfo, rowNum, colNum, &mvFT, &mvFB) != MP4_STATUS_OK) {
                                    mp4_Error("Error when decode motion vector");
                                    return MP4_STATUS_ERROR;
                                }
                                mvField[0] = mvFT; mvField[1] = mvFB;
                                if (quarter_sample) {
                                    mp4_LimitFMVQ(&mvFT, &mvCur[0], &limitRectL, dx, dy, 16);
                                    mp4_LimitFMVQ(&mvFB, &mvCur[2], &limitRectL, dx, dy, 16);
                                    mvTmp[0].dx = (Ipp16s)mp4_Div2(mvCur[0].dx);
                                    mvTmp[0].dy = (Ipp16s)(mp4_Div2(mvCur[0].dy << 1) >> 1);
                                    mvTmp[2].dx = (Ipp16s)mp4_Div2(mvCur[2].dx);
                                    mvTmp[2].dy = (Ipp16s)(mp4_Div2(mvCur[2].dy << 1) >> 1);
                                    mp4_ComputeChromaMV(&mvTmp[0], &mvCbCrT);
                                    mp4_ComputeChromaMV(&mvTmp[2], &mvCbCrB);
                                } else {
                                    mp4_LimitFMV(&mvFT, &mvCur[0], &limitRectL, dx, dy, 16);
                                    mp4_LimitFMV(&mvFB, &mvCur[2], &limitRectL, dx, dy, 16);
                                    mp4_ComputeChromaMV(&mvCur[0], &mvCbCrT);
                                    mp4_ComputeChromaMV(&mvCur[2], &mvCbCrB);
                                }
                            }
                        } else {
                            ippiCalcGlobalMV_MPEG4(dx, dy, pMBinfo->mv, pInfo->VisualObject.VideoObject.WarpSpec);
                            pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0];
                        }
                    }
                    if (!obmc_disable) {
                        // OBMC for previous MB
                        if (colNum > 0)
                            if (pMBinfo[-1].type < IPPVC_MBTYPE_INTRA && !(pMBinfo[-1].field_info & 1)) // previous is marked as INTRA if it was mcsel
                                mp4_OBMC(pInfo, pMBinfo - 1, mvPrev, colNum - 1, rowNum, limitRectL, pYc - 16, stepYc, pYr - 16, stepYr, cbpyPrev, coeffMB, dct_typePrev);
                        if (mb_type < IPPVC_MBTYPE_INTRA && !field_prediction && !mcsel) {
                            cbpyPrev = cbpy;
                            dct_typePrev = dct_type;
                            mvPrev[0] = mvCur[0]; mvPrev[1] = mvCur[1]; mvPrev[2] = mvCur[2]; mvPrev[3] = mvCur[3];
                            if (mp4_DecodeInterMB(pInfo, coeffMB, quant, (cbpy << 2) + cbpc, scan) != MP4_STATUS_OK) {
                                mp4_Error("Error when decode coefficients of Inter block");
                                return MP4_STATUS_ERROR;
                            }
                            mp4_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt);
                            mp4_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt);
                            // OBMC current MB if it is the last in the row
                            if (colNum == mbPerRow - 1)
                                mp4_OBMC(pInfo, pMBinfo, mvPrev, colNum, rowNum, limitRectL, pYc, stepYc, pYr, stepYr, cbpyPrev, coeffMB, dct_typePrev);
                        }
                    }
                    if (mb_type < IPPVC_MBTYPE_INTRA && (obmc_disable || field_prediction || mcsel)) {
                        pat = mb_not_coded ? 0 : ((cbpy << 2) + cbpc);
                        if (pat)
                            if (mp4_DecodeInterMB(pInfo, coeffMB, quant, pat, scan) != MP4_STATUS_OK) {
                                mp4_Error("Error when decode coefficients of Inter block");
                                return MP4_STATUS_ERROR;
                            }
                        if (!mcsel) {
                            if (quarter_sample) {
                                if (!field_prediction) {
                                    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+stepYr*8, stepYr, pYc+stepYc*8, 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 {
                                    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 {
                                if (!field_prediction) {
                                    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+stepYr*8, stepYr, pYc+stepYc*8, 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 {
                                    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(cbpy & 8, pYc, stepYc, coeffMB);
                                mp4_AddResidual(cbpy & 4, pYc+8, stepYc, coeffMB+64);
                                mp4_AddResidual(cbpy & 2, pYc+stepYc*8, stepYc, coeffMB+128);
                                mp4_AddResidual(cbpy & 1, pYc+stepYc*8+8, stepYc, coeffMB+192);
                            } else {
                                mp4_AddResidual(cbpy & 8, pYc, stepYc*2, coeffMB);
                                mp4_AddResidual(cbpy & 4, pYc+8, stepYc*2, coeffMB+64);
                                mp4_AddResidual(cbpy & 2, pYc+stepYc, stepYc*2, coeffMB+128);
                                mp4_AddResidual(cbpy & 1, pYc+stepYc+8, stepYc*2, coeffMB+192);
                            }
                            if (!field_prediction) {
                                mp4_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt);
                                mp4_MC_HP(cbpc & 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(cbpc & 2, pCbc, stepCbc, coeffMB+256);
                                mp4_AddResidual(cbpc & 1, pCrc, stepCrc, coeffMB+320);
                            }
                        } else {
                            IppiRect  mbRect;

                            mbRect.x = dx;  mbRect.y = dy;  mbRect.width = mbRect.height = 16;
                            ippiWarpLuma_MPEG4_8u_C1R(pInfo->VisualObject.rFrame.pY, stepYr, pYc, stepYc, &mbRect, pInfo->VisualObject.VideoObject.WarpSpec);
                            mbRect.x >>= 1;  mbRect.y >>= 1;  mbRect.width = mbRect.height = 8;
                            ippiWarpChroma_MPEG4_8u_P2R(pInfo->VisualObject.rFrame.pCb, stepCbr, pInfo->VisualObject.rFrame.pCr, stepCrr, pCbc, stepCbc, pCrc, stepCrc, &mbRect, pInfo->VisualObject.VideoObject.WarpSpec);
                            if (pat) {
                                if (!dct_type) {
                                    mp4_AddResidual(cbpy & 8, pYc, stepYc, coeffMB);
                                    mp4_AddResidual(cbpy & 4, pYc+8, stepYc, coeffMB+64);
                                    mp4_AddResidual(cbpy & 2, pYc+stepYc*8, stepYc, coeffMB+128);
                                    mp4_AddResidual(cbpy & 1, pYc+stepYc*8+8, stepYc, coeffMB+192);
                                } else {
                                    mp4_AddResidual(cbpy & 8, pYc, stepYc*2, coeffMB);
                                    mp4_AddResidual(cbpy & 4, pYc+8, stepYc*2, coeffMB+64);
                                    mp4_AddResidual(cbpy & 2, pYc+stepYc, stepYc*2, coeffMB+128);
                                    mp4_AddResidual(cbpy & 1, pYc+stepYc+8, stepYc*2, coeffMB+192);
                                }
                                mp4_AddResidual(cbpc & 2, pCbc, stepCbc, coeffMB+256);
                                mp4_AddResidual(cbpc & 1, pCrc, stepCrc, coeffMB+320);
                            }
                        }
                    }
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB);
                    mbCurr ++;
                    if (mbCurr == nmb) {
                        // skip stuffing
                        while (mp4_ShowBits(pInfo, 10) == 1)
                            mp4_FlushBits(pInfo, 10);
                        return MP4_STATUS_OK;
                    }
                    pMBinfo ++;
                    mvField += 2;
                    mbInVideoPacket ++;
                    colNum ++;
                    if (colNum == mbPerRow) {
                        colNum = 0;
                        rowNum ++;
                        pYc += 3 * MP4_NUM_EXT_MB * 16 + (stepYc << 4) - stepYc;
                        pCbc += 3 * MP4_NUM_EXT_MB * 8 + (stepCbc << 3) - stepCbc;
                        pCrc += 3 * MP4_NUM_EXT_MB * 8 + (stepCrc << 3) - stepCrc;
                        pYr += 3 * MP4_NUM_EXT_MB * 16 + (stepYr << 4) - stepYr;
                        pCbr += 3 * MP4_NUM_EXT_MB * 8 + (stepCbr << 3) - stepCbr;
                        pCrr += 3 * MP4_NUM_EXT_MB * 8 + (stepCrr << 3) - stepCrr;
                    } else {
                        pYc += 16; pCrc += 8; pCbc += 8;
                        pYr += 16; pCrr += 8; pCbr += 8;
                    }
                }
                if (!pInfo->VisualObject.VideoObject.resync_marker_disable) {
                    int  found;
                    if (mp4_DecodeVideoPacket(pInfo, &quant, &found) == MP4_STATUS_OK) {
                        if (found)
                            break;
                    } else
                        return MP4_STATUS_ERROR;
                }
            }
            // mark MBs the previous videopacket as invalid for prediction
            for (i = 1; i <= IPP_MIN(mbInVideoPacket, mbPerRow + 1); i ++) {
                pMBinfo[-i].validPred = 0;
            }
        }
    }
}


#ifdef _OMP_KARABAS

static mp4_Status mp4_DecodeVOP_S_DecodeSlice(mp4_Info* pInfo, int curRow, mp4_MacroBlockMT* pMBinfoMT)
{
    int              mb_not_coded, mb_type, cbpc, cbpy, quant, quantPred, ac_pred_flag, dcVLC;
    int              i, j, mbPerRow, scan, pat;
    mp4_MacroBlock  *pMBinfo;
    int              mcsel, interlaced, field_prediction, dct_type, mb_ftfr, mb_fbfr;
    IppMotionVector *pMVField;

    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + curRow * mbPerRow;
    // warning "variable may be used without having been initialized"
    cbpc = mb_type = ac_pred_flag = 0;
    quant = quantPred = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant;
    scan = pInfo->VisualObject.VideoObject.VideoObjectPlane.alternate_vertical_scan_flag ? IPPVC_SCAN_VERTICAL : IPPVC_SCAN_ZIGZAG;
    interlaced = pInfo->VisualObject.VideoObject.interlaced;
    pMVField = interlaced ? pInfo->VisualObject.VideoObject.FieldMV + curRow * mbPerRow * 2 : 0;
    // init for non-interlaced
    field_prediction = dct_type = mb_ftfr = mb_fbfr = 0;
    // reset B-prediction blocks on new row
    mp4_ResetIntraPredBblock(pInfo);
    for (j = 0; j < mbPerRow;) {
        mb_not_coded = mp4_GetBit(pInfo);
        mb_type = IPPVC_MBTYPE_INTER;
        if (!mb_not_coded)
            if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK)
                return MP4_STATUS_ERROR;
        if (mb_type != IPPVC_MB_STUFFING) {
            pMBinfo->validPred = 1;
            if (!mb_not_coded) {
                mcsel = (mb_type < IPPVC_MBTYPE_INTER4V) ? mp4_GetBit(pInfo) : 0;
                if (mb_type >= IPPVC_MBTYPE_INTRA)