mp4decvopp.c

audio-video-codecs.rar语音编解码器

                                        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC);
                                        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC);
                                        mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC);
                                        //if (cbpy) {
                                        //    mp4_DecodeReconBlockInter_MPEG4(cbpy & 8, pYc, stepYc);
                                        //    mp4_DecodeReconBlockInter_MPEG4(cbpy & 4, pYc+8, stepYc);
                                        //    mp4_DecodeReconBlockInter_MPEG4(cbpy & 2, pYc+8*stepYc, stepYc);
                                        //    mp4_DecodeReconBlockInter_MPEG4(cbpy & 1, pYc+8*stepYc+8, stepYc);
                                        //}
                                    }
                                }
                                mp4_DecodeMCBlockInter_MPEG4(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, mvCbCr, rt, Err_4);
                                mp4_DecodeMCBlockInter_MPEG4(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, mvCbCr, rt, Err_4);
                            }
                        }
                    }
                    if (!obmc_disable) {
                        // OBMC for previous MB
                        if (colNum > 0)
                            if (pMBinfo[-1].type < IPPVC_MBTYPE_INTRA)
                                mp4_OBMC(pInfo, pMBinfo - 1, mvPrev, colNum - 1, rowNum, limitRectL, pYc - 16, stepYc, pYr - 16, stepYr, cbpyPrev, coeffMB, 0);
                        if (mb_type < IPPVC_MBTYPE_INTRA) {
                            if (mb_not_coded) {
                                cbpyPrev = 0;
                                mp4_Zero4MV(mvPrev);
                                ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc);
                                ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc);
                            } else {
                                cbpyPrev = cbpy;
                                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)
                                    goto Err_4;
                                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, 0);
                        }
                    }
#ifdef USE_NOTCODED_STATE
                    ncState ++;
#endif
                    pMBinfo ++;
                    mbInVideoPacket ++;
                    colNum ++;
                    if (colNum == mbPerRow) {
                        colNum = 0;
                        rowNum ++;
                        if (rowNum == mbPerCol) {
                            // skip stuffing
                            while (mp4_ShowBits(pInfo, 10) == 1)
                                mp4_FlushBits(pInfo, 10);
                            return sts;
                        }
                        pYc += (2 * MP4_NUM_EXT_MB + 1) * 16 + (stepYc << 4) - stepYc;
                        pCbc += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCbc << 3) - stepCbc;
                        pCrc += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCrc << 3) - stepCrc;
                        pYr += (2 * MP4_NUM_EXT_MB + 1) * 16 + (stepYr << 4) - stepYr;
                        pCbr += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCbr << 3) - stepCbr;
                        pCrr += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCrr << 3) - stepCrr;
                    } else {
                        pYc += 16; pCrc += 8; pCbc += 8;
                        pYr += 16; pCrr += 8; pCbr += 8;
                    }
                }
                if (!pInfo->VisualObject.VideoObject.resync_marker_disable) {
                    Ipp32s  found;
ErrRet_4:
                    if (mp4_CheckDecodeVideoPacket(pInfo, &found) == MP4_STATUS_OK) {
                        if (found) {
                            mbInVideoPacket = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num - mbCurr;
                            quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant_scale;
                            mbCurr = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num;
                            mp4_CopyMacroBlocks(&pInfo->VisualObject.rFrame, &pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, mbCurr - rowNum * mbPerRow - colNum);
                            rowNum = mbCurr / mbPerRow;
                            colNum = mbCurr % mbPerRow;
                            pYc = pInfo->VisualObject.cFrame.pY + (rowNum * stepYc + colNum) * 16; pCbc = pInfo->VisualObject.cFrame.pCb + (rowNum * stepCbc + colNum) * 8; pCrc = pInfo->VisualObject.cFrame.pCr + (rowNum * stepCrc + colNum) * 8;
                            pYr = pInfo->VisualObject.rFrame.pY + (rowNum * stepYr + colNum) * 16; pCbr = pInfo->VisualObject.rFrame.pCb + (rowNum * stepCbr + colNum) * 8; pCrr = pInfo->VisualObject.rFrame.pCr + (rowNum * stepCrr + colNum) * 8;
                            pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + mbCurr;
#ifdef USE_NOTCODED_STATE
                            ncState = pInfo->VisualObject.VideoObject.ncState + mbCurr;
#endif
                            break;
                        }
                    } else
                        goto Err_4;
                }
            }
            // mark MBs the previous videopacket as invalid for prediction
            for (i = 1; i <= IPP_MIN(mbInVideoPacket, mbPerRow + 1); i ++) {
                pMBinfo[-i].validPred = 0;
            }
        }
Err_4:
        sts = MP4_STATUS_ERROR;
        if (pInfo->stopOnErr)
            return sts;
        if (pInfo->VisualObject.VideoObject.resync_marker_disable || !mp4_SeekResyncMarker(pInfo)) {
            mp4_CopyMacroBlocks(&pInfo->VisualObject.rFrame, &pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum,  pInfo->VisualObject.VideoObject.MacroBlockPerVOP - rowNum * mbPerRow - colNum);
            return sts;
        }
        goto ErrRet_4;
    }
}

#ifdef _OMP_KARABAS

static mp4_Status mp4_DecodeVOP_P_DecodeSlice(mp4_Info* pInfo, Ipp32s curRow, mp4_MacroBlockMT* pMBinfoMT)
{
    Ipp32s           mb_not_coded, mb_type, cbpc, cbpy, quant, quantPred, ac_pred_flag, dcVLC;
    Ipp32s           i, j, mbPerRow, scan, pat;
    mp4_MacroBlock  *pMBinfo;
    Ipp32s           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;
    if (pInfo->VisualObject.VideoObject.short_video_header) {
        quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.vop_quant;
        for (j = 0; j < mbPerRow; j ++) {
            do {
                mb_not_coded = mp4_GetBit(pInfo);
                if (mb_not_coded)
                    break;
                if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK)
                    goto Err;
            } while (mb_type == IPPVC_MB_STUFFING);
            pMBinfo->not_coded = (Ipp8u)mb_not_coded;
            if (mb_not_coded) {
                pMBinfo->mv[0].dx = pMBinfo->mv[0].dy = 0;
                mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED);
            } else {
                pMBinfo->type = (Ipp8u)mb_type;
                if (mb_type == IPPVC_MBTYPE_INTER4V || mb_type == IPPVC_MBTYPE_INTER4V_Q)
                    goto Err;
                if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK)
                    goto Err;
                if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q)
                    mp4_UpdateQuant(pInfo, quant);
                pat = (cbpy << 2) + cbpc;
                pMBinfoMT->pat = (Ipp8u)pat;
                if (mb_type >= IPPVC_MBTYPE_INTRA) {
                    mp4_ReconstructCoeffsIntraMB_SVH(pInfo, pMBinfoMT->dctCoeffs, pMBinfoMT->lnz, pat, quant, Err);
                    pMBinfo->mv[0].dx = pMBinfo->mv[0].dy = 0;
                } else {
                    if (mp4_PredictDecodeMV(pInfo, pMBinfo, pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.frGOB, curRow, j) != MP4_STATUS_OK)
                        goto Err;
                    mp4_ReconstructCoeffsInterMB_SVH(pInfo, pMBinfoMT->dctCoeffs, pMBinfoMT->lnz, pat, quant, Err);
                }
            }
            pMBinfo ++;
            pMBinfoMT ++;
            pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.nmb ++;
            if (pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.nmb == pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_macroblocks_in_gob && pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number < (pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_gobs_in_vop - 1)) {
                if (mp4_CheckDecodeGOB_SVH(pInfo) != MP4_STATUS_OK)
                    goto Err;
                if (!pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_header_empty) {
                    quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.quant_scale;
                    pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.frGOB = curRow + 1;
                }
                pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.nmb = 0;
            }
        }
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.vop_quant = quant;
    } else {
        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)
                    goto Err;
            if (mb_type != IPPVC_MB_STUFFING) {
                pMBinfo->validPred = 1;
                if (!mb_not_coded) {
                    if (mb_type >= IPPVC_MBTYPE_INTRA)
                        ac_pred_flag = mp4_GetBit(pInfo);
                    if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK)
                        goto Err;
                    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) {
                            field_prediction = mp4_GetBit(pInfo);
                            if (field_prediction) {
                                mb_ftfr = mp4_GetBit(pInfo);
                                mb_fbfr = mp4_GetBit(pInfo);
                            }
                        }
                    }
                    pat = (cbpy << 2) + cbpc;
                    pMBinfoMT->pat = (Ipp8u)pat;
                    if (mb_type >= IPPVC_MBTYPE_INTRA) {
                        if (pInfo->mbInVideoPacket == 0)
                            quantPred = quant;
                        dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                        if (mp4_ReconstructCoeffsIntraMB(pInfo, j, pat, quant, dcVLC, ac_pred_flag, pMBinfoMT->dctCoeffs, pMBinfoMT->lnz) != MP4_STATUS_OK)
                            goto Err;
                        mp4_Zero4MV(pMBinfo->mv);
                    } else {
                        mp4_U