mp4decvopi.c

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

    }
// decode not data partitioned I-VOP
    else {
        Ipp32s  stepY = stepYc, dct_type = 0, pYoff23 = 8 * stepYc;
        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);
                }
                if (mp4_DecodeMCBPC_I(pInfo, &mb_type, &cbpc) != MP4_STATUS_OK)
                    goto Err_3;
                if (mb_type != IPPVC_MB_STUFFING) {
                    ac_pred_flag = mp4_GetBit(pInfo);
                    if (mp4_DecodeCBPY_I(pInfo, &cbpy) != MP4_STATUS_OK)
                        goto Err_3;
                    quantPred = quant;
                    if (mb_type == IPPVC_MBTYPE_INTRA_Q)
                        mp4_UpdateQuant(pInfo, quant);
                    if (mbInVideoPacket == 0)
                        quantPred = quant;
                    dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                    if (pInfo->VisualObject.VideoObject.interlaced) {
                        dct_type = mp4_GetBit(pInfo);
                        if (dct_type) {
                            stepY = stepYc * 2;
                            pYoff23 = stepYc;
                        } else {
                            stepY = stepYc;
                            pYoff23 = 8 * stepYc;
                        }
                        stepFc[0] = stepFc[1] = stepFc[2] = stepFc[3] = stepY;
                    }
                    pFc[2] = pFc[0] + pYoff23; pFc[3] = pFc[1] + pYoff23;
                    if (mp4_DecodeIntraMB(pInfo, colNum, (cbpy << 2) + cbpc, quant, dcVLC, ac_pred_flag, pFc, stepFc) != MP4_STATUS_OK)
                        goto Err_3;
                    mbInVideoPacket ++;
                    colNum ++;
                    if (colNum == mbPerRow) {
                        colNum = 0;
                        rowNum ++;
                        if (rowNum == mbPerCol) {
                            // skip stuffing
                            while (mp4_ShowBits9(pInfo, 9) == 1)
                                mp4_FlushBits(pInfo, 9);
                            return sts;
                        }
                        pFc[0] += (2 * MP4_NUM_EXT_MB + 1) * 16 + (stepYc << 4) - stepYc;
                        pFc[1] += (2 * MP4_NUM_EXT_MB + 1) * 16 + (stepYc << 4) - stepYc;
                        pFc[4] += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCbc << 3) - stepCbc;
                        pFc[5] += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCrc << 3) - stepCrc;
                    } else {
                        pFc[0] += 16; pFc[1] += 16; pFc[4] += 8; pFc[5] += 8;
                    }
                }
                if (!pInfo->VisualObject.VideoObject.resync_marker_disable) {
                    Ipp32s  found;
ErrRet_3:
                    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;
                            pFc[0] = pInfo->VisualObject.cFrame.pY + (rowNum * stepYc + colNum) * 16; pFc[1] = pFc[0] + 8;
                            pFc[4] = pInfo->VisualObject.cFrame.pCb + (rowNum * stepCbc + colNum) * 8; pFc[5] = pInfo->VisualObject.cFrame.pCr + (rowNum * stepCrc + colNum) * 8;
                            break;
                        }
                    } else
                        goto Err_3;
                }
            }
        }
Err_3:
        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_3;
    }
}

#ifdef _OMP_KARABAS

static mp4_Status mp4_DecodeVOP_I_DecodeSlice(mp4_Info* pInfo, Ipp32s rowNum, mp4_MacroBlockMT* pMBinfoMT)
{
    Ipp32s  mb_type, cbpc, cbpy, quant, quantPred, ac_pred_flag, dcVLC;
    Ipp32s  mbPerRow, pat, colNum;

    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    if (pInfo->VisualObject.VideoObject.short_video_header) {
        quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.vop_quant;
        for (colNum = 0; colNum < mbPerRow; colNum ++) {
            do {
                if (mp4_DecodeMCBPC_I(pInfo, &mb_type, &cbpc) != MP4_STATUS_OK)
                    goto Err;
            } while (mb_type == IPPVC_MB_STUFFING);
            if (mp4_DecodeCBPY_I(pInfo, &cbpy) != MP4_STATUS_OK)
                goto Err;
            if (mb_type == IPPVC_MBTYPE_INTRA_Q)
                mp4_UpdateQuant(pInfo, quant);
            pat = (cbpy << 2) + cbpc;
            mp4_ReconstructCoeffsIntraMB_SVH(pInfo, pMBinfoMT->dctCoeffs, pMBinfoMT->lnz, pat, quant, Err);
            colNum ++;
            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.nmb = 0;
            }
        }
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.vop_quant = quant;
    } else {
        // reset B-prediction blocks on new row
        mp4_ResetIntraPredBblock(pInfo);
        quant = quantPred = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant;
        for (colNum = 0; colNum < mbPerRow;) {
            if (mp4_DecodeMCBPC_I(pInfo, &mb_type, &cbpc) != MP4_STATUS_OK)
                goto Err;
            if (mb_type != IPPVC_MB_STUFFING) {
                ac_pred_flag = mp4_GetBit(pInfo);
                if (mp4_DecodeCBPY_I(pInfo, &cbpy) != MP4_STATUS_OK)
                    goto Err;
                quantPred = quant;
                if (mb_type == IPPVC_MBTYPE_INTRA_Q)
                    mp4_UpdateQuant(pInfo, quant);
                if (pInfo->mbInVideoPacket == 0)
                    quantPred = quant;
                dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                if (pInfo->VisualObject.VideoObject.interlaced)
                    pMBinfoMT->dct_type = (Ipp8u)mp4_GetBit(pInfo);
                pat = (cbpy << 2) + cbpc;
                if (mp4_ReconstructCoeffsIntraMB(pInfo, colNum, pat, quant, dcVLC, ac_pred_flag, pMBinfoMT->dctCoeffs, pMBinfoMT->lnz) != MP4_STATUS_OK)
                    goto Err;
                pMBinfoMT ++;
                colNum ++;
                pInfo->mbInVideoPacket ++;
            }
            if (!pInfo->VisualObject.VideoObject.resync_marker_disable) {
                Ipp32s  found;
                if (mp4_CheckDecodeVideoPacket(pInfo, &found) == MP4_STATUS_OK) {
                    if (found) {
                        quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant_scale;
                        // reset Intra prediction buffer on new Video_packet
                        mp4_ResetIntraPredBuffer(pInfo);
                        pInfo->mbInVideoPacket = 0;
                    }
                } else
                    goto Err;
            }
        }
        pInfo->VisualObject.VideoObject.VideoObjectPlane.quant = quant;
    }
    return MP4_STATUS_OK;
Err:
    return MP4_STATUS_ERROR;
}

static void mp4_DecodeVOP_I_ReconSlice(mp4_Info* pInfo, Ipp32s curRow, mp4_MacroBlockMT* pMBinfoMT)
{
    Ipp32s j, stepYc, stepCbc, stepCrc, stepFc[6], mbPerRow;
    Ipp8u  *pYc, *pCbc, *pCrc, *pFc[6];

    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    stepYc = pInfo->VisualObject.cFrame.stepY;
    stepCbc = pInfo->VisualObject.cFrame.stepCb;
    stepCrc = pInfo->VisualObject.cFrame.stepCr;
    pYc = pInfo->VisualObject.cFrame.pY   + curRow * 16 * stepYc;
    pCbc = pInfo->VisualObject.cFrame.pCb + curRow * 8 * stepCbc;
    pCrc = pInfo->VisualObject.cFrame.pCr + curRow * 8 * stepCrc;
    stepFc[0] = stepFc[1] = stepFc[2] = stepFc[3] = stepYc; stepFc[4] = stepCbc; stepFc[5] = stepCrc;
    pFc[0] = pYc; pFc[1] = pYc + 8; pFc[2] = pYc + 8 * stepYc; pFc[3] = pYc + 8 * stepYc + 8; pFc[4] = pCbc; pFc[5] = pCrc;
    if (pInfo->VisualObject.VideoObject.short_video_header) {
        for (j = 0; j < mbPerRow; j ++) {
            mp4_DCTInvCoeffsIntraMB(pMBinfoMT->dctCoeffs, pMBinfoMT->lnz, pFc, stepFc);
            pMBinfoMT ++;
            pFc[0] += 16; pFc[1] += 16; pFc[2] += 16; pFc[3] += 16; pFc[4] += 8; pFc[5] += 8;
        }
    } else {
        Ipp32s   stepY, pYoff23, interlaced;

        stepY = stepYc;
        pYoff23 = 8 * stepYc;
        interlaced = pInfo->VisualObject.VideoObject.interlaced;
        for (j = 0; j < mbPerRow; j ++) {
            if (interlaced) {
                if (pMBinfoMT->dct_type) {
                    stepY = stepYc * 2;
                    pYoff23 = stepYc;
                } else {
                    stepY = stepYc;
                    pYoff23 = 8 * stepYc;
                }
                stepFc[0] = stepFc[1] = stepFc[2] = stepFc[3] = stepY;
            }
            pFc[2] = pFc[0] + pYoff23; pFc[3] = pFc[1] + pYoff23;
            mp4_DCTInvCoeffsIntraMB(pMBinfoMT->dctCoeffs, pMBinfoMT->lnz, pFc, stepFc);
            pMBinfoMT ++;
            pFc[0] += 16; pFc[1] += 16; pFc[4] += 8; pFc[5] += 8;
        }
    }
}

mp4_Status mp4_DecodeVOP_I_MT(mp4_Info* pInfo)
{
    Ipp32s     i, mbPerCol, mbPerRow, sBitOff;
    Ipp8u      *sBufPtr;
    mp4_Status sts = MP4_STATUS_OK;

    sBufPtr = pInfo->bufptr;
    sBitOff = pInfo->bitoff;
    mbPerCol = pInfo->VisualObject.VideoObject.MacroBlockPerCol;
    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    if (pInfo->VisualObject.VideoObject.short_video_header) {
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number = 0;
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.nmb = 0;
        pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.frGOB = 0;
    } else {
        pInfo->mbInVideoPacket = 0;
        mp4_ResetIntraPredBuffer(pInfo);
        if (pInfo->VisualObject.VideoObject.sprite_enable != MP4_SPRITE_STATIC)
            ippsZero_8u((Ipp8u*)pInfo->VisualObject.VideoObject.MBinfo, pInfo->VisualObject.VideoObject.MacroBlockPerVOP * sizeof(mp4_MacroBlock));
    }
    i = 0;
#ifdef _OPENMP
#pragma  omp parallel shared(pInfo, i, mbPerCol, mbPerRow, sts) num_threads(pInfo->num_threads)
#endif
    {
        Ipp32s            idThread = 0;
        Ipp32s            curRow;
        mp4_MacroBlockMT* pMBinfoMT;

#ifdef _OPENMP
        idThread = omp_get_thread_num();
        vm_set_current_thread_priority(pInfo->mTreadPriority);
#endif
        pMBinfoMT = pInfo->pMBinfoMT + mbPerRow * idThread;
        for (;;) {
#ifdef _OPENMP
#pragma omp critical(HI_FOXY)
#endif
            {
                curRow = i;
                i ++;
                if (curRow < mbPerCol)
                    if (mp4_DecodeVOP_I_DecodeSlice(pInfo, curRow, pMBinfoMT) != MP4_STATUS_OK) {
                        sts = MP4_STATUS_ERROR;
                        i = curRow = mbPerCol;
                    }
            }
            if ((curRow >= mbPerCol) || (sts != MP4_STATUS_OK))
                break;
            mp4_DecodeVOP_I_ReconSlice(pInfo, curRow, pMBinfoMT);
        }
    }
    if (sts != MP4_STATUS_OK && !pInfo->stopOnErr) {
        pInfo->bufptr = sBufPtr;
        pInfo->bitoff = sBitOff;
        sts = mp4_DecodeVOP_I(pInfo);
    } else {
        if (pInfo->VisualObject.VideoObject.short_video_header)
            mp4_AlignBits(pInfo);
        else {
            // skip stuffing
            while (mp4_ShowBits(pInfo, 9) == 1)
                mp4_FlushBits(pInfo, 9);
        }
    }
    return sts;
}

#endif // _OMP_KARABAS

#endif //defined (UMC_ENABLE_MPEG4_VIDEO_DECODER)