mp4decvops.c

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

                mcsel = pMBdp->mcsel;
                if (!mcsel && (mb_type >= IPPVC_MBTYPE_INTRA)) {
                    quantPred = (i == 0) ? quant : pMBdp[-1].quant;
                    dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                    pF[0] = pYc; pF[1] = pYc + 8; pF[2] = pYc + 8 * stepYc; pF[3] = pYc + 8 * stepYc + 8; pF[4] = pCbc; pF[5] = pCrc;
                    if (mp4_DecodeIntraMB_DP(pInfo, pMBdp->dct_dc, colNum, pMBdp->pat, quant, dcVLC, pMBdp->ac_pred_flag, pF, stepF) != MP4_STATUS_OK) {
                        mp4_Error("Error when decode coefficients of Intra block");
                        return MP4_STATUS_ERROR;
                    }
                } else {
                    mp4_UpdateIntraPredBuffInvalid(pInfo, colNum);
                    dx = colNum * 16;
                    dy = rowNum * 16;
                    pat = pMBdp->pat;
                    cbpy = pat >> 2;
                    cbpc = pat & 3;
                    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 (mb_type == IPPVC_MBTYPE_INTER4V) {
                            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_LimitMVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16);
                                mp4_ComputeChromaMVQ(mvCur, &mvCbCr);
                            } else {
                                mp4_LimitMV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16);
                                mp4_ComputeChromaMV(mvCur, &mvCbCr);
                            }
                            mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0];
                        }
                        if (obmc_disable) {
                            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);
                            }
                            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_OBMC(pInfo, pMBinfo, mvCur, colNum, rowNum, limitRectL, pYc, stepYc, pYr, stepYr, cbpy, coeffMB, 0);
                        }
                        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 {
                        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) {
                            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);
                            mp4_AddResidual(cbpc & 2, pCbc, stepCbc, coeffMB+256);
                            mp4_AddResidual(cbpc & 1, pCrc, stepCrc, coeffMB+320);
                        }
                    }
                }
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB);
                pMBinfo ++;
                pMBdp ++;
                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;
                }
            }
            mbCurr += mbInVideoPacket;
            if (mbCurr == nmb)
                break;
            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;
        }
        return MP4_STATUS_OK;
    }
// decode not data_partitioned S-VOP
    {
        int     stepY, pYoff23, field_prediction, dct_type, dct_typePrev, mb_ftfr, mb_fbfr;
        IppMotionVector mvCbCrT, mvCbCrB, *mvField = pInfo->VisualObject.VideoObject.FieldMV;

        // warning "variable may be used without having been initialized"
        dx = dy = ac_pred_flag = cbpy = cbpyPrev = field_prediction = dct_type = dct_typePrev = mb_ftfr = mb_fbfr = 0;
        mvCbCr.dx = mvCbCr.dy = mvCbCrT.dx = mvCbCrT.dy = mvCbCrB.dx = mvCbCrB.dy = 0;
        for (;;) {
            // reset Intra prediction buffer on new Video_packet
            mp4_ResetIntraPredBuffer(pInfo);
            mbInVideoPacket = 0;
            // decode blocks
            for (;;) {
                if (colNum == 0) {
                    // reset B-prediction blocks on new row
                    mp4_ResetIntraPredBblock(pInfo);
                }
                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) {
                    if (!mb_not_coded) {
                        mcsel = (mb_type < IPPVC_MBTYPE_INTER4V) ? mp4_GetBit(pInfo) : 0;
                        if (mb_type >= IPPVC_MBTYPE_INTRA)
                            ac_pred_flag = mp4_GetBit(pInfo);
                        if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK)
                            return MP4_STATUS_ERROR;
                        quantPred = quant;
                        if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q)
                            mp4_UpdateQuant(pInfo, quant);
                        if (interlaced) {
                            dct_type = 0;
                            field_prediction = 0;
                            if (mb_type >= IPPVC_MBTYPE_INTRA || (cbpy + cbpc) != 0)
                                dct_type = mp4_GetBit(pInfo);
                            if ((mb_type == IPPVC_MBTYPE_INTER || mb_type == IPPVC_MBTYPE_INTER_Q) && !mcsel) {
                                field_prediction = mp4_GetBit(pInfo);
                                if (field_prediction) {
                                    mb_ftfr = mp4_GetBit(pInfo);
                                    mb_fbfr = mp4_GetBit(pInfo);
                                }
                            }
                        }
                    } else {
                        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED);
                        mcsel = 1;
                        field_prediction = 0;
                    }
                    pMBinfo->validPred = 1;
                    pMBinfo->not_coded = 0;  // for B-VOP all MB have MVs
                    pMBinfo->type = (Ipp8u)(mcsel ? IPPVC_MBTYPE_INTRA : mb_type);  // for OBMC MVs
                    pMBinfo->field_info = (Ipp8u)(field_prediction + (mb_ftfr << 1) + (mb_fbfr << 2));
                    if (mb_type >= IPPVC_MBTYPE_INTRA) {
                        if (mbCurr == 0)
                            quantPred = quant;
                        dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                        if (dct_type) {
                            stepY = stepYc * 2;
                            pYoff23 = stepYc;
                        } else {
                            stepY = stepYc;
                            pYoff23 = 8 * stepYc;
                        }
                        stepF[0] = stepF[1] = stepF[2] = stepF[3] = stepY;
                        pF[0] = pYc; pF[1] = pYc + 8; pF[2] = pYc + pYoff23; pF[3] = pYc + pYoff23 + 8; pF[4] = pCbc; pF[5] = pCrc;
                        if (mp4_DecodeIntraMB(pInfo, colNum, (cbpy << 2) + cbpc, quant, dcVLC, ac_pred_flag, pF, stepF) != MP4_STATUS_OK) {
                            mp4_Error("Error when decode coefficients of Intra block");
                            return MP4_STATUS_ERROR;
                        }
                        mp4_Zero4MV(pMBinfo->mv);
                    } else {
                        mp4_UpdateIntraPredBuffInvalid(pInfo, colNum);
                        dx = colNum * 16;
                        dy = rowNum * 16;
                        if (!mcsel) {
                            if (!field_prediction) {
                                if (mb_type != IPPVC_MBTYPE_INTER4V) {
                                    if (mp4_PredictDecode1MV(pInfo, pMBinfo, rowNum, colNum) != MP4_STATUS_OK) {
                                        mp4_Error("Error when decode motion vector");
                                        return MP4_STATUS_ERROR;
                                    }
                                    pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0];
                                    if (quarter_sample) {
                                        mp4_LimitMVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16);
                                        mp4_ComputeChromaMVQ(mvCur, &mvCbCr);
                                    } else {
                                        mp4_LimitMV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16);
                                        mp4_ComputeChromaMV(mvCur, &mvCbCr);
                                    }
                                    mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0];
                                } else {
                                    if (mp4_PredictDecode4MV(pInfo, pMBinfo, rowNum, colNum) != MP4_STATUS_OK) {
                                        mp4_Error("Error when decode motion vector");
                                        return MP4_STATUS_ERROR;