umc_vc1_dec_mb_interpolate_com.cpp

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

                pSrc += srcStep;
                pDst += dstStep;
#ifdef VC1_DEBUG_ON
//                VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n") );
#endif
            }
    break;

    case 3:

            for(j = 0; j < 8; j++)
            {
                for(i = 0; i < 16; i++)
                {
                    //pPixels[I] = IC_SCAN(pSource[I], IC_matrix);
                    pDst[i] = pSrc[i];
#ifdef VC1_DEBUG_ON
//                    VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  "), pDst[i] );
#endif

                }
#ifdef VC1_DEBUG_ON
//                VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n") );
#endif
                pSrc += srcStep;
                pDst += dstStep;
            }
        break;
    default:
        break;
    }
    return ret;
}

static IppStatus ippiInterpolate8x8QPBicubicIC_VC1_8u_C1R (const Ipp8u* pSrc,
                                                      Ipp32s srcStep,
                                                      Ipp8u *pDst,
                                                      Ipp32s dstStep,
                                                      Ipp32s dx,
                                                      Ipp32s dy,
                                                      Ipp32s roundControl)
{
    IppStatus ret = ippStsNoErr;

    unsigned choose_int = ( (1==(0==(dx))) |(((1==(0 == (dy))) << 1)));
    short TempBlock[(17 + 3) * 17];
    int i, j;
    int PBPL          = 17 + 3;
    int R             = roundControl;

    short         *pDst16 = TempBlock + 1;
    short         *pSource16 = TempBlock + 1;
    int Pixel;
    int Fy0, Fy1, Fy2, Fy3;
    int Fx0, Fx1, Fx2, Fx3;
    const int (*FP) = BicubicFilterParams[(dy) - 1];
    int Abs, Shift;
    Fy0          = FP[0];
    Fy1          = FP[1];
    Fy2          = FP[2];
    Fy3          = FP[3];

    FP = BicubicFilterParams[dx - 1];
    Fx0          = FP[0];
    Fx1          = FP[1];
    Fx2          = FP[2];
    Fx3          = FP[3];

    switch(choose_int)
    {
    case 0:

        Shift           = BicubicVertFilterShift[(dx)][(dy) - 1];
        Abs             = 1 << (Shift - 1);
#ifdef VC1_DEBUG_ON
//        VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("PelBicubicDiag\n") );
#endif
        FP = BicubicFilterParams[dx - 1];
        Fx0          = (int)FP[0];
        Fx1          = (int)FP[1];
        Fx2          = (int)FP[2];
        Fx3          = (int)FP[3];

#ifdef VC1_DEBUG_ON
//        VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("Source\n" ));
//        for(j = -1; j < 8+2; j++)
//        {
//            for(i = -1; i < 8+2; i++)
//            {
//                VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d "), pSrc[i  + j*srcStep]);
//            }
//            VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n"));
//        }
//        VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("F(%d, %d, %d, %d) abs=%d r=%d shift=%d\n") ,Fy0,Fy1,Fy2,Fy3,Abs,R,Shift);
//        VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("after interpolate\n") );
//        VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n"));
#endif

        /* vertical filter */

            for(j = 0; j < 8; j++)
            {
                for(i = -1; i < 3; i++)
                {
                    Pixel = ((pSrc[i - srcStep] * Fy0 +
                        pSrc[i]             * Fy1 +
                        pSrc[i + srcStep]  * Fy2 +
                        pSrc[i + 2*srcStep]* Fy3 +
                        Abs - 1 + R) >> Shift);

                    pDst16[i] = (short)Pixel;

                }
                for(;i < 8+2; i++)
                {
                    Pixel = ((pSrc[i - srcStep]  * Fy0 +
                        pSrc[i]              * Fy1 +
                        pSrc[i  + srcStep]  * Fy2 +
                        pSrc[i  + 2*srcStep]* Fy3 +
                        Abs - 1 + R) >> Shift);
                    pDst16[i] = (short)Pixel;
                    pDst[i-3] = CLIP((pDst16[i-4] * Fx0 +
                        pDst16[i-3] * Fx1 +
                        pDst16[i-2] * Fx2 +
                        pDst16[i-1] * Fx3 + 64 - R) >> 7);
#ifdef VC1_DEBUG_ON
//                    VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  "), pDst[i-3] );
#endif
                }
                pDst[i-3] = CLIP((pDst16[i-4] * Fx0 +
                    pDst16[i-3] * Fx1 +
                    pDst16[i-2] * Fx2 +
                    pDst16[i-1] * Fx3 + 64 - R) >> 7);
#ifdef VC1_DEBUG_ON
 //               VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  "), pDst[i-3] );
#endif
                pDst   += dstStep;
                pSrc   += srcStep;
                pDst16 += PBPL;
#ifdef VC1_DEBUG_ON
//                VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n") );
#endif
            }
        break;
    case 1:

        Shift           = BicubicVertFilterShift[0][(dy) - 1];
        Abs             = 1 << (Shift - 1);
#ifdef VC1_DEBUG_ON
 //       VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("PelBicubicVert\n") );
#endif


            for(j = 0; j < 8; j++)
            {
                for(i = 0; i < 8; i++)
                {
                    pDst[i] = CLIP((pSrc[i - srcStep]   * Fy0 +
                                    pSrc[i]             * Fy1 +
                                    pSrc[i + srcStep]   * Fy2 +
                                    pSrc[i + 2*srcStep] * Fy3 +
                                    Abs - 1 + R) >> Shift);
                    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("Source\n"));
                    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  \n"), pSrc[i - srcStep] );
                    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  \n"), pSrc[i] );
                    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  \n"), pSrc[i + srcStep] );
                    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  \n"), pSrc[i + 2*srcStep] );

                    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  \n"), pDst[i] );
                }
                pSrc += srcStep;
                pDst += dstStep;
#ifdef VC1_DEBUG_ON
  //              VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n") );
#endif
            }
        break;
    case 2:
        Shift           = BicubicHorizFilterShift[(dx) - 1][0];
        Abs             = 1 << (Shift - 1);
#ifdef VC1_DEBUG_ON
 //       VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("PelBicubicHoriz\n") );
#endif

            for(j = 0; j < 8; j++)
            {
                for(i = 0; i < 8; i++)
                {
                     pDst[i] = CLIP((pSrc[i-1]   * Fx0 +
                        pSrc[i]     * Fx1 +
                        pSrc[i+1]   * Fx2 +
                        pSrc[i + 2] * Fx3 +
                        Abs - R) >> Shift);
#ifdef VC1_DEBUG_ON
  //                  VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  "), pDst[i] );
#endif
                }
                pSrc += srcStep;
                pDst += dstStep;
#ifdef VC1_DEBUG_ON
 //               VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n") );
#endif
            }
        break;
    case 3:

            for(j = 0; j < 8; j++)
            {
                for(i = 0; i < 8; i++)
                {
                    //pPixels[I] = IC_SCAN(pSource[I], IC_matrix);
                    pDst[i] = pSrc[i];
#ifdef VC1_DEBUG_ON
  //                  VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("%d  "), pDst[i] );
#endif

                }
                //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_PRED,VM_STRING("\n") );
                pSrc += srcStep;
                pDst += dstStep;
            }
        break;
    default:
        break;
    }
    return ret;
}


static const ippiBicubicInterpolate ippiBicubicInterpolate_table[] = {
        (ippiBicubicInterpolate)(ippiInterpolate8x8QPBicubicIC_VC1_8u_C1R),
        (ippiBicubicInterpolate)(ippiInterpolate16x8QPBicubicIC_VC1_8u_C1R),
        (ippiBicubicInterpolate)(ippiInterpolate16x16QPBicubicIC_VC1_8u_C1R),
};


IppStatus _own_ippiInterpolateQPBicubicIC_VC1_8u_C1R   (_IppVCInterpolate_8u* inter_struct)
{
    IppStatus ret = ippStsNoErr;
    int pinterp = (inter_struct->roiSize.width >> 4) + (inter_struct->roiSize.height >> 4);
    ret= ippiBicubicInterpolate_table[pinterp](inter_struct->pSrc,
                                               inter_struct->srcStep,
                                               inter_struct->pDst,
                                               inter_struct->dstStep,
                                               inter_struct->dx,
                                               inter_struct->dy,
                                               inter_struct->roundControl);
    return ret;
}
#endif
void DecodeTransformInfo(VC1Context* pContext)
{
    Ipp32u i;
    if(pContext->m_seqLayerHeader->VSTRANSFORM)
    {
        if (pContext->m_picLayerHeader->TTMBF == 0 &&
            (pContext->m_pCurrMB->mbType != VC1_MB_INTRA) )
        {
            GetTTMB(pContext);
        }
        else
        {
            if (!pContext->m_pCurrMB->mbType == VC1_MB_INTRA)
            {
                for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
                {
                    if (!VC1_IS_BLKINTRA(pContext->m_pCurrMB->m_pBlocks[i].blkType))
                        pContext->m_pCurrMB->m_pBlocks[i].blkType = (Ipp8u)pContext->m_picLayerHeader->TTFRM;
                }
            }
            else
                for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
                    pContext->m_pCurrMB->m_pBlocks[i].blkType = VC1_BLK_INTRA;

        }
    }
    //else
    //{
    //    for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
    //        pContext->m_pCurrMB->m_pBlocks[i].blkType = (Ipp8u)pContext->m_picLayerHeader->TTFRM;
    //}
}

VC1Status GetTTMB(VC1Context* pContext)
{
    IppStatus ret;
    VC1MB *pMB = pContext->m_pCurrMB;
    Ipp32s eSBP;
    Ipp8u Count, Limit, FirstBlock = 0;

    while ( (FirstBlock <  VC1_NUM_OF_BLOCKS)             &&
           ((0 == ((1 << (5-FirstBlock)) & pMB->m_cbpBits)) ||
           (pMB->m_pBlocks[FirstBlock].blkType == VC1_BLK_INTRA) )
          )
    {
        FirstBlock++;
    }

    if(FirstBlock == VC1_NUM_OF_BLOCKS)
    {
        return VC1_OK;
    }

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

    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_TT,VM_STRING("TTMB = %d\n"), eSBP);

    Limit = VC1_NUM_OF_BLOCKS;

    if(eSBP < VC1_SBP_8X8_MB)
    {
        Limit = FirstBlock + 1;
    }
    else
    {
        eSBP -= VC1_SBP_8X8_MB;
    }

    //printf("eSBP = %d\n",eSBP);
    //printf("offset = %d\n", pContext->m_bitOffset);

    pContext->m_pSingleMB->m_ubNumFirstCodedBlk = FirstBlock;

    pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = 0;

    switch(eSBP)
    {
        case VC1_SBP_8X8_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_0;
            break;

        case VC1_SBP_8X4_BOTTOM_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_1;
            break;

        case VC1_SBP_8X4_TOP_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_0;
            break;

        case VC1_SBP_8X4_BOTH_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_0|VC1_SBP_1;
            break;

        case VC1_SBP_4X8_RIGHT_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_1;
            break;

        case VC1_SBP_4X8_LEFT_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_0;
            break;

        case VC1_SBP_4X8_BOTH_BLK:
            pContext->m_pSingleMB->m_pSingleBlock[FirstBlock].numCoef = VC1_SBP_0|VC1_SBP_1;
            break;

        case VC1_SBP_4X4_BLK:
            //nothing to do
            break;

        default:
            return VC1_FAIL;
    }

    for(Count = FirstBlock; Count < Limit; Count++)
    {
        if(!(pMB->m_pBlocks[Count].blkType == VC1_BLK_INTRA))
        {
            VM_ASSERT(eSBP<8);
            pMB->m_pBlocks[Count].blkType = VC1_LUT_SET(eSBP,esbp_lut);
        }
    }

    for( ; Count < VC1_NUM_OF_BLOCKS; Count++)
    {
        if(!(pMB->m_pBlocks[Count].blkType == VC1_BLK_INTRA))
        {
            pMB->m_pBlocks[Count].blkType = VC1_BLK_INTER;
        }
    }

    return VC1_OK;
}


void CalculateIntraFlag(VC1Context* pContext)
{
    Ipp8u i;
    pContext->m_pCurrMB->IntraFlag=0;

    for (i = 0; i < VC1_NUM_OF_BLOCKS; i++)
    {
        if(pContext->m_pCurrMB->m_pBlocks[i].blkType & VC1_BLK_INTRA)
        {
            pContext->m_pCurrMB->IntraFlag=(1<<i)|pContext->m_pCurrMB->IntraFlag;
        }
    }
}

#endif //UMC_ENABLE_VC1_VIDEO_DECODER