📄 umc_vc1_enc_common.cpp
字号:
/* /////////////////////////////////////////////////////////////////////////////
//
// 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) 2007 Intel Corporation. All Rights Reserved.
//
//
// VC-1 (VC1) encoder, common declarations
//
*/
#include "umc_defs.h"
#if defined (UMC_ENABLE_VC1_VIDEO_ENCODER)
#include "ippvc.h"
#include "umc_vc1_enc_def.h"
#include "umc_vc1_common_defs.h"
#include "stdio.h"
#include "assert.h"
namespace UMC_VC1_ENCODER
{
static const Ipp16s TableFwdTransform8x8[64] =
{
21845, 21845, 21845, 21845, 21845, 21845, 21845, 21845,
29026, 27212, 16327, 7257, -7257, -16327, -27212, -29026,
28728, 10773, -10773, -28728, -28728, -10773, 10773, 28728,
27212, -7257, -29026, -16327, 16327, 29026, 7257, -27212,
21845, -21845, -21845, 21845, 21845, -21845, -21845, 21845,
16327, -29026, 7257, 27212, -27212, -7257, 29026, -16327,
10773, -28728, 28728, -10773, -10773, 28728, -28728, 10773,
7257, -16327, 27212, -29026, 29026, -27212, 16327, -7257
};
static const Ipp16s TableFwdTransform4x4[16] =
{
15420, 15420, 15420, 15420,
19751, 8978, -8978, -19751,
15420, -15420, -15420, 15420,
8978 , -19751, 19751 , -8978
};
Ipp8u Get_CBPCY(Ipp8u MBPatternCur, Ipp8u CBPCYTop, Ipp8u CBPCYLeft, Ipp8u CBPCYULeft)
{
Ipp8u LT3 = (CBPCYULeft >> VC1_ENC_PAT_POS_Y3) & 0x01;
Ipp8u T2 = (CBPCYTop >> VC1_ENC_PAT_POS_Y2) & 0x01;
Ipp8u T3 = (CBPCYTop >> VC1_ENC_PAT_POS_Y3) & 0x01;
Ipp8u L1 = (CBPCYLeft >> VC1_ENC_PAT_POS_Y1) & 0x01;
Ipp8u L3 = (CBPCYLeft >> VC1_ENC_PAT_POS_Y3) & 0x01;
Ipp8u CBPCY = MBPatternCur;
Ipp8u Y0 = (CBPCY>>VC1_ENC_PAT_POS_Y0)&0x01;
CBPCY ^= ((LT3==T2)? L1:T2) << VC1_ENC_PAT_POS_Y0;
CBPCY ^= ((T2 ==T3)? Y0:T3) << VC1_ENC_PAT_POS_Y1;
CBPCY ^= ((L1 ==Y0)? L3:Y0) << VC1_ENC_PAT_POS_Y2;
CBPCY ^= ((Y0 ==((MBPatternCur>>VC1_ENC_PAT_POS_Y1)&0x01))?
(MBPatternCur>>VC1_ENC_PAT_POS_Y2)&0x01:(MBPatternCur>>VC1_ENC_PAT_POS_Y1)&0x01) << VC1_ENC_PAT_POS_Y3;
return CBPCY;
}
//eDirection GetDCPredDirectionSM(Ipp16s dcA, Ipp16s dcB, Ipp16s dcC)
//{
//
// return ((Ipp32u)((dcA - dcB)*(dcA - dcB))<= (Ipp32u)((dcC - dcB)*(dcC - dcB)))? VC1_ENC_LEFT: VC1_ENC_TOP;
//
//}
//void Diff_1x7_16s(Ipp16s* pSrcDst, Ipp16s step, const Ipp16s* pBlock)
//{
// for(int i=0; i<7 ;i++)
// {
// pBlock = (Ipp16s*)((Ipp8u*)pBlock +step);
// pSrcDst = (Ipp16s*)((Ipp8u*)pSrcDst+step);
// *pSrcDst -= *pBlock;
// }
//
// return;
//}
//void Diff_7x1_16s(Ipp16s* pSrcDst, const Ipp16s* pBlock)
//{
// for(int i=0; i<7 ;i++)
// {
// *(++pSrcDst) -= *(++pBlock);
// }
// return;
//}
Ipp32s SumSqDiff_1x7_16s(Ipp16s* pSrc, Ipp16s step, Ipp16s* pPred)
{
Ipp32s sum=0;
for(int i=0; i<7 ;i++)
{
pPred = (Ipp16s*)((Ipp8u*)pPred+step);
pSrc = (Ipp16s*)((Ipp8u*)pSrc+step);
sum += (pSrc[0]-pPred[0])*(pSrc[0]- pPred[0]) - pSrc[0]*pSrc[0];
}
return sum;
}
Ipp32s SumSqDiff_7x1_16s(Ipp16s* pSrc, Ipp16s* pPred)
{
Ipp32s sum=0;
for(int i=1; i<8 ;i++)
{
sum += (pSrc[i]-pPred[i])*(pSrc[i]- pPred[i]) - pSrc[i]*pSrc[i];
}
return sum;
}
void Diff8x8 (const Ipp16s* pSrc1, Ipp32s src1Step,
const Ipp16s* pSrc2, Ipp32s src2Step,
const Ipp8u* pCoeff,Ipp32s coefStep,
Ipp16s* pDst, Ipp32s dstStep)
{
int i, j;
for (i = 0; i<8; i++)
{
for (j = 0;j<8;j++)
{
pDst[j] = pSrc1[j] - pSrc2[j]*pCoeff[j];
}
pDst = (Ipp16s*)((Ipp8u*)pDst + dstStep);
pSrc1 = (Ipp16s*)((Ipp8u*)pSrc1 + src1Step);
pSrc2 = (Ipp16s*)((Ipp8u*)pSrc2 + src2Step);
pCoeff += coefStep;
}
}
//---BEGIN------------------------Copy block, MB functions-----------------------------------------------
//---END------------------------Copy block, MB functions-----------------------------------------------
//Ipp32u GetNumZeros(Ipp16s* pSrc, Ipp32u srcStep, bool bIntra)
//{
// int i,j;
// Ipp32u s=0;
// Ipp16s* pBlock = pSrc;
//
// for(i = 0; i<8; i++)
// {
// for (j = bIntra; j<8; j++)
// {
// s+= !pBlock[j];
// }
// bIntra = false;
// pBlock = (Ipp16s*)((Ipp8u*) pBlock + srcStep);
// }
// //printf ("intra MB: num of coeff %d\n",64 - s - bIntra);
// return s;
//}
//Ipp32u GetNumZeros(Ipp16s* pSrc, Ipp32u srcStep)
//{
// int i,j;
// Ipp32u s=0;
// Ipp16s* pBlock = pSrc;
//
// for(i = 0; i<8; i++)
// {
// for (j = 0; j<8; j++)
// {
// s+= !pBlock[j];
// }
// pBlock = (Ipp16s*)((Ipp8u*) pBlock + srcStep);
// }
// //printf ("intra MB: num of coeff %d\n",64 - s);
// return s;
//}
//Ipp8u GetBlockPattern(Ipp16s* pBlock, Ipp32u step)
//{
// int i,j;
// Ipp8u s[4]={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);
// }
// //printf ("inter MB: num of coeff %d\n",64 - (s[0]+s[1]+s[2]+s[3]));
// return (((s[0]<16)<<3)|((s[1]<16)<<2)|((s[2]<16)<<1)| (s[3]<16));
//
//}
Ipp8u GetMode( Ipp8u &run, Ipp16s &level, const Ipp8u *pTableDR, const Ipp8u *pTableDL, bool& sign)
{
sign = level < 0;
level = (sign)? -level : level;
if (run <= pTableDR[1])
{
Ipp8u maxLevel = pTableDL[run];
if (level <= maxLevel)
{
return 0;
}
if (level <= 2*maxLevel)
{
level -= maxLevel;
return 1;
}
}
if (level <= pTableDL[0])
{
Ipp8u maxRun = pTableDR[level];
if (run <= (Ipp8u)(2*maxRun + 1)) // level starts from 0
{
run -= (Ipp8u)maxRun + 1;
return 2;
}
}
return 3;
}
//bool GetRLCode(Ipp32s run, Ipp32s level, IppVCHuffmanSpec_32s *pTable, Ipp32s &code, Ipp32s &len)
//{
// Ipp32s maxRun = pTable[0] >> 20;
// Ipp32s addr;
// Ipp32s *table;
//
// if(run > maxRun)
// {
// return false;
// }
// addr = pTable[run + 1];
// table = (Ipp32s*)((Ipp8s*)pTable + addr);
// if(level <= table[0])
// {
// len = *(table + level) & 0x1f;
// code = (*(table + level) >> 16);
// return true;
// }
// return false;
//}
//Ipp8u Zigzag ( Ipp16s* pBlock,
// Ipp32u blockStep,
// bool bIntra,
// const Ipp8u* pScanMatrix,
// Ipp8u* pRuns,
// Ipp16s* pLevels)
//{
// Ipp32s i = 0, pos = 0;
// Ipp16s value = 0;
// Ipp8u n_pairs = 0;
//
// pRuns[n_pairs] = 0;
// for (i = bIntra; i<64; i++)
// {
// pos = pScanMatrix[i];
// value = *((Ipp16s*)((Ipp8u*)pBlock + blockStep*(pos/8)) + pos%8);
// if (!value)
// {
// pRuns[n_pairs]++;
// }
// else
// {
// pLevels [n_pairs++] = value;
// pRuns [n_pairs] = 0;
// }
//
// }
// return n_pairs;
//}
//Ipp8u GetLength_16s(Ipp16s value)
//{
// int i=0;
// Ipp16u n = (Ipp16u)value;
// while (n>>i)
// {
// i++;
// }
// return i;
//
//}
//---BEGIN------------------------Add constant to block-----------------------------------------------
//---End------------------------Add constant to block-----------------------------------------------
//---Begin------------------------Get difference-----------------------------------------------
//---End------------------------Get difference-----------------------------------------------
//---Begin---------------------Motion compensation-----------------------------------------------
//---End---------------------Motion compensation-----------------------------------------------
Ipp16s median3(Ipp16s a, Ipp16s b, Ipp16s c)
{
if ((a-b)*(b-c)>=0)
{
return b;
}
else
{
return ((b-a)*(a-c)>=0)? a:c;
}
}
void PredictMV(sCoordinate* predA,sCoordinate* predB,sCoordinate* predC, sCoordinate* res)
{
res->x=0;
res->y=0;
if (predA)
{
predB = (!predB)? res: predB;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -