mp4decvops.c

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

/* ///////////////////////////////////////////////////////////////////////
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2001-2008 Intel Corporation. All Rights Reserved.
//
//  Description:    Decodes S-VOPs
//
*/

#include "umc_defs.h"

#if defined (UMC_ENABLE_MPEG4_VIDEO_DECODER)

#include "mp4.h"
#include "mp4dec.h"

/*
//  decode MPEG-4 SVOP
*/
mp4_Status mp4_DecodeVOP_S(mp4_Info* pInfo)
{
    __ALIGN16(Ipp16s, coeffMB, 64*6);
    Ipp32s          quant, quantPred, i, j, dcVLC, nmb, dx, dy, pat;
    Ipp32s          stepYr, stepYc, stepCbr, stepCbc, stepCrr, stepCrc, mbPerRow, mbPerCol;
    Ipp32s          mbCurr, mbInVideoPacket, colNum, rowNum, stepF[6];
    Ipp8u           *pYc, *pCbc, *pCrc, *pYr, *pCbr, *pCrr, *pF[6];
    Ipp32s          mb_not_coded, mb_type, cbpc, cbpy, ac_pred_flag, cbpyPrev, mcsel;
    Ipp32s          scan, obmc_disable, rt, quarter_sample, interlaced, fcode_forward;
    IppiRect        limitRectL, limitRectC;
    IppMotionVector mvCur[4], mvPrev[4], mvTmp[4], mvCbCr;
    mp4_MacroBlock *pMBinfo;
    IppiRect        spriteRect, vopRect;
    mp4_Status      sts;

    mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
    mbPerCol = pInfo->VisualObject.VideoObject.MacroBlockPerCol;
    stepYc = pInfo->VisualObject.cFrame.stepY;
    stepYr = pInfo->VisualObject.rFrame.stepY;
    stepCbc = pInfo->VisualObject.cFrame.stepCb;
    stepCbr = pInfo->VisualObject.rFrame.stepCb;
    stepCrc = pInfo->VisualObject.cFrame.stepCr;
    stepCrr = pInfo->VisualObject.rFrame.stepCr;
    pYc = pInfo->VisualObject.cFrame.pY;
    pCbc = pInfo->VisualObject.cFrame.pCb;
    pCrc = pInfo->VisualObject.cFrame.pCr;
    pYr = pInfo->VisualObject.rFrame.pY;
    pCbr = pInfo->VisualObject.rFrame.pCb;
    pCrr = pInfo->VisualObject.rFrame.pCr;
    stepF[0] = stepF[1] = stepF[2] = stepF[3] = stepYc; stepF[4] = stepCbc; stepF[5] = stepCrc;
    // Bounding rectangle for MV limitation
    limitRectL.x = - 16 * MP4_NUM_EXT_MB;
    limitRectL.y = - 16 * MP4_NUM_EXT_MB;
    limitRectL.width = pInfo->VisualObject.VideoObject.width + 16 * 2 * MP4_NUM_EXT_MB;
    limitRectL.height = pInfo->VisualObject.VideoObject.height + 16 * 2 * MP4_NUM_EXT_MB;
    limitRectC.x = -8 * MP4_NUM_EXT_MB;
    limitRectC.y = -8 * MP4_NUM_EXT_MB;
    limitRectC.width = (pInfo->VisualObject.VideoObject.width >> 1) + 8 * 2 * MP4_NUM_EXT_MB;
    limitRectC.height = (pInfo->VisualObject.VideoObject.height >> 1) + 8 * 2 * MP4_NUM_EXT_MB;
    pMBinfo = pInfo->VisualObject.VideoObject.MBinfo;
    rt = pInfo->VisualObject.VideoObject.VideoObjectPlane.rounding_type;
    quarter_sample = pInfo->VisualObject.VideoObject.quarter_sample;
    obmc_disable = pInfo->VisualObject.VideoObject.obmc_disable;
    interlaced = pInfo->VisualObject.VideoObject.interlaced;
    scan = pInfo->VisualObject.VideoObject.VideoObjectPlane.alternate_vertical_scan_flag ? IPPVC_SCAN_VERTICAL : IPPVC_SCAN_ZIGZAG;
    nmb = pInfo->VisualObject.VideoObject.MacroBlockPerVOP;
    quant = quantPred = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant;
    mbCurr = colNum = rowNum = 0;
    cbpc = 0;
    // init WarpSpec for Sprites or GMC
    vopRect.x = 0;
    vopRect.y = 0;
    vopRect.width = pInfo->VisualObject.VideoObject.width;
    vopRect.height = pInfo->VisualObject.VideoObject.height;
    if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_STATIC) {
        spriteRect.x = pInfo->VisualObject.VideoObject.sprite_left_coordinate;
        spriteRect.y = pInfo->VisualObject.VideoObject.sprite_top_coordinate;
        spriteRect.width = pInfo->VisualObject.VideoObject.sprite_width;
        spriteRect.height = pInfo->VisualObject.VideoObject.sprite_height;
        fcode_forward = 1;
    } else {
        spriteRect = vopRect; // for shapes they may be different !!!!!!
        fcode_forward = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_forward;
    }
    ippiWarpInit_MPEG4(pInfo->VisualObject.VideoObject.WarpSpec,
                       pInfo->VisualObject.VideoObject.VideoObjectPlane.warping_mv_code_du,
                       pInfo->VisualObject.VideoObject.VideoObjectPlane.warping_mv_code_dv,
                       pInfo->VisualObject.VideoObject.sprite_warping_points,
                       pInfo->VisualObject.VideoObject.sprite_enable,
                       pInfo->VisualObject.VideoObject.sprite_warping_accuracy,
                       rt, quarter_sample, fcode_forward,
                       &spriteRect, &vopRect);
// decode basic sprites
    if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_STATIC) {
        //if (pInfo->VisualObject.VideoObject.shape != MP4_SHAPE_TYPE_RECTANGULAR) {
        //    if (mp4_InitVOPShape(pInfo) != MP4_STATUS_OK)
        //        return MP4_STATUS_ERROR;
        //}
        ippiWarpLuma_MPEG4_8u_C1R(pInfo->VisualObject.sFrame.pY, pInfo->VisualObject.sFrame.stepY,
                                  pYc, stepYc, &vopRect, pInfo->VisualObject.VideoObject.WarpSpec);
        if (pInfo->VisualObject.VideoObject.sprite_brightness_change)
            ippiChangeSpriteBrightness_MPEG4_8u_C1IR(pYc, stepYc, vopRect.width, vopRect.height, pInfo->VisualObject.VideoObject.VideoObjectPlane.brightness_change_factor);
        vopRect.width >>= 1;  vopRect.height >>= 1;
        ippiWarpChroma_MPEG4_8u_P2R(pInfo->VisualObject.sFrame.pCb, pInfo->VisualObject.sFrame.stepCb,
                                    pInfo->VisualObject.sFrame.pCr, pInfo->VisualObject.sFrame.stepCr,
                                    pCbc, stepCbc, pCrc, stepCrc, &vopRect, pInfo->VisualObject.VideoObject.WarpSpec);
        return MP4_STATUS_OK;
    }
    sts = MP4_STATUS_OK;
// decode data_partitioned S(GMC)-VOP
    if (pInfo->VisualObject.VideoObject.data_partitioned) {
        for (;;) {
            mp4_DataPartMacroBlock *pMBdp;
            Ipp32s  x, y;

            x = colNum;
            y = rowNum;
            // reset Intra prediction buffer on new Video_packet
            mp4_ResetIntraPredBuffer(pInfo);
            pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr];
            pMBinfo = &pInfo->VisualObject.VideoObject.MBinfo[mbCurr];
            mbInVideoPacket = 0;
            // decode not_coded/mcsel/mb_type/cbpc/MV part
            for (;;) {
                mb_not_coded = mp4_GetBit(pInfo);
                if (mb_not_coded) {
                    mb_type = IPPVC_MBTYPE_INTER;
                    mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED);
                } else {
                    if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK)
                        goto Err_2;
                }
                if (mb_type != IPPVC_MB_STUFFING) {
                    if (mbInVideoPacket == nmb - mbCurr) {
                        mp4_Error("DC Marker missed");
                        goto Err_2;
                    }
                    pMBinfo->validPred = 1;
                    if (mb_type < IPPVC_MBTYPE_INTER4V && !mb_not_coded)
                        mcsel = mp4_GetBit(pInfo);
                    else
                        mcsel = mb_not_coded;
                    if (!mcsel) {
                        if (mb_type <= IPPVC_MBTYPE_INTER4V) {
                            if (mb_type != IPPVC_MBTYPE_INTER4V) {
                                if (mp4_PredictDecode1MV(pInfo, pMBinfo, y, x) != MP4_STATUS_OK)
                                    goto Err_2;
                                pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0];
                            } else {
                                if (mp4_PredictDecode4MV(pInfo, pMBinfo, y, x) != MP4_STATUS_OK)
                                    goto Err_2;
                            }
                        } else {
                            mp4_Zero4MV(pMBinfo->mv);
                        }
                    } else {
                        ippiCalcGlobalMV_MPEG4(x << 4, y << 4, pMBinfo->mv, pInfo->VisualObject.VideoObject.WarpSpec);
                        pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0];
                    }
                    pMBinfo->not_coded = (Ipp8u)mb_not_coded;
                    pMBinfo->type = (Ipp8u)mb_type;
                    pMBinfo ++;
                    pMBdp->pat = (Ipp8u)cbpc;
                    pMBdp->mcsel = (Ipp8u)mcsel;
                    pMBdp ++;
                    mbInVideoPacket ++;
                    x ++;
                    if (x == mbPerRow) {
                        x = 0;
                        y ++;
                    }
                }
                if (mp4_ShowBits(pInfo, 17) == MP4_MV_MARKER) {
                    mp4_GetBits(pInfo, 17);
                    break;
                }
            }
            pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr];
            pMBinfo = &pInfo->VisualObject.VideoObject.MBinfo[mbCurr];
            // decode ac_pred_flag/cbpy/dquant/IntraDC part
            for (i = 0; i < mbInVideoPacket; i ++) {
                if (!pMBinfo->not_coded) {
                    mb_type = pMBinfo->type;
                    if (mb_type >= IPPVC_MBTYPE_INTRA)
                        pMBdp->ac_pred_flag = (Ipp8u)mp4_GetBit(pInfo);
                    if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK)
                        goto Err_2;
                    pMBdp->pat = (Ipp8u)((cbpy << 2) + pMBdp->pat);
                    quantPred = quant;
                    if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q)
                        mp4_UpdateQuant(pInfo, quant);
                    pMBdp->quant = (Ipp8u)quant;
                    if (i == 0)
                        quantPred = quant;
                    // decode DC coefficient of Intra blocks
                    dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0;
                    if ((mb_type >= IPPVC_MBTYPE_INTRA) && dcVLC) {
                        for (j = 0; j < 6; j ++) {
                            if (ippiDecodeDCIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, &pMBdp->dct_dc[j], j < 4 ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA) != ippStsNoErr)
                                goto Err_2;
                        }
                    }
                } else
                    pMBdp->pat = 0;
                pMBinfo->not_coded = 0;  // for B-VOP all MB have MVs
                if (pMBdp->mcsel)
                    pMBinfo->type = IPPVC_MBTYPE_INTRA;  // for OBMC MVs
                pMBdp ++;
                pMBinfo ++;
            }
            if (mbCurr + mbInVideoPacket < nmb)
                pMBinfo->type = IPPVC_MBTYPE_INTRA;  // for OBMC set first MB of the next videopacket as invalid for right MV
            pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr];
            pMBinfo = &pInfo->VisualObject.VideoObject.MBinfo[mbCurr];
            // decode coeffs and reconstruct macroblocks
            for (i = 0; i < mbInVideoPacket; i ++) {
                if (colNum == 0) {
                    // reset B-prediction blocks on new row
                    mp4_ResetIntraPredBblock(pInfo);