umc_vc1_dec_blk.cpp

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

                blkType = VC1_BLK_INTRA_TOP;
            }
        }
        break;
    case 0:
    case 2:
        {
            // A, C unavailable
            #ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                                                "DC left prediction\n");
            #endif

            CurrBlk->DC = CurrBlk->DC + defaultDC;
        }
        break;
    }

    pBlock[0] = CurrBlk->DC;
    PredData->DC[blk_num] = CurrBlk->DC;
    return blkType;
}

static const DCPrediction DCPredictionTable[] =
{
        (DCPrediction)(GetDCPrediction),
        (DCPrediction)(GetDCACPrediction)
};

VC1Status BLKLayer_Intra_Luma(VC1Context* pContext, Ipp32s blk_num, Ipp32u bias, Ipp32u ACPRED)
{
    Ipp16s*   m_pBlock  = pContext->m_pBlock + VC1_BlkStart[blk_num];
    VC1Block* pBlock    = &pContext->m_pCurrMB->m_pBlocks[blk_num];
    VC1DCMBParam*  CurrDC = pContext->CurrDC;
    VC1DCBlkParam* CurrBlk = &CurrDC->DCBlkPred[blk_num];
    VC1DCPredictors* DCPred = &pContext->DCPred;

    IppStatus ret;
    Ipp32s DCCOEF;
    Ipp32s DCSIGN;
    Ipp32u i = 0;

    Ipp32u quant = CurrDC->DoubleQuant>>1;

    STATISTICS_START_TIME(m_timeStatistics->decoding_Intra_StartTime);

    ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                                     &pContext->m_bitstream.bitOffset,
                                     &DCCOEF,
                                     pContext->m_picLayerHeader->m_pCurrLumaDCDiff);
    VM_ASSERT(ret == ippStsNoErr);

    if(DCCOEF != 0)
    {
        if(DCCOEF == IPPVC_ESCAPE)
        {
           if(quant == 1)
           {
              VC1_GET_BITS(10, DCCOEF);
           }
           else if(quant == 2)
           {
              VC1_GET_BITS(9, DCCOEF);
           }
           else // pContext->m_pCurrMB->MQUANT is > 2
           {
              VC1_GET_BITS(8, DCCOEF);
           }
        }
        else
        {  // DCCOEF is not IPPVC_ESCAPE
           Ipp32s tmp;
           if(quant  == 1)
           {
              VC1_GET_BITS(2, tmp);
               DCCOEF = DCCOEF*4 + tmp - 3;
           }
           else if(quant == 2)
           {
              VC1_GET_BITS(1, tmp);
              DCCOEF = DCCOEF*2 + tmp - 1;
           }
        }

        VC1_GET_BITS(1, DCSIGN);
        //if (DCSIGN == 1)
        //    DCCOEF = -DCCOEF;
        DCCOEF = (1 - (DCSIGN<<1))* DCCOEF;
    }

    CurrBlk->DC = (Ipp16s)DCCOEF;
    if(!bias)
    {
        Ipp32s DCStepSize = pContext->CurrDC->DCStepSize;
        pBlock->blkType =  DCPredictionTable[ACPRED](CurrBlk, DCPred, blk_num, m_pBlock,
                                            (Ipp16s)((1024 +(DCStepSize>>1))/DCStepSize),
                                            pContext->m_picLayerHeader->PTYPE);
    }
    else
    pBlock->blkType = DCPredictionTable[ACPRED](CurrBlk, DCPred, blk_num,
                        m_pBlock,0,pContext->m_picLayerHeader->PTYPE);
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                        VM_STRING("DC diff = %d\n"),DCCOEF);
#endif
   if(pContext->m_pCurrMB->m_cbpBits & (1<<(5-blk_num)))
    {
        const Ipp8u* curr_scan = pContext->m_pSingleMB->ZigzagTable[VC1_BlockTable[pBlock->blkType]];
        if(curr_scan==NULL)
            return VC1_FAIL;

        DecodeBlockACIntra_VC1(&pContext->m_bitstream,
                    m_pBlock, curr_scan,
                   pContext->m_picLayerHeader->m_pCurrIntraACDecSet,
                   &pContext->m_pSingleMB->EscInfo);
    }

    for(i = 1; i < 8; i++)

    {
        CurrBlk->ACLEFT[i] = m_pBlock[i*16];
        CurrBlk->ACTOP[i]  = m_pBlock[i];
    }

   STATISTICS_END_TIME(m_timeStatistics->decoding_Intra_StartTime,
                        m_timeStatistics->decoding_Intra_EndTime,
                        m_timeStatistics->decoding_Intra_TotalTime);


#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
        VM_STRING("DC = %d\n"),pContext->CurrDC->DCBlkPred[blk_num].DC);
    //NEED!
                VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                                                "Block %d\n", blk_num);
                for(Ipp32u k = 0; k<8; k++)
                {
                    for (Ipp32u t = 0; t<8; t++)
                    {
                    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                                            "%d  ", m_pBlock[k*16 + t]);
                    }
                    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS, "\n");
                }
#endif
    return VC1_OK;
}

VC1Status BLKLayer_Intra_Chroma(VC1Context* pContext, Ipp32s blk_num, Ipp32u bias, Ipp32u ACPRED)
{
    Ipp16s*   m_pBlock  = pContext->m_pBlock + VC1_BlkStart[blk_num];
    VC1Block* pBlock    = &pContext->m_pCurrMB->m_pBlocks[blk_num];
    VC1DCMBParam*  CurrDC = pContext->CurrDC;
    VC1DCBlkParam* CurrBlk = &CurrDC->DCBlkPred[blk_num];

    VC1DCPredictors* DCPred = &pContext->DCPred;

    IppStatus ret;
    Ipp32s DCCOEF;
    Ipp32s DCSIGN;
    Ipp32u i = 0;

    Ipp32u quant =  CurrDC->DoubleQuant>>1;

    STATISTICS_START_TIME(m_timeStatistics->decoding_Intra_StartTime);

    ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                                     &pContext->m_bitstream.bitOffset,
                                     &DCCOEF,
                                     pContext->m_picLayerHeader->m_pCurrChromaDCDiff);
    VM_ASSERT(ret == ippStsNoErr);

    if(DCCOEF != 0)
    {
        if(DCCOEF == IPPVC_ESCAPE)
        {
           if(quant == 1)
           {
              VC1_GET_BITS(10, DCCOEF);
           }
           else if(quant == 2)
           {
              VC1_GET_BITS(9, DCCOEF);
           }
           else // pContext->m_pCurrMB->MQUANT is > 2
           {
              VC1_GET_BITS(8, DCCOEF);
           }
        }
        else
        {  // DCCOEF is not IPPVC_ESCAPE
           Ipp32s tmp;
           if(quant == 1)
           {
              VC1_GET_BITS(2, tmp);
              DCCOEF = DCCOEF*4 + tmp - 3;
           }
           else if(quant == 2)
           {
              VC1_GET_BITS(1, tmp);
              DCCOEF = DCCOEF*2 + tmp - 1;
           }
        }
        VC1_GET_BITS(1, DCSIGN);
        //if (DCSIGN == 1)
        //    DCCOEF = -DCCOEF;
        DCCOEF = (1 - (DCSIGN<<1))* DCCOEF;
    }

    CurrBlk->DC = (Ipp16s)DCCOEF;
    if(!bias)
    {
        Ipp32s DCStepSize = pContext->CurrDC->DCStepSize;
        pBlock->blkType = DCPredictionTable[ACPRED](CurrBlk, DCPred, blk_num,
                        m_pBlock,(Ipp16s)((1024 +(DCStepSize>>1))/DCStepSize),
                        pContext->m_picLayerHeader->PTYPE);
    }
    else
    pBlock->blkType = DCPredictionTable[ACPRED](CurrBlk, DCPred, blk_num, m_pBlock,0,
                        pContext->m_picLayerHeader->PTYPE);
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                        VM_STRING("DC diff = %d\n"),DCCOEF);
#endif

    if(pContext->m_pCurrMB->m_cbpBits & (1<<(5-blk_num)))
    {
        const Ipp8u* curr_scan = pContext->m_pSingleMB->ZigzagTable[VC1_BlockTable[pBlock->blkType]];
        if(curr_scan==NULL)
            return VC1_FAIL;

        DecodeBlockACIntra_VC1(&pContext->m_bitstream,
                     m_pBlock, curr_scan,
                     pContext->m_picLayerHeader->m_pCurrInterACDecSet,
                     &pContext->m_pSingleMB->EscInfo);
   }

    for(i = 1; i < 8; i++)

    {
        CurrBlk->ACLEFT[i] = m_pBlock[i*8];
        CurrBlk->ACTOP[i]  = m_pBlock[i];
    }

STATISTICS_END_TIME(m_timeStatistics->decoding_Intra_StartTime,
                        m_timeStatistics->decoding_Intra_EndTime,
                        m_timeStatistics->decoding_Intra_TotalTime);
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
            VM_STRING("DC = %d\n"),pContext->CurrDC->DCBlkPred[blk_num].DC);
//NEED!
                VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                                                "Block %d\n", blk_num);
                for(Ipp32u k = 0; k<8; k++)
                {
                    for (Ipp32u t = 0; t<8; t++)
                    {
                    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                                                "%d  ", m_pBlock[k*8 + t]);
                    }
                    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS, "\n");
                }
#endif
    return VC1_OK;
}

VC1Status BLKLayer_Inter_Luma(VC1Context* pContext, Ipp32s blk_num)
{
    Ipp16s*   m_pBlock  = pContext->m_pBlock + VC1_BlkStart[blk_num];
    VC1Block* pBlock    = &pContext->m_pCurrMB->m_pBlocks[blk_num];
    const Ipp8u* curr_scan = NULL;
    Ipp8u numCoef = 0;

    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader * picHeader = pContext->m_picLayerHeader;

    STATISTICS_START_TIME(m_timeStatistics->decoding_Inter_StartTime);
    if(pContext->m_pCurrMB->m_cbpBits & (1<<(5-blk_num)))
    {
        switch (pBlock->blkType)
        {
        case VC1_BLK_INTER8X8:
            {
#ifdef VC1_DEBUG_ON
                VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_COEFFS,
                                                                            "Inter\n");
#endif
                curr_scan = sMB->ZigzagTable[VC1_BlockTable[pBlock->blkType]];
                if(curr_scan==NULL)
                    return VC1_FAIL;