umc_vc1_enc_common.cpp

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

        predC  = (!predC)? res: predC;
        res->x = median3(predA->x, predB->x, predC->x);
        res->y = median3(predA->y, predB->y, predC->y);
    }
    else if (predC)
    {
        res->x = predC->x;
        res->y = predC->y;
    }
}
Ipp16s VC1abs(Ipp16s value)
{
  return value*(2*(value>>15)+1);
}
//void Copy8x8_16s(Ipp16s*  pSrc, Ipp32u   srcStep, Ipp16s*  pDst, Ipp32u   dstStep)
//{
//   int i,j;
//    for (i=0;i<8;i++)
//    {
//        for (j=0;j<8;j++)
//        {
//            pDst[j] = pSrc[j];
//        }
//        pDst = (Ipp16s*)((Ipp8u*)pDst + dstStep);
//        pSrc = (Ipp16s*)((Ipp8u*)pSrc + srcStep);
//    }
//}
//void Copy16x16_16s(Ipp16s*  pSrc, Ipp32u   srcStep, Ipp16s*  pDst, Ipp32u   dstStep)
//{
//   int i,j;
//    for (i=0;i<16;i++)
//    {
//        for (j=0;j<16;j++)
//        {
//            pDst[j] = pSrc[j];
//        }
//        pDst = (Ipp16s*)((Ipp8u*)pDst + dstStep);
//        pSrc = (Ipp16s*)((Ipp8u*)pSrc + srcStep);
//    }
//}

void ScalePredict(sCoordinate * MV, Ipp32s x,Ipp32s y,sCoordinate MVPredMin, sCoordinate MVPredMax)
{
    x += MV->x;
    y += MV->y;

    if (x < MVPredMin.x)
    {
        MV->x -= (x- MVPredMin.x);
    }
    else if (x > MVPredMax.x)
    {
        MV-> x -= (x-MVPredMax.x);
    }

    if (y < MVPredMin.y)
    {
        MV->y -= (y - MVPredMin.y);
    }
    else if (y > MVPredMax.y)
    {
        MV->y -= (y - MVPredMax.y);
    }
}
Ipp8u HybridPrediction(     sCoordinate * mvPred,
                      const sCoordinate * MV,
                      const sCoordinate * mvA,
                      const sCoordinate * mvC)
{
    Ipp8u hybrid = 0;

    if (mvA && mvC)
    {
        Ipp32u sumA = VC1abs(mvA->x - mvPred->x) + VC1abs(mvA->y - mvPred->y);
        Ipp32u sumC = VC1abs(mvC->x - mvPred->x) + VC1abs(mvC->y - mvPred->y);

        if (sumA > 32 || sumC>32)
        {
            if (VC1abs(mvA->x - MV->x) + VC1abs(mvA->y - MV->y)<
                VC1abs(mvC->x - MV->x) + VC1abs(mvC->y - MV->y))
            {
                hybrid = 2;
                mvPred->x = mvA->x;
                mvPred->y = mvA->y;

            }
            else
            {

                hybrid = 1;
                mvPred->x = mvC->x;
                mvPred->y = mvC->y;
            }
        }
    }
    return hybrid;
}
//#define _A(x) (((x)<0)?-(x):(x))
//Ipp32s FullSearch(const Ipp8u* pSrc, Ipp32u srcStep, const Ipp8u* pPred, Ipp32u predStep, sCoordinate Min, sCoordinate Max,sCoordinate * MV)
//{
//    Ipp32s x, y;
//    Ipp32s MVx=0, MVy=0;
//    Ipp32s sum  = 0x7FFFFFFF;
//    Ipp32s temp = 0;
//    Ipp32s yStep=1, xStep=1;
//    const Ipp8u* prediction = pPred;
//
//
//
//    for (y = Min.y; y <Max.y ; y+=yStep )
//    {
//        pPred = prediction + y*(Ipp32s)predStep;
//        for (x = Min.x; x < Max.x; x+=xStep )
//        {
//            ippiSAD16x16_8u32s (pSrc, srcStep, pPred+x, predStep, &temp, 0);
//            temp += (VC1abs(x)+VC1abs(y))*16;
//            if (temp < sum)
//            {
//                sum = temp;
//                MVx = x;
//                MVy = y;
//
//            }
//        }
//
//    }
//    MV->x = MVx;
//    MV->y = MVy;
//    return sum;
//}
//Ipp32s SumBlockDiffBPred16x16(const Ipp8u* pSrc, Ipp32u srcStep,const Ipp8u* pPred1, Ipp32u predStep1,
//                                                                const Ipp8u* pPred2, Ipp32u predStep2)
//{
//    Ipp32s x, y;
//    Ipp32s sum = 0;
//    for(y = 0; y <16; y++)
//    {
//        for (x=0; x<16; x++)
//        {
//            sum += VC1abs(pSrc[x]-((pPred1[x]+pPred2[x])>>2));
//        }
//        pPred1 += predStep1;
//        pPred2 += predStep2;
//        pSrc   += srcStep;
//
//    }
//
//    return sum;
//
//}
//Ipp32s SumBlockDiff16x16(const Ipp8u* pSrc1, Ipp32u srcStep1,const Ipp8u* pSrc2, Ipp32u srcStep2)
//{
//    Ipp32s x, y;
//    Ipp32s sum = 0;
//    for(y = 0; y <16; y++)
//    {
//        for (x=0; x<16; x++)
//        {
//            sum += VC1abs(pSrc1[x]-pSrc1[x]);
//        }
//        pSrc1+=srcStep1;
//        pSrc2+=srcStep2;
//    }
//    return sum;
//
//}
//void GetBlockType(Ipp16s* pBlock, Ipp32s step, Ipp8u Quant, eTransformType& type)
//{
//    int i,j;
//    Ipp32s s[4]={0};
//    bool vEdge[2]={0};
//    bool hEdge[3]={0};
//
//    for (i=0;i<8;i++)
//    {
//        for(j=0;j<8;j++)
//        {
//            s[((i>>2)<<1)+(j>>2)] += pBlock[j];
//        }
//        pBlock = (Ipp16s*)((Ipp8u*)pBlock + step);
//    }
//    s[0] = s[0]>>3;
//    s[1] = s[1]>>3;
//    s[2] = s[2]>>3;
//    s[3] = s[3]>>3;
//
//    vEdge[0] = ((VC1abs(s[0]-s[1]))>= Quant);
//    vEdge[1] = ((VC1abs(s[2]-s[3]))>= Quant);
//    hEdge[0] = ((VC1abs(s[0]-s[2]))>= Quant);
//    hEdge[1] = ((VC1abs(s[1]-s[3]))>= Quant);
//
//    if (vEdge[0]||vEdge[1])
//    {
//            type = (hEdge[0]||hEdge[1])? VC1_ENC_4x4_TRANSFORM:VC1_ENC_4x8_TRANSFORM;
//    }
//    else
//    {
//            type = (hEdge[0]||hEdge[1])? VC1_ENC_8x4_TRANSFORM:VC1_ENC_8x8_TRANSFORM;
//    }
//
//    return;
//}
//bool GetMBTSType(Ipp16s** ppBlock, Ipp32u* pStep, Ipp8u Quant /*doubleQuant*/, eTransformType* pTypes /*BlockTSTypes*/)
//{
//    Ipp8u num [4]           = {0};
//    Ipp8u max_num           = 0;
//    eTransformType max_type = VC1_ENC_8x8_TRANSFORM;
//    Ipp32s blk;
//
//    for (blk = 0; blk<6; blk++)
//    {
//        GetBlockType(ppBlock[blk],
//                     pStep[blk],
//                     Quant,
//                     (pTypes[blk]));
//        assert(pTypes[blk]<4);
//        num[pTypes[blk]]++;
//        if (num[pTypes[blk]]>max_num)
//        {
//            max_num         = num[pTypes[blk]];
//            max_type        = pTypes[blk];
//        }
//    } // for
//    if (max_num > 4)
//    {
//        for (blk = 0; blk<6; blk++)
//        {
//             pTypes[blk] = max_type;
//        }
//        return true; //bMBTSType - one type for all blocks in macroblock
//    }
//    return false;
//}
//#undef _A
//Ipp32s SumBlock16x16(const Ipp8u* pSrc, Ipp32u srcStep)
//{
//    Ipp32s x, y;
//    Ipp32s sum = 0;
//    for(y = 0; y <16; y++)
//    {
//        for (x=0; x<16; x++)
//        {
//            sum += pSrc[x];
//        }
//        pSrc += srcStep;
//    }
//    return sum;
//}


void  GetMVDirectHalf  (Ipp16s x, Ipp16s y, Ipp32s scaleFactor, sCoordinate * mvF, sCoordinate *mvB)
{
     mvB->x = ((x*(scaleFactor-256)+255)>>9)<<1;
     mvB->y = ((y*(scaleFactor-256)+255)>>9)<<1;
     mvF->x = ((x*scaleFactor+255)>>9)<<1;
     mvF->y = ((y*scaleFactor+255)>>9)<<1;

}
void  GetMVDirectQuarter(Ipp16s x, Ipp16s y, Ipp32s scaleFactor, sCoordinate * mvF, sCoordinate *mvB)
{
     mvB->x = (x*(scaleFactor-256)+128)>>8;
     mvB->y = (y*(scaleFactor-256)+128)>>8;
     mvF->x = (x*scaleFactor+128)>>8;
     mvF->y = (y*scaleFactor+128)>>8;
}
void GetChromaMV (sCoordinate LumaMV, sCoordinate * pChroma)
{
    static Ipp16s round[4]= {0,0,0,1};

    pChroma->x = (LumaMV.x + round[LumaMV.x&0x03])>>1;
    pChroma->y = (LumaMV.y + round[LumaMV.y&0x03])>>1;
}


void GetChromaMVFast(sCoordinate LumaMV, sCoordinate * pChroma)
{
    static Ipp16s round [4]= {0,0,0,1};
    static Ipp16s round1[2][2] = {
        {0, -1}, //sign = 0;
        {0,  1}  //sign = 1
    };

    pChroma->x = (LumaMV.x + round[LumaMV.x&0x03])>>1;
    pChroma->y = (LumaMV.y + round[LumaMV.y&0x03])>>1;
    pChroma->x += round1[pChroma->x < 0][pChroma->x & 1];
    pChroma->y += round1[pChroma->y < 0][pChroma->y & 1];
}
void GetIntQuarterMV(sCoordinate MV,sCoordinate *pMVInt, sCoordinate *pMVIntQuarter)
{
    pMVInt->x = MV.x>>2;
    pMVInt->y = MV.y>>2;
    pMVIntQuarter->x = MV.x - (pMVInt->x<<2);
    pMVIntQuarter->y = MV.y - (pMVInt->y<<2);
}
//void GetQMV(sCoordinate *pMV,sCoordinate MVInt, sCoordinate MVIntQuarter)
//{
//    pMV->x = (MVInt.x<<2) + MVIntQuarter.x;
//    pMV->y = (MVInt.y<<2) + MVIntQuarter.y;
//}

////////////////////////////////////////////////////////////////
//--------Interpolation----------------------------------------

}

#endif // defined (UMC_ENABLE_VC1_VIDEO_ENCODER)