umc_vc1_deblock_adv.cpp

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) 2004-2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) decoder, deblocking
//
*/
#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_VIDEO_DECODER)

#include "umc_vc1_dec_seq.h"
#include "umc_vc1_common_defs.h"
#include "umc_vc1_dec_debug.h"

static const Ipp8u deblock_table[16] = {IPPVC_EDGE_ALL ,
                                      IPPVC_EDGE_QUARTER_1 +  IPPVC_EDGE_HALF_2,
                                      IPPVC_EDGE_QUARTER_2 +  IPPVC_EDGE_HALF_2,
                                      IPPVC_EDGE_HALF_2,

                                      IPPVC_EDGE_HALF_1 + IPPVC_EDGE_QUARTER_3,
                                      IPPVC_EDGE_QUARTER_1 +  IPPVC_EDGE_QUARTER_3,
                                      IPPVC_EDGE_QUARTER_2 + IPPVC_EDGE_QUARTER_3,
                                      IPPVC_EDGE_QUARTER_3,

                                      IPPVC_EDGE_HALF_1+ IPPVC_EDGE_QUARTER_4,
                                      IPPVC_EDGE_QUARTER_1+ IPPVC_EDGE_QUARTER_4,
                                      IPPVC_EDGE_QUARTER_2+ IPPVC_EDGE_QUARTER_4,
                                      IPPVC_EDGE_QUARTER_4,

                                      IPPVC_EDGE_HALF_1,
                                      IPPVC_EDGE_QUARTER_1,
                                      IPPVC_EDGE_QUARTER_2,
                                      0};

static const Ipp8u deblock_table_2[4] = {IPPVC_EDGE_ALL,
                                         IPPVC_EDGE_HALF_1,
                                         IPPVC_EDGE_HALF_2,
                                         0};


static void HorizontalDeblockingLumaP(Ipp8u* pUUpBlock,
                                      Ipp32u Pquant,
                                      Ipp32s Pitch,
                                      const VC1MB* _pMB,
                                      const VC1MB* _pnMB)
{
    Ipp32s SBP = 0;
    Ipp32s count = 0;
    Ipp32s flag_ext = 0;
    Ipp32s flag_int = 0;

    Ipp32s Edge_ext = 3; /* Mark bottom left and right subblocks */
    Ipp32s Edge_int = 0;

    Ipp32s SBP_cur_count  = 0;
    Ipp32s SBP_next_count = 2;



    if (_pMB != _pnMB)
    {
        SBP_next_count = 0;
        SBP_cur_count  = 2;
    }

    for(count = 0; count<2;count++)
    {
        Edge_ext = 3;
        Edge_int = 0;
        SBP = _pMB->m_pBlocks[SBP_cur_count].SBlkPattern;

        if ((_pMB->m_pBlocks[SBP_cur_count].blkType < VC1_BLK_INTRA_TOP)
            &&(_pnMB->m_pBlocks[SBP_next_count].blkType < VC1_BLK_INTRA_TOP)
            &&(_pMB->m_pBlocks[SBP_cur_count].mv[0][0] == _pnMB->m_pBlocks[SBP_next_count].mv[0][0])
            &&(_pMB->m_pBlocks[SBP_cur_count].mv[0][1] == _pnMB->m_pBlocks[SBP_next_count].mv[0][1])
            &&(_pMB->m_pBlocks[SBP_cur_count].mv_s_polarity[0] == _pnMB->m_pBlocks[SBP_next_count].mv_s_polarity[0])
            )
        {
            Ipp32s DSBP = _pnMB->m_pBlocks[SBP_next_count].SBlkPattern;
            Ipp32s TSBP = SBP;
            Edge_ext = TSBP | (DSBP>>2);
        }
        flag_ext += ((Edge_ext&3) << (count*2));
        if ((_pMB->m_pBlocks[SBP_cur_count].blkType==VC1_BLK_INTER8X4) || (_pMB->m_pBlocks[SBP_cur_count].blkType==VC1_BLK_INTER4X4))
        {
            if ((SBP & 8) || (SBP & 2))
                Edge_int |= 2;
            if ((SBP & 4) || (SBP & 1))
                Edge_int |= 1;
        }
        flag_int += (Edge_int << (count*2));
        ++SBP_next_count;
        ++SBP_cur_count;
    }
    _own_FilterDeblockingLuma_HorEdge_VC1(pUUpBlock + 8*Pitch, Pquant,Pitch, deblock_table[flag_ext]);
    _own_FilterDeblockingLuma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,Pitch, deblock_table[flag_int]);
}



static void HorizontalDeblockingLumaPNoBotBlock(Ipp8u* pUUpBlock,
                                                Ipp32u Pquant,
                                                Ipp32s Pitch,
                                                const VC1MB* _pMB)
{
    Ipp32s count = 0;
    Ipp32s flag = 0;
    Ipp32s Edge = 0;
    Ipp32s SBP = 0;
    for(count = 0; count<2;count++)
    {
        Edge = 0;
        SBP = _pMB->m_pBlocks[count+2].SBlkPattern;
        if ((_pMB->m_pBlocks[count+2].blkType==VC1_BLK_INTER8X4) || (_pMB->m_pBlocks[count+2].blkType==VC1_BLK_INTER4X4))
        {
            if ((SBP & 8) || (SBP & 2))
                Edge |= 2;
            if ((SBP & 4) || (SBP & 1))
                Edge |= 1;
        }
        flag += (Edge << (count*2));
    }
    _own_FilterDeblockingLuma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,Pitch, deblock_table[flag]);
}



static void HorizontalDeblockingChromaP(Ipp8u* pUUpBlock,
                                        Ipp32u Pquant,
                                        Ipp32s Pitch,
                                        VC1Block* _pBlk,
                                        VC1Block* _pnBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s Edge_int = 0;
    Ipp32s Edge_ext = 3;

    if ((_pBlk->blkType < VC1_BLK_INTRA_TOP)
        &&(_pnBlk->blkType < VC1_BLK_INTRA_TOP)
        &&(_pBlk->mv[0][0] == _pnBlk->mv[0][0])
        &&(_pBlk->mv[0][1] == _pnBlk->mv[0][1])
        &&(_pBlk->mv_s_polarity[0] == _pnBlk->mv_s_polarity[0])
        )
    {
        Ipp32s DSBP = _pnBlk->SBlkPattern;
        Ipp32s TSBP = SBP;
        Edge_ext = TSBP | (DSBP>>2);
    }

    if ((_pBlk->blkType==VC1_BLK_INTER8X4) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 2))
        {
            Edge_int |= 2;
        }
        if ((SBP & 4) || (SBP & 1))
        {
            Edge_int |= 1;
        }
    }
    _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 8*Pitch, Pquant,Pitch, deblock_table_2[Edge_ext&3]);
    _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,Pitch, deblock_table_2[Edge_int]);

}

static void HorizontalDeblockingChromaPNoBotBlock(Ipp8u* pUUpBlock,
                                                  Ipp32u Pquant,
                                                  Ipp32s Pitch,
                                                  const  VC1Block* _pBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s Edge_int = 0;


    if ((_pBlk->blkType==VC1_BLK_INTER8X4) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 2))
        {
            Edge_int |= 2;
        }
        if ((SBP & 4) || (SBP & 1))
        {
            Edge_int |= 1;
        }
    }
    _own_FilterDeblockingChroma_HorEdge_VC1(pUUpBlock + 4*Pitch, Pquant,Pitch, deblock_table_2[Edge_int]);
}

static void VerticalDeblockingLumaP(Ipp8u* pUUpLBlock,
                                    Ipp32u Pquant,
                                    Ipp32s Pitch,
                                    const VC1MB* _pMB,
                                    const VC1MB* _pnMB)
{
    Ipp32s SBP = 0;

    Ipp32s count = 0;
    Ipp32s flag_ext = 0;
    Ipp32s flag_int = 0;

    Ipp32s Edge_ext = 3; /* Mark bottom left and right subblocks */
    Ipp32s Edge_int = 0;

    Ipp32s SBP_cur_count  = 0;
    Ipp32s SBP_next_count = 1;


    if (_pMB != _pnMB)
    {
        SBP_next_count = 0;
        SBP_cur_count  = 1;
    }

    for(count = 0; count<2;count++)
    {
        Edge_ext = 3;
        Edge_int = 0;
        SBP = _pMB->m_pBlocks[SBP_cur_count].SBlkPattern;

        if ((_pMB->m_pBlocks[SBP_cur_count].blkType < VC1_BLK_INTRA_TOP)
            &&(_pnMB->m_pBlocks[SBP_next_count].blkType < VC1_BLK_INTRA_TOP)
            &&(_pMB->m_pBlocks[SBP_cur_count].mv[0][0] == _pnMB->m_pBlocks[SBP_next_count].mv[0][0])
            &&(_pMB->m_pBlocks[SBP_cur_count].mv[0][1] == _pnMB->m_pBlocks[SBP_next_count].mv[0][1])
            &&(_pMB->m_pBlocks[SBP_cur_count].mv_s_polarity[0] == _pnMB->m_pBlocks[SBP_next_count].mv_s_polarity[0])
            )
        {
            Ipp32s DSBP = _pnMB->m_pBlocks[SBP_next_count].SBlkPattern;
            Ipp32s TSBP = SBP;
            Edge_ext = TSBP | (DSBP>>1);
            Edge_ext = ( ((Edge_ext&4)>>1) + (Edge_ext&1));
        }
        flag_ext += (Edge_ext << (count*2));
        if ((_pMB->m_pBlocks[SBP_cur_count].blkType==VC1_BLK_INTER4X8) || (_pMB->m_pBlocks[SBP_cur_count].blkType==VC1_BLK_INTER4X4))
        {
            if ((SBP & 8) || (SBP & 4))
                Edge_int |= 2;
            if ((SBP & 2) || (SBP & 1))
                Edge_int |= 1;
        }
        flag_int += (Edge_int << (count*2));
        SBP_next_count +=2;
        SBP_cur_count +=2;
    }
    _own_FilterDeblockingLuma_VerEdge_VC1(pUUpLBlock + 8, Pquant,Pitch, deblock_table[flag_ext]);
    _own_FilterDeblockingLuma_VerEdge_VC1(pUUpLBlock + 4, Pquant,Pitch, deblock_table[flag_int]);

}
static void VerticalDeblockingLumaPNoLeftBlock(Ipp8u* pUUpLBlock,
                                               Ipp32u Pquant,
                                               Ipp32s Pitch,
                                               const VC1MB* _pMB)
{
    Ipp32s count = 0;
    Ipp32s flag = 0;
    Ipp32s Edge = 0;
    Ipp32s SBP = 0;
    Ipp32s SBP_counter = 1;


   for(count = 0; count<2;count++)
    {
        Edge = 0;
        SBP = _pMB->m_pBlocks[SBP_counter].SBlkPattern;
        if ((_pMB->m_pBlocks[SBP_counter].blkType==VC1_BLK_INTER4X8) ||
            (_pMB->m_pBlocks[SBP_counter].blkType==VC1_BLK_INTER4X4))
        {
            if ((SBP & 8) || (SBP & 4))
                Edge |= 2;
            if ((SBP & 2) || (SBP & 1))
                Edge |= 1;
        }
        flag += (Edge << (count*2));
        SBP_counter += 2;
    }
    _own_FilterDeblockingLuma_VerEdge_VC1(pUUpLBlock + 4, Pquant,Pitch, deblock_table[flag]);

}



static void VerticalDeblockingChromaP(Ipp8u* pUUpLBlock,
                                      Ipp32u Pquant,
                                      Ipp32s Pitch,
                                      VC1Block* _pBlk,
                                      VC1Block* _pnBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s Edge_int = 0;
    Ipp32s Edge_ext = 3;

        if ((_pBlk->blkType < VC1_BLK_INTRA_TOP)
        &&(_pnBlk->blkType < VC1_BLK_INTRA_TOP)
        &&(_pBlk->mv[0][0] == _pnBlk->mv[0][0])
        &&(_pBlk->mv[0][1] == _pnBlk->mv[0][1])
        &&(_pBlk->mv_s_polarity[0] == _pnBlk->mv_s_polarity[0])
        )
    {
            Ipp32s DSBP = _pnBlk->SBlkPattern;
            Ipp32s TSBP = SBP;
            Edge_ext = TSBP | (DSBP>>1);
            Edge_ext = ( ((Edge_ext&4)>>1) + (Edge_ext&1));
    }

    if ((_pBlk->blkType==VC1_BLK_INTER4X8) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 4))
        {
            Edge_int |= 2;
        }
        if ((SBP & 2) || (SBP & 1))
        {
            Edge_int |= 1;
        }
    }
    _own_FilterDeblockingChroma_VerEdge_VC1(pUUpLBlock + 8, Pquant,Pitch, deblock_table_2[Edge_ext]);
    _own_FilterDeblockingChroma_VerEdge_VC1(pUUpLBlock + 4, Pquant,Pitch, deblock_table_2[Edge_int]);
}
static void VerticalDeblockingChromaPNoLeftBlock(Ipp8u* pUUpLBlock,
                                                 Ipp32u Pquant,
                                                 Ipp32s Pitch,
                                                 VC1Block* _pBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s Edge_int = 0;

    if ((_pBlk->blkType==VC1_BLK_INTER4X8) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 4))
        {
            Edge_int |= 2;
        }
        if ((SBP & 2) || (SBP & 1))
        {
            Edge_int |= 1;
        }
    }
    _own_FilterDeblockingChroma_VerEdge_VC1(pUUpLBlock + 4, Pquant,Pitch, deblock_table_2[Edge_int]);
}



static void HorizontalDeblockingBlkB_No_DBlock(Ipp8u* pUUpBlock,
                                               Ipp32u Pquant,
                                               Ipp32s Pitch,
                                               VC1Block* _pBlk)
{
    Ipp32s SBP = _pBlk->SBlkPattern;
    Ipp32s flag_ver = IPPVC_EDGE_ALL;
    if ((_pBlk->blkType==VC1_BLK_INTER8X4) || (_pBlk->blkType==VC1_BLK_INTER4X4))
    {
        if ((SBP & 8) || (SBP & 2))
        {
            flag_ver ^= IPPVC_EDGE_HALF_1;
        }
        if ((SBP & 4) || (SBP & 1))
        {
            flag_ver ^= IPPVC_EDGE_HALF_2;
        }