mp4decvopb.c

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

                        mp4_AddResidual(cbpb & 1, pCrc, stepCrc, coeffMB+320);
                    } else { // IPPVC_MBTYPE_DIRECT
                        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_DIRECT);
                        field_prediction = pMBinfo->field_info & 1;
                        if (!field_prediction) {
                            // frame direct mode
                            if (mp4_DecodeMV_Direct(pInfo, pMBinfo->mv, mvForw, mvBack, TRB, TRD, modb, pMBinfo->type) != MP4_STATUS_OK) {
                                mp4_Error("Error when decode B-VOP motion vector");
                                return MP4_STATUS_ERROR;
                            }
                            if (quarter_sample) {
                                mp4_ComputeChroma4MVQ(mvForw, &mvCbCrF);
                                mp4_Limit4MVQ(mvForw, mvForw, &limitRectL, dx, dy, 8);
                                mp4_ComputeChroma4MVQ(mvBack, &mvCbCrB);
                                mp4_Limit4MVQ(mvBack, mvBack, &limitRectL, dx, dy, 8);
                                pc = pYc;
                                pr = pYp;
                                pn = pYn;
                                mp4_Copy8x8QP_8u(pr, stepYp, pc, stepYc, &mvForw[0], 0);
                                mp4_Copy8x8QP_8u(pn, stepYn, tmpMB, 16, &mvBack[0], 0);
                                mp4_Copy8x8QP_8u(pr+8, stepYp, pc+8, stepYc, &mvForw[1], 0);
                                mp4_Copy8x8QP_8u(pn+8, stepYn, tmpMB+8, 16, &mvBack[1], 0);
                                pc = pYc + stepYc * 8;
                                pr = pYp + stepYp * 8;
                                pn = pYn + stepYn * 8;
                                mp4_Copy8x8QP_8u(pr, stepYp, pc, stepYc, &mvForw[2], 0);
                                mp4_Copy8x8QP_8u(pn, stepYn, tmpMB+128, 16, &mvBack[2], 0);
                                mp4_Copy8x8QP_8u(pr+8, stepYp, pc+8, stepYc, &mvForw[3], 0);
                                mp4_Copy8x8QP_8u(pn+8, stepYn, tmpMB+136, 16, &mvBack[3], 0);
                            } else {
                                mp4_ComputeChroma4MV(mvForw, &mvCbCrF);
                                mp4_Limit4MV(mvForw, mvForw, &limitRectL, dx, dy, 8);
                                mp4_ComputeChroma4MV(mvBack, &mvCbCrB);
                                mp4_Limit4MV(mvBack, mvBack, &limitRectL, dx, dy, 8);
                                pc = pYc;
                                pr = pYp;
                                pn = pYn;
                                mp4_Copy8x8HP_8u(pr, stepYp, pc, stepYc, &mvForw[0], 0);
                                mp4_Copy8x8HP_8u(pn, stepYn, tmpMB, 16, &mvBack[0], 0);
                                mp4_Copy8x8HP_8u(pr+8, stepYp, pc+8, stepYc, &mvForw[1], 0);
                                mp4_Copy8x8HP_8u(pn+8, stepYn, tmpMB+8, 16, &mvBack[1], 0);
                                pc = pYc + stepYc * 8;
                                pr = pYp + stepYp * 8;
                                pn = pYn + stepYn * 8;
                                mp4_Copy8x8HP_8u(pr, stepYp, pc, stepYc, &mvForw[2], 0);
                                mp4_Copy8x8HP_8u(pn, stepYn, tmpMB+128, 16, &mvBack[2], 0);
                                mp4_Copy8x8HP_8u(pr+8, stepYp, pc+8, stepYc, &mvForw[3], 0);
                                mp4_Copy8x8HP_8u(pn+8, stepYn, tmpMB+136, 16, &mvBack[3], 0);
                            }
                            mp4_LimitMV(&mvCbCrF, &mvCbCrF, &limitRectC, dx >> 1, dy >> 1, 8);
                            mp4_LimitMV(&mvCbCrB, &mvCbCrB, &limitRectC, dx >> 1, dy >> 1, 8);
                        } else {
                            mb_ftfr = (pMBinfo->field_info >> 1) & 1;
                            mb_fbfr = (pMBinfo->field_info >> 2) & 1;
                            if (mp4_DecodeMV_DirectField(pInfo, mb_ftfr, mb_fbfr, &mvField[0], &mvField[1], &mvForw[0], &mvForw[2], &mvBack[0], &mvBack[2], TRB, TRD, modb) != MP4_STATUS_OK) {
                                mp4_Error("Error when decode B-VOP motion vector");
                                return MP4_STATUS_ERROR;
                            }
                            if (quarter_sample) {
                                mp4_LimitFMVQ(&mvForw[0], &mvForw[0], &limitRectL, dx, dy, 16);
                                mp4_LimitFMVQ(&mvForw[2], &mvForw[2], &limitRectL, dx, dy, 16);
                                mp4_LimitFMVQ(&mvBack[0], &mvBack[0], &limitRectL, dx, dy, 16);
                                mp4_LimitFMVQ(&mvBack[2], &mvBack[2], &limitRectL, dx, dy, 16);
                                mp4_Copy16x8QP_8u(pYp+(mb_ftfr ? stepYp : 0), stepYp*2, pYc, stepYc*2, &mvForw[0], 0);
                                mp4_Copy16x8QP_8u(pYp+(mb_fbfr ? stepYp : 0), stepYp*2, pYc+stepYc, stepYc*2, &mvForw[2], 0);
                                mp4_Copy16x8QP_8u(pYn/*+stepYn*mb_btfr*/, stepYn*2, tmpMB, 32, &mvBack[0], 0);
                                mp4_Copy16x8QP_8u(pYn+stepYn/**mb_bbfr*/, stepYn*2, tmpMB+16, 32, &mvBack[2], 0);
                                mvForw[0].dx = (Ipp16s)mp4_Div2(mvForw[0].dx);
                                mvForw[0].dy = (Ipp16s)(mp4_Div2(mvForw[0].dy*2) >> 1);
                                mvForw[2].dx = (Ipp16s)mp4_Div2(mvForw[2].dx);
                                mvForw[2].dy = (Ipp16s)(mp4_Div2(mvForw[2].dy*2) >> 1);
                                mvBack[0].dx = (Ipp16s)mp4_Div2(mvBack[0].dx);
                                mvBack[0].dy = (Ipp16s)(mp4_Div2(mvBack[0].dy*2) >> 1);
                                mvBack[2].dx = (Ipp16s)mp4_Div2(mvBack[2].dx);
                                mvBack[2].dy = (Ipp16s)(mp4_Div2(mvBack[2].dy*2) >> 1);
                            } else {
                                mp4_LimitFMV(&mvForw[0], &mvForw[0], &limitRectL, dx, dy, 16);
                                mp4_LimitFMV(&mvForw[2], &mvForw[2], &limitRectL, dx, dy, 16);
                                mp4_LimitFMV(&mvBack[0], &mvBack[0], &limitRectL, dx, dy, 16);
                                mp4_LimitFMV(&mvBack[2], &mvBack[2], &limitRectL, dx, dy, 16);
                                mp4_Copy16x8HP_8u(pYp+(mb_ftfr ? stepYp : 0), stepYp*2, pYc, stepYc*2, &mvForw[0], 0);
                                mp4_Copy16x8HP_8u(pYp+(mb_fbfr ? stepYp : 0), stepYp*2, pYc+stepYc, stepYc*2, &mvForw[2], 0);
                                mp4_Copy16x8HP_8u(pYn/*+stepYn*mb_btfr*/, stepYn*2, tmpMB, 32, &mvBack[0], 0);
                                mp4_Copy16x8HP_8u(pYn+stepYn/**mb_bbfr*/, stepYn*2, tmpMB+16, 32, &mvBack[2], 0);
                            }
                            mp4_ComputeChromaMV(&mvForw[0], &mvCbCrFFT);
                            mp4_ComputeChromaMV(&mvForw[2], &mvCbCrFFB);
                            mp4_ComputeChromaMV(&mvBack[0], &mvCbCrBFT);
                            mp4_ComputeChromaMV(&mvBack[2], &mvCbCrBFB);
                        }
                        ippiAverage16x16_8u_C1IR(tmpMB, 16, pYc, stepYc);
                        if (mp4_DecodeInterMB(pInfo, coeffMB, quant, cbpb, scan) != MP4_STATUS_OK) {
                            mp4_Error("Error when decode coefficients of Inter block");
                            return MP4_STATUS_ERROR;
                        }
                        if (!dct_type) {
                            mp4_AddResidual(cbpb & 32, pYc, stepYc, coeffMB);
                            mp4_AddResidual(cbpb & 16, pYc+8, stepYc, coeffMB+64);
                            mp4_AddResidual(cbpb & 8, pYc+stepYc*8, stepYc, coeffMB+128);
                            mp4_AddResidual(cbpb & 4, pYc+stepYc*8+8, stepYc, coeffMB+192);
                        } else {
                            mp4_AddResidual(cbpb & 32, pYc, stepYc*2, coeffMB);
                            mp4_AddResidual(cbpb & 16, pYc+8, stepYc*2, coeffMB+64);
                            mp4_AddResidual(cbpb & 8, pYc+stepYc, stepYc*2, coeffMB+128);
                            mp4_AddResidual(cbpb & 4, pYc+stepYc+8, stepYc*2, coeffMB+192);
                        }
                        if (!field_prediction) {
                            mp4_Copy8x8HP_8u(pCbp, stepCbp, pCbc, stepCbc, &mvCbCrF, 0);
                            mp4_Copy8x8HP_8u(pCrp, stepCrp, pCrc, stepCrc, &mvCbCrF, 0);
                            mp4_Copy8x8HP_8u(pCbn, stepCbn, tmpMB, 8, &mvCbCrB, 0);
                            mp4_Copy8x8HP_8u(pCrn, stepCrn, tmpMB+64, 8, &mvCbCrB, 0);
                        } else {
                            mp4_Copy8x4HP_8u(pCbp+(mb_ftfr ? stepCbp : 0), stepCbp*2, pCbc, stepCbc*2, &mvCbCrFFT, 0);
                            mp4_Copy8x4HP_8u(pCrp+(mb_ftfr ? stepCrp : 0), stepCrp*2, pCrc, stepCrc*2, &mvCbCrFFT, 0);
                            mp4_Copy8x4HP_8u(pCbp+(mb_fbfr ? stepCbp : 0), stepCbp*2, pCbc+stepCbc, stepCbc*2, &mvCbCrFFB, 0);
                            mp4_Copy8x4HP_8u(pCrp+(mb_fbfr ? stepCrp : 0), stepCrp*2, pCrc+stepCrc, stepCrc*2, &mvCbCrFFB, 0);
                            mp4_Copy8x4HP_8u(pCbn/*+(mb_btfr ? stepCbn : 0)*/, stepCbn*2, tmpMB, 16, &mvCbCrBFT, 0);
                            mp4_Copy8x4HP_8u(pCrn/*+(mb_btfr ? stepCrn : 0)*/, stepCrn*2, tmpMB+64, 16, &mvCbCrBFT, 0);
                            mp4_Copy8x4HP_8u(pCbn+/*(mb_bbfr ? */stepCbn/* : 0)*/, stepCbn*2, tmpMB+8, 16, &mvCbCrBFB, 0);
                            mp4_Copy8x4HP_8u(pCrn+/*(mb_bbfr ? */stepCrn/* : 0)*/, stepCrn*2, tmpMB+64+8, 16, &mvCbCrBFB, 0);
                        }
                        ippiAverage8x8_8u_C1IR(tmpMB, 8, pCbc, stepCbc);
                        ippiAverage8x8_8u_C1IR(tmpMB+64, 8, pCrc, stepCrc);
                        mp4_AddResidual(cbpb & 2, pCbc, stepCbc, coeffMB+256);
                        mp4_AddResidual(cbpb & 1, pCrc, stepCrc, coeffMB+320);
                    }
                }
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB);
                mbCurr ++;
                if (mbCurr == nmb)
                    return MP4_STATUS_OK;
                mbInVideoPacket ++;
                colNum ++;
                pMBinfo ++;
                mvField += 2;
                if (colNum == pInfo->VisualObject.VideoObject.MacroBlockPerRow) {
                    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;
                    pYp += 3 * MP4_NUM_EXT_MB * 16 + (stepYp << 4) - stepYp;
                    pCbp += 3 * MP4_NUM_EXT_MB * 8 + (stepCbp << 3) - stepCbp;
                    pCrp += 3 * MP4_NUM_EXT_MB * 8 + (stepCrp << 3) - stepCrp;
                    pYn += 3 * MP4_NUM_EXT_MB * 16 + (stepYn << 4) - stepYn;
                    pCbn += 3 * MP4_NUM_EXT_MB * 8 + (stepCbn << 3) - stepCbn;
                    pCrn += 3 * MP4_NUM_EXT_MB * 8 + (stepCrn << 3) - stepCrn;
                    // reset MV predictors at new row
                    mvForwT.dx = mvForwT.dy = mvBackT.dx = mvBackT.dy = mvForwB.dx = mvForwB.dy = mvBackB.dx = mvBackB.dy = 0;
                } else {
                    pYc += 16; pCrc += 8; pCbc += 8;
                    pYp += 16; pCrp += 8; pCbp += 8;
                    pYn += 16; pCrn += 8; pCbn += 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;
                }
            }
        }
    }
// decode usual B-VOP
    for (;;) {
        IppMotionVector mvCbCrF, mvCbCrB, mvForw, mvBack, mvForwLim, mvBackLim;

        mbInVideoPacket = 0;
        // reset MV predictors at new VideoPacket
        mvForw.dx = mvForw.dy = mvBack.dx = mvBack.dy = 0;
        // decode B-VOP macroblocks
        for (;;) {
            if (pMBinfo->not_coded) {
                ippiCopy16x16_8u_C1R(pYp, stepYp, pYc, stepYc);
                ippiCopy8x8_8u_C1R(pCbp, stepCbp, pCbc, stepCbc);
                ippiCopy8x8_8u_C1R(pCrp, stepCrp, pCrc, stepCrc);
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED);
            } else {
                cbpb = 0;
                if (mp4_GetBit(pInfo)) {
                    modb = 2;
                    mb_type = IPPVC_MBTYPE_DIRECT;
                } else {
                    modb = mp4_GetBit(pInfo);
                    // decode mb_type
                    code = mp4_ShowBits9(pInfo, 4);
                    if (code != 0) {
                        mb_type = mp4_BVOPmb_type[code].code;
                        mp4_FlushBits(pInfo, mp4_BVOPmb_type[code].len);
                    } else {
                        mp4_Error("Error when decode mb_type of B-VOP macroblock");
                        return MP4_STATUS_ERROR;
                    }
                    if (modb == 0)
                        cbpb = mp4_GetBits9(pInfo, 6);
                    if (mb_type != IPPVC_MBTYPE_DIRECT && cbpb != 0)
                        mp4_UpdateQuant_B(pInfo, quant);
                }
                // coordinates of current MB for limitation
                dx = colNum * 16;
                dy = rowNum * 16;
                if (mb_type == IPPVC_MBTYPE_FORWARD) {