📄 block.c
字号:
// printf("error\n");
// if((b[1]+b[5])<=-32768 || (b[1]+b[5])>=(32768-65 ))
// printf("error\n");
// if((b[2]+b[6])<=-32768 || (b[2]+b[6])>=(32768-65 ))
// printf("error\n");
// if((b[3]+b[7])<=-32768 || (b[3]+b[7])>=(32768-65 ))
// printf("error\n");
// if((b[0]-b[4])<=-32768 || (b[0]-b[4])>=(32768-65 ))
// printf("error\n");
// if((b[1]-b[5])<=-32768 || (b[1]-b[5])>=(32768-65 ))
// printf("error\n");
// if((b[2]-b[6])<=-32768 || (b[2]-b[6])>=(32768-65 ))
// printf("error\n");
// if((b[3]-b[7])<=-32768 || (b[3]-b[7])>=(32768-65 ))
// printf("error\n");
}
}
/*
*************************************************************************
* Function:
Quantization, scan and reconstruction of a transformed 8x8 bock
Return coeff_cost of the block.
* Input:
* Output:
* Return:
* Attention:
*************************************************************************
*/
int scanquant_B8(int qp, int mode, int block8x8, // block8x8: number of current 8x8 block
short curr_blk[B8_SIZE][B8_SIZE],
int scrFlag,
int *cbp,
int *cbp_blk
)
{
int run;
int xx, yy;
int intra;
int icoef, ipos;
int b8_y = (block8x8 / 2) << 3;
int b8_x = (block8x8 % 2) << 3;
int coeff_cost = 0;
int* ACLevel;
int* ACRun;
int curr_val;
// Quantization
quant_B8(qp, mode, curr_blk);
// Scan
intra=0;
if(mode>3)
intra=1;
mode %= 4; // mode+=4 is used to signal intra coding to quant_B8().
// General block information
ACLevel = img->cofAC[block8x8][0][0];
ACRun = img->cofAC[block8x8][0][1];
for (xx=0; xx<65; xx++)
ACRun[xx] = ACLevel[xx] = 0;
run = -1;
ipos = 0;
for (icoef=0; icoef<64; icoef++)
{
run++;
xx = AVS_SCAN[img->picture_structure][icoef][0];
yy = AVS_SCAN[img->picture_structure][icoef][1];
curr_val = curr_blk[yy][xx];
if (curr_val != 0)
{
ACLevel[ipos] = curr_val;
ACRun[ipos] = run;
if (scrFlag && absm(ACLevel[ipos])==1)
coeff_cost += (scrFlag==1)? 1 : AVS_COEFF_COST[run];
else
coeff_cost += MAX_VALUE; // block has to be saved
{
int val, temp, shift, QPI;
shift = IQ_SHIFT[qp];
QPI = IQ_TAB[qp];
val = curr_blk[yy][xx];
temp = (val*QPI+(1<<(shift-2)) )>>(shift-1);
curr_blk[yy][xx] = temp;// dequantization & descale
}
run = -1;
ipos++;
}
}
if (ipos>0) // there are coefficients
if (block8x8 <= 3)
(*cbp) |= (1<<block8x8);
else
(*cbp) |= (1<<(block8x8));/*lgp*dct*/
// Inverse transform
inv_transform_B8(curr_blk);
// reconstruct current 8x8 block and add to prediction block
for(yy=0;yy<8;yy++)
for(xx=0;xx<8;xx++)
{
if(block8x8 <= 3)
curr_val = img->mpr[b8_x+xx][b8_y+yy] + curr_blk[yy][xx];
else
curr_val = img->mpr[xx][yy] + curr_blk[yy][xx];
img->m7[xx][yy] = curr_blk[yy][xx] = clamp(curr_val,0,255);
if(block8x8 <= 3)
imgY[img->pix_y+b8_y+yy][img->pix_x+b8_x+xx] = (unsigned char)curr_blk[yy][xx];
else
imgUV[block8x8-4][img->pix_c_y+yy][img->pix_c_x+xx] = (unsigned char) curr_blk[yy][xx];
}
for(yy=0;yy<8;yy++)
for(xx=0;xx<8;xx++)
{
MB_16_temp[yy][xx] = curr_blk[yy][xx]-128;
}
return coeff_cost;
}
/*
*************************************************************************
* Function: Calculate SAD or SATD for a prediction error block of size
iSizeX x iSizeY.
* Input:
* Output:
* Return:
* Attention:
*************************************************************************
*/
int find_sad_8x8(int iMode,
int iSizeX,
int iSizeY,
int iOffX,
int iOffY,
int m7[MB_BLOCK_SIZE][MB_BLOCK_SIZE]
)
{
int i,j;
int bmode;
int ishift = 0;
int sad = 0;
assert( (iSizeX+iOffX) <= MB_BLOCK_SIZE );
assert( (iSizeY+iOffY) <= MB_BLOCK_SIZE );
// m7[y,j,line][x,i,pixel]
switch (iMode)
{
case 0 : // ---------- SAD ----------
for (j=iOffY; j < iOffY+iSizeY; j++)
for (i=iOffX; i < iOffX+iSizeX; i++)
sad += absm(m7[j][i]);
break;
case 1 : // --------- SATD ----------
bmode = iSizeX+iSizeY;
if (bmode<24) // 8x8
{
sad = sad_hadamard(iSizeY,iSizeX,iOffY,iOffX,m7); // Attention: sad_hadamard() is X/Y flipped
ishift = 2;
sad = (sad + (1<<(ishift-1)))>>ishift;
}
else // 8x16-16x16
{
switch (bmode)
{
case 24 : // 16x8 8x16
sad = sad_hadamard(8,8,iOffY,iOffX,m7);
sad += sad_hadamard(8,8,iOffY+((iSizeY==16)?8:0) , iOffX+((iSizeX==16)?8:0) ,m7);
ishift = 2;
break;
case 32 : // 16x16
sad = sad_hadamard(8,8,0,0,m7);
sad += sad_hadamard(8,8,8,0,m7);
sad += sad_hadamard(8,8,0,8,m7);
sad += sad_hadamard(8,8,8,8,m7);
ishift = 2;
break;
default :
assert(0==1);
}
sad = (sad + (1<<(ishift-1)))>>ishift;
}
break;
default :
assert(0==1); // more switches may be added here later
}
return sad;
}
/*
*************************************************************************
* Function:
calculates the SAD of the Hadamard transformed block of
size iSizeX*iSizeY. Block may have an offset of (iOffX,iOffY).
If offset!=0 then iSizeX/Y has to be <=8.
* Input:
* Output:
* Return:
* Attention:
*************************************************************************
*/
int sad_hadamard(int iSizeX, int iSizeY, int iOffX, int iOffY, int m7[MB_BLOCK_SIZE][MB_BLOCK_SIZE])
{
int i,j,ii;
int m1[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
int m2[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
int m3[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
int sad = 0;
int iy[MB_BLOCK_SIZE] =
{
iOffY,iOffY,iOffY,iOffY,
iOffY,iOffY,iOffY,iOffY,
iOffY,iOffY,iOffY,iOffY,
iOffY,iOffY,iOffY,iOffY
};
// in this routine, cols are j,y and rows are i,x
assert( ((iOffX==0)||(iSizeX<=8)) && ((iOffY==0)||(iSizeY<=8)) );
for (j=1; j<iSizeY; j++)
iy[j] += j;
// vertical transform
if (iSizeY == 4)
for (i=0; i < iSizeX; i++)
{
ii = i+iOffX;
m1[i][0] = m7[ii][iy[0]] + m7[ii][iy[3]];
m1[i][1] = m7[ii][iy[1]] + m7[ii][iy[2]];
m1[i][2] = m7[ii][iy[1]] - m7[ii][iy[2]];
m1[i][3] = m7[ii][iy[0]] - m7[ii][iy[3]];
m3[i][0] = m1[i][0] + m1[i][1];
m3[i][1] = m1[i][0] - m1[i][1];
m3[i][2] = m1[i][2] + m1[i][3];
m3[i][3] = m1[i][3] - m1[i][2];
}
else
for (i=0; i < iSizeX; i++)
{
ii = i+iOffX;
m1[i][0] = m7[ii][iy[0]] + m7[ii][iy[4]];
m1[i][1] = m7[ii][iy[1]] + m7[ii][iy[5]];
m1[i][2] = m7[ii][iy[2]] + m7[ii][iy[6]];
m1[i][3] = m7[ii][iy[3]] + m7[ii][iy[7]];
m1[i][4] = m7[ii][iy[0]] - m7[ii][iy[4]];
m1[i][5] = m7[ii][iy[1]] - m7[ii][iy[5]];
m1[i][6] = m7[ii][iy[2]] - m7[ii][iy[6]];
m1[i][7] = m7[ii][iy[3]] - m7[ii][iy[7]];
m2[i][0] = m1[i][0] + m1[i][2];
m2[i][1] = m1[i][1] + m1[i][3];
m2[i][2] = m1[i][0] - m1[i][2];
m2[i][3] = m1[i][1] - m1[i][3];
m2[i][4] = m1[i][4] + m1[i][6];
m2[i][5] = m1[i][5] + m1[i][7];
m2[i][6] = m1[i][4] - m1[i][6];
m2[i][7] = m1[i][5] - m1[i][7];
m3[i][0] = m2[i][0] + m2[i][1];
m3[i][1] = m2[i][0] - m2[i][1];
m3[i][2] = m2[i][2] + m2[i][3];
m3[i][3] = m2[i][2] - m2[i][3];
m3[i][4] = m2[i][4] + m2[i][5];
m3[i][5] = m2[i][4] - m2[i][5];
m3[i][6] = m2[i][6] + m2[i][7];
m3[i][7] = m2[i][6] - m2[i][7];
}
// horizontal transform
if (iSizeX == 4)
for (j=0; j < iSizeY; j++)
{
m1[0][j]=m3[0][j]+m3[3][j];
m1[1][j]=m3[1][j]+m3[2][j];
m1[2][j]=m3[1][j]-m3[2][j];
m1[3][j]=m3[0][j]-m3[3][j];
m2[0][j]=m1[0][j]+m1[1][j];
m2[1][j]=m1[0][j]-m1[1][j];
m2[2][j]=m1[2][j]+m1[3][j];
m2[3][j]=m1[3][j]-m1[2][j];
for (i=0; i < iSizeX; i++)
sad += absm(m2[i][j]);
}
else
for (j=0; j < iSizeY; j++)
{
m2[0][j] = m3[0][j] + m3[4][j];
m2[1][j] = m3[1][j] + m3[5][j];
m2[2][j] = m3[2][j] + m3[6][j];
m2[3][j] = m3[3][j] + m3[7][j];
m2[4][j] = m3[0][j] - m3[4][j];
m2[5][j] = m3[1][j] - m3[5][j];
m2[6][j] = m3[2][j] - m3[6][j];
m2[7][j] = m3[3][j] - m3[7][j];
m1[0][j] = m2[0][j] + m2[2][j];
m1[1][j] = m2[1][j] + m2[3][j];
m1[2][j] = m2[0][j] - m2[2][j];
m1[3][j] = m2[1][j] - m2[3][j];
m1[4][j] = m2[4][j] + m2[6][j];
m1[5][j] = m2[5][j] + m2[7][j];
m1[6][j] = m2[4][j] - m2[6][j];
m1[7][j] = m2[5][j] - m2[7][j];
m2[0][j] = m1[0][j] + m1[1][j];
m2[1][j] = m1[0][j] - m1[1][j];
m2[2][j] = m1[2][j] + m1[3][j];
m2[3][j] = m1[2][j] - m1[3][j];
m2[4][j] = m1[4][j] + m1[5][j];
m2[5][j] = m1[4][j] - m1[5][j];
m2[6][j] = m1[6][j] + m1[7][j];
m2[7][j] = m1[6][j] - m1[7][j];
for (i=0; i < iSizeX; i++)
sad += absm(m2[i][j]);
}
return(sad);
}
int writeLumaCoeffAVS_B8(int b8,int intra)
{
int no_bits = 0;
int mb_nr = img->current_mb_nr;
Macroblock *currMB = &img->mb_data[mb_nr];
const int cbp = currMB->cbp;
int *bitCount = currMB->bitcounter;
SyntaxElement *currSE = &img->MB_SyntaxElements[currMB->currSEnr];
const char (*AVS_2DVLC_table_intra)[26][27]; //qwang 11.29
const char (*AVS_2DVLC_table_inter)[26][27]; //qwang 11.29
int inumblk; /* number of blocks per CBP*/
int inumcoeff; /* number of coeffs per block */
int iblk; /* current block */
int icoef; /* current coefficient */
int ipos; /* current position in cof_AVS */
int run, level;
int i, j;
int b4;
int* ACLevel;
int* ACRun;
int symbol2D;
int escape_level_diff; // added by dj
int tablenum;
static const int incVlc_intra[7] = { 0,1,2,4,7,10,3000}; //qwang 11.29
static const int incVlc_inter[7] = { 0,1,2,3,6,9,3000}; //qwang 11.29
static const int blk_table[4] = {0,-1,-1,-1};
static const int blkmode2ctx [4] = {LUMA_8x8, LUMA_8x4, LUMA_4x8, LUMA_4x4};
inumblk = 1;
inumcoeff = 65; // all positions + EOB
AVS_2DVLC_table_intra = AVS_2DVLC_INTRA;
AVS_2DVLC_table_inter = AVS_2DVLC_INTER;
if ( cbp & (1<<b8) )
{
//code all symbols
for (iblk=0; iblk<1; iblk++)
{
i=0; // =b4
j=(i&~1)<<1; //off_x
i=(i&1)<<2; //off_y
if( (i<0) || (i>=8) || (j<0) || (j>=8) )
continue; //used in AVS Intra RDopt. code one one subblock.
b4 = blk_table[iblk];
level = 1; // get inside loop
ipos = 0;
ACLevel = img->cofAC[b8][b4][0];
ACRun = img->cofAC[b8][b4][1];
for(icoef=0;icoef<inumcoeff;icoef++) //count coeffs
if(!ACLevel[icoef])
break;
if(intra)
{
tablenum = 0;
for(icoef; icoef>=0; icoef--)
{
if(icoef == 0) //EOB
{
level = 0;
run = 0;
}
else
{
level = ACLevel[icoef-1];
run = ACRun[icoef-1];
}
symbol2D=CODE2D_ESCAPE_SYMBOL; //symbol for out-of-table
if(level>-27 && level<27 && run<26)
{
if(tablenum == 0)
//symbol2D = AVS_2DVLC_INTRA[tablenum][run][abs(level)-1];
symbol2D = AVS_2DVLC_table_intra[tablenum][run][abs(level)-1]; //qwang 11.29
else
//symbol2D = AVS_2DVLC_INTRA[tablenum][run][abs(level)];
symbol2D = AVS_2DVLC_table_intra[tablenum][run][abs(level)]; //qwang 11.29
if(symbol2D >= 0 && level < 0)
symbol2D++;
if(symbol2D < 0)
// symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?0:1)); // added by dj
symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?1:0)); //jlzheng 7.20
}
// added by dj
else
{
// symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?0:1));
symbol2D = (CODE2D_ESCAPE_SYMBOL + (run<<1) + ((level>0)?1:0)); //jlzheng 7.20
}
// end
currSE->type = SE_LUM_AC_INTER;
currSE->value1=symbol2D;
currSE->value2=0;
//currSE->golomb_grad=2;
//currSE->golomb_maxlevels=4;
currSE->golomb_grad = VLC_Golomb_Order[0][tablenum][0]; //qwang 11.29
currSE->golomb_maxlevels = VLC_Golomb_Order[0][tablenum][1]; //qwang 11.29
writeSyntaxElement_GOLOMB(currSE,currBitStream);
bitCount[BITS_COEFF_Y_MB]+=currSE->len;
no_bits+=currSE->len;
currSE++;// proceed to next SE
currMB->currSEnr++;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -