mp4decvopb.c

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

                pYn += 16; pCrn += 8; pCbn += 8;
            }
            if (!pInfo->VisualObject.VideoObject.resync_marker_disable) {
                Ipp32s  found;
ErrRet_2:
                if (mp4_CheckDecodeVideoPacket(pInfo, &found) == MP4_STATUS_OK) {
                    if (found) {
                        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;
                        pYp = pInfo->VisualObject.rFrame.pY + (rowNum * stepYp + colNum) * 16; pCbp = pInfo->VisualObject.rFrame.pCb + (rowNum * stepCbp + colNum) * 8; pCrp = pInfo->VisualObject.rFrame.pCr + (rowNum * stepCrp + colNum) * 8;
                        pYn = pInfo->VisualObject.nFrame.pY + (rowNum * stepYn + colNum) * 16; pCbn = pInfo->VisualObject.nFrame.pCb + (rowNum * stepCbn + colNum) * 8; pCrn = pInfo->VisualObject.nFrame.pCr + (rowNum * stepCrn + colNum) * 8;
                        pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + mbCurr;
                        break;
                    }
                } else
                    goto Err_2;
            }
        }
    }
Err_2:
    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_2;
}

#ifdef _OMP_KARABAS

static mp4_Status mp4_DecodeVOP_B_DecodeSlice(mp4_Info* pInfo, Ipp32s curRow, mp4_MacroBlockMT* pMBinfoMT)
{
    Ipp32u          code;
    Ipp32s          mb_type, cbpb, modb, quant, TRB, TRD, j, mbPerRow, scan, fcode_forward, fcode_backward, sts;
    Ipp32s          interlaced, field_prediction, dct_type, mb_ftfr, mb_fbfr, mb_btfr, mb_bbfr;
    mp4_MacroBlock *pMBinfo;
    IppMotionVector mvForwT, mvBackT, mvForwB, mvBackB, *pMVField;

    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + curRow * mbPerRow;
    quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant;
    TRD = pInfo->VisualObject.VideoObject.TRD;
    TRB = pInfo->VisualObject.VideoObject.TRB;
    scan = pInfo->VisualObject.VideoObject.VideoObjectPlane.alternate_vertical_scan_flag ? IPPVC_SCAN_VERTICAL : IPPVC_SCAN_ZIGZAG;
    fcode_forward = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_forward;
    fcode_backward = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_backward;
    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 = mb_btfr = mb_bbfr = 0;
    // reset MV predictors at new Row
    mvForwT.dx = mvForwT.dy = mvBackT.dx = mvBackT.dy = mvForwB.dx = mvForwB.dy = mvBackB.dx = mvBackB.dy = 0;
    for (j = 0; j < mbPerRow; j ++) {
        if (pMBinfo->not_coded) {
            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");
                    goto Err;
                }
                if (modb == 0)
                    cbpb = mp4_GetBits9(pInfo, 6);
                if (mb_type != IPPVC_MBTYPE_DIRECT && cbpb != 0)
                    mp4_UpdateQuant_B(pInfo, quant);
            }
            if (!interlaced) {
                if (mb_type == IPPVC_MBTYPE_FORWARD) {
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_FORWARD);
                    sts = mp4_DecodeMV(pInfo, &mvForwT, fcode_forward);
                    pMBinfoMT->mvF[0] = mvForwT;
                } else if (mb_type == IPPVC_MBTYPE_BACKWARD) {
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_BACKWARD);
                    sts = mp4_DecodeMV(pInfo, &mvBackT, fcode_backward);
                    pMBinfoMT->mvB[0] = mvBackT;
                } else if (mb_type == IPPVC_MBTYPE_INTERPOLATE) {
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTERPOLATE);
                    sts = mp4_DecodeMV(pInfo, &mvForwT, fcode_forward);
                    if (sts == MP4_STATUS_OK)
                        sts = mp4_DecodeMV(pInfo, &mvBackT, fcode_backward);
                    pMBinfoMT->mvF[0] = mvForwT;
                    pMBinfoMT->mvB[0] = mvBackT;
                } else { // IPPVC_MBTYPE_DIRECT
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_DIRECT);
                    //f MVs of collocated block of recently decoded I or P frame used in Direct mode
                    sts = mp4_DecodeMV_Direct(pInfo, pMBinfo->mv, pMBinfoMT->mvF, pMBinfoMT->mvB, TRB, TRD, modb, pMBinfo->type);
                }
            } else {
                dct_type = 0;
                field_prediction = 0;
                if (cbpb != 0)
                    dct_type = mp4_GetBit(pInfo);
                if (mb_type != IPPVC_MBTYPE_DIRECT) {
                    field_prediction = mp4_GetBit(pInfo);
                    if (field_prediction) {
                        if (mb_type != IPPVC_MBTYPE_BACKWARD) {
                            mb_ftfr = mp4_GetBit(pInfo);
                            mb_fbfr = mp4_GetBit(pInfo);
                        }
                        if (mb_type != IPPVC_MBTYPE_FORWARD) {
                            mb_btfr = mp4_GetBit(pInfo);
                            mb_bbfr = mp4_GetBit(pInfo);
                        }
                    }
                }
                if (mb_type == IPPVC_MBTYPE_FORWARD) {
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_FORWARD);
                    if (!field_prediction) {
                        sts = mp4_DecodeMV(pInfo, &mvForwT, fcode_forward);
                        mvForwB = mvForwT;
                        pMBinfoMT->mvF[0] = mvForwT;
                    } else {
                        mvForwT.dy = (Ipp16s)mp4_Div2(mvForwT.dy);
                        mvForwB.dy = (Ipp16s)mp4_Div2(mvForwB.dy);
                        sts = mp4_DecodeMV(pInfo, &mvForwT, fcode_forward);
                        if (sts == MP4_STATUS_OK)
                            sts = mp4_DecodeMV(pInfo, &mvForwB, fcode_forward);
                        pMBinfoMT->mvF[0] = mvForwT;
                        pMBinfoMT->mvF[2] = mvForwB;
                        mvForwT.dy <<= 1;
                        mvForwB.dy <<= 1;
                    }
                } else if (mb_type == IPPVC_MBTYPE_BACKWARD) {
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_BACKWARD);
                    if (!field_prediction) {
                        sts = mp4_DecodeMV(pInfo, &mvBackT, fcode_backward);
                        mvBackB = mvBackT;
                        pMBinfoMT->mvB[0] = mvBackT;
                    } else {
                        mvBackT.dy = (Ipp16s)mp4_Div2(mvBackT.dy);
                        mvBackB.dy = (Ipp16s)mp4_Div2(mvBackB.dy);
                        sts = mp4_DecodeMV(pInfo, &mvBackT, fcode_backward);
                        if (sts == MP4_STATUS_OK)
                            sts = mp4_DecodeMV(pInfo, &mvBackB, fcode_backward);
                        pMBinfoMT->mvB[0] = mvBackT;
                        pMBinfoMT->mvB[2] = mvBackB;
                        mvBackT.dy <<= 1;
                        mvBackB.dy <<= 1;
                    }
                } else if (mb_type == IPPVC_MBTYPE_INTERPOLATE) {
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTERPOLATE);
                    if (!field_prediction) {
                        sts = mp4_DecodeMV(pInfo, &mvForwT, fcode_forward);
                        if (sts == MP4_STATUS_OK)
                            sts = mp4_DecodeMV(pInfo, &mvBackT, fcode_backward);
                        mvBackB = mvBackT;
                        pMBinfoMT->mvB[0] = mvBackT;
                        mvForwB = mvForwT;
                        pMBinfoMT->mvF[0] = mvForwT;
                    } else {
                        mvForwT.dy = (Ipp16s)mp4_Div2(mvForwT.dy);
                        mvForwB.dy = (Ipp16s)mp4_Div2(mvForwB.dy);
                        mvBackT.dy = (Ipp16s)mp4_Div2(mvBackT.dy);
                        mvBackB.dy = (Ipp16s)mp4_Div2(mvBackB.dy);
                        sts = mp4_DecodeMV(pInfo, &mvForwT, fcode_forward);
                        if (sts == MP4_STATUS_OK)
                            sts = mp4_DecodeMV(pInfo, &mvForwB, fcode_forward);
                        if (sts == MP4_STATUS_OK)
                            sts = mp4_DecodeMV(pInfo, &mvBackT, fcode_backward);
                        if (sts == MP4_STATUS_OK)
                            sts = mp4_DecodeMV(pInfo, &mvBackB, fcode_backward);
                        pMBinfoMT->mvF[0] = mvForwT;
                        pMBinfoMT->mvF[2] = mvForwB;
                        mvForwT.dy <<= 1;
                        mvForwB.dy <<= 1;
                        pMBinfoMT->mvB[0] = mvBackT;
                        pMBinfoMT->mvB[2] = mvBackB;
                        mvBackT.dy <<= 1;
                        mvBackB.dy <<= 1;
                    }
                } else { // IPPVC_MBTYPE_DIRECT
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_DIRECT);
                    //f MVs of collocated block of recently decoded I or P frame used in Direct mode
                    if (!(pMBinfo->field_info & 1))
                        sts = mp4_DecodeMV_Direct(pInfo, pMBinfo->mv, pMBinfoMT->mvF, pMBinfoMT->mvB, TRB, TRD, modb, pMBinfo->type);
                    else
                        sts = mp4_DecodeMV_DirectField(pInfo, (pMBinfo->field_info >> 1) & 1, (pMBinfo->field_info >> 2) & 1, &pMVField[0], &pMVField[1], &pMBinfoMT->mvF[0], &pMBinfoMT->mvF[2], &pMBinfoMT->mvB[0], &pM