📄 block.c
字号:
void rd_quant(int scan_type,int *coeff)
{
int idx,coeff_ctr;
int qp_const,intra_add;
int dbl_coeff_ctr;
int level0,level1;
int snr0;
int dbl_coeff,k,k1,k2,rd_best,best_coeff_comb,rd_curr,snr1;
int k0;
int quant_set;
int ilev,run,level;
int no_coeff;
if (img->type == INTRA_IMG)
{
qp_const=JQQ3;
intra_add=2;
}
else
{
qp_const=JQQ4;
intra_add=0;
}
quant_set=img->qp;
switch (scan_type)
{
case QUANT_LUMA_SNG:
quant_set=img->qp;
idx=2;
no_coeff=16;
break;
case QUANT_LUMA_AC:
quant_set=img->qp;
idx=2;
no_coeff=15;
break;
case QUANT_LUMA_DBL:
quant_set=img->qp;
idx=1;
no_coeff=8;
break;
case QUANT_CHROMA_DC:
quant_set=QP_SCALE_CR[img->qp];
idx=0;
no_coeff=4;
break;
case QUANT_CHROMA_AC:
quant_set=QP_SCALE_CR[img->qp];
idx=2;
no_coeff=15;
break;
default:
error("rd_quant: unsupported scan_type", 600);
break;
}
dbl_coeff_ctr=0;
for (coeff_ctr=0;coeff_ctr < no_coeff ;coeff_ctr++)
{
k0=coeff[coeff_ctr];
k1=abs(k0);
if (dbl_coeff_ctr < MAX_TWO_LEVEL_COEFF) // limit the number of 'twin' levels
{
level0 = (k0*JQ[quant_set][0])/J20;
level1 = (k1*JQ[quant_set][0]+JQ4)/J20; // make positive summation
level1 = sign(level1,k0);// set back sign on level
}
else
{
level0 = (k1*JQ[quant_set][0]+qp_const)/J20;
level0 = sign(level0,k0);
level1 = level0;
}
if (level0 != level1)
{
dbl_coeff = TRUE; // decision is still open
dbl_coeff_ctr++; // count number of coefficients with 2 possible levels
}
else
dbl_coeff = FALSE; // level is decided
snr0 = (12+intra_add)*level0*(64*level0 - (JQ[quant_set][0]*coeff[coeff_ctr])/J13); // find SNR improvement
level_arr[coeff_ctr][MTLC_POW]=0; // indicates that all coefficients are decided
for (k=0; k< MTLC_POW; k++)
{
level_arr[coeff_ctr][k]=level0;
snr_arr[coeff_ctr][k]=snr0;
}
if (dbl_coeff)
{
snr1 = (12+intra_add)*level1*(64*level1 - (JQ[quant_set][0]*coeff[coeff_ctr])/J13);
ilev= (int)pow(2,dbl_coeff_ctr-1);
for (k1=ilev; k1<MTLC_POW; k1+=ilev*2)
{
for (k2=k1; k2<k1+ilev; k2++)
{
level_arr[coeff_ctr][k2]=level1;
snr_arr[coeff_ctr][k2]=snr1;
}
}
}
}
rd_best=0;
best_coeff_comb= MTLC_POW; // initial setting, used if no double decision coefficients
for (k=0; k < pow(2,dbl_coeff_ctr);k++) // go through all combinations
{
rd_curr=0;
run=-1;
for (coeff_ctr=0;coeff_ctr < no_coeff;coeff_ctr++)
{
run++;
level=min(16,absm(level_arr[coeff_ctr][k]));
if (level != 0)
{
rd_curr += 64*COEFF_BIT_COST[idx][run][level-1]+snr_arr[coeff_ctr][k];
run = -1;
}
}
if (rd_curr < rd_best)
{
rd_best=rd_curr;
best_coeff_comb=k;
}
}
for (coeff_ctr=0;coeff_ctr < no_coeff ;coeff_ctr++)
coeff[coeff_ctr]=level_arr[coeff_ctr][best_coeff_comb];
return;
}
/*!
************************************************************************
* \brief
* The routine performs transform,quantization,inverse transform, adds the diff.
* to the prediction and writes the result to the decoded luma frame. Includes the
* RD constrained quantization also.
*
* \para Input:
* block_x,block_y: Block position inside a macro block (0,4,8,12).
*
* \para Output:
* nonzero: 0 if no levels are nonzero. 1 if there are nonzero levels. \n
* coeff_cost: Counter for nonzero coefficients, used to discard expencive levels.
*
*
************************************************************************/
#ifndef NO_RDQUANT
int dct_luma_sp(int block_x,int block_y,int *coeff_cost)
{
int sign(int a,int b);
int i,j,i1,j1,ilev,m5[4],m6[4],coeff_ctr,scan_loop_ctr;
int pos_x,pos_y,quant_set,level,scan_pos,run;
int nonzero;
int idx;
int scan_mode;
int loop_rep;
int predicted_block[BLOCK_SIZE][BLOCK_SIZE],alpha,quant_set1,Fq1q2;
int coeff[16],coeff2[16];
pos_x=block_x/BLOCK_SIZE;
pos_y=block_y/BLOCK_SIZE;
// Horizontal transform
for (j=0; j< BLOCK_SIZE; j++)
for (i=0; i< BLOCK_SIZE; i++)
{
img->m7[i][j]+=img->mpr[i+block_x][j+block_y];
predicted_block[i][j]=img->mpr[i+block_x][j+block_y];
}
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < 2; i++)
{
i1=3-i;
m5[i]=img->m7[i][j]+img->m7[i1][j];
m5[i1]=img->m7[i][j]-img->m7[i1][j];
}
img->m7[0][j]=(m5[0]+m5[1])*13;
img->m7[2][j]=(m5[0]-m5[1])*13;
img->m7[1][j]=m5[3]*17+m5[2]*7;
img->m7[3][j]=m5[3]*7-m5[2]*17;
}
// Vertival transform
for (i=0; i < BLOCK_SIZE; i++)
{
for (j=0; j < 2; j++)
{
j1=3-j;
m5[j]=img->m7[i][j]+img->m7[i][j1];
m5[j1]=img->m7[i][j]-img->m7[i][j1];
}
img->m7[i][0]=(m5[0]+m5[1])*13;
img->m7[i][2]=(m5[0]-m5[1])*13;
img->m7[i][1]=m5[3]*17+m5[2]*7;
img->m7[i][3]=m5[3]*7-m5[2]*17;
}
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < 2; i++)
{
i1=3-i;
m5[i]=predicted_block[i][j]+predicted_block[i1][j];
m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
}
predicted_block[0][j]=(m5[0]+m5[1])*13;
predicted_block[2][j]=(m5[0]-m5[1])*13;
predicted_block[1][j]=m5[3]*17+m5[2]*7;
predicted_block[3][j]=m5[3]*7-m5[2]*17;
}
// Vertival transform
for (i=0; i < BLOCK_SIZE; i++)
{
for (j=0; j < 2; j++)
{
j1=3-j;
m5[j]=predicted_block[i][j]+predicted_block[i][j1];
m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
}
predicted_block[i][0]=(m5[0]+m5[1])*13;
predicted_block[i][2]=(m5[0]-m5[1])*13;
predicted_block[i][1]=m5[3]*17+m5[2]*7;
predicted_block[i][3]=m5[3]*7-m5[2]*17;
}
// Quant
quant_set=img->qp;
quant_set1=img->qpsp;
alpha=(JQQ1+JQ[quant_set1][0]/2)/JQ[quant_set1][0];
Fq1q2=(JQQ1*JQ[quant_set1][0]+JQ[quant_set][0]/2)/JQ[quant_set][0];
nonzero=FALSE;
scan_mode=SINGLE_SCAN;
loop_rep=1;
idx=0;
for(scan_loop_ctr=0;scan_loop_ctr<loop_rep;scan_loop_ctr++) // 2 times if double scan, 1 normal scan
{
for (coeff_ctr=0;coeff_ctr < 16/loop_rep;coeff_ctr++) // 8 times if double scan, 16 normal scan
{
if (scan_mode==DOUBLE_SCAN)
{
i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
}
else
{
i=SNGL_SCAN[coeff_ctr][0];
j=SNGL_SCAN[coeff_ctr][1];
}
coeff[coeff_ctr]=img->m7[i][j];
coeff2[coeff_ctr]=(img->m7[i][j]-sign(((abs (predicted_block[i][j]) * JQ[quant_set1][0] +JQQ2) / JQQ1),predicted_block[i][j])*alpha);
}
rd_quant(QUANT_LUMA_SNG,coeff2);
run=-1;
scan_pos=scan_loop_ctr*9; // for double scan; set first or second scan posision
for (coeff_ctr=0; coeff_ctr<16/loop_rep; coeff_ctr++)
{
if (scan_mode==DOUBLE_SCAN)
{
i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
}
else
{
i=SNGL_SCAN[coeff_ctr][0];
j=SNGL_SCAN[coeff_ctr][1];
}
run++;
ilev=0;
level= absm(coeff2[coeff_ctr]);
if (level != 0)
{
nonzero=TRUE;
if (level > 1)
*coeff_cost += MAX_VALUE; // set high cost, shall not be discarded
else
*coeff_cost += COEFF_COST[run];
img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=sign(level,coeff2[coeff_ctr]);
img->cof[pos_x][pos_y][scan_pos][1][scan_mode]=run;
++scan_pos;
run=-1; // reset zero level counter
ilev=level;
}
ilev=coeff2[coeff_ctr]*Fq1q2+predicted_block[i][j]*JQ[quant_set1][0];
img->m7[i][j]=sign((abs(ilev)+JQQ2)/ JQQ1,ilev)*JQ[quant_set1][1];
}
img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=0; // end of block
}
// IDCT.
// horizontal
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < BLOCK_SIZE; i++)
{
m5[i]=img->m7[i][j];
}
m6[0]=(m5[0]+m5[2])*13;
m6[1]=(m5[0]-m5[2])*13;
m6[2]=m5[1]*7-m5[3]*17;
m6[3]=m5[1]*17+m5[3]*7;
for (i=0; i < 2; i++)
{
i1=3-i;
img->m7[i][j]=m6[i]+m6[i1];
img->m7[i1][j]=m6[i]-m6[i1];
}
}
// vertical
for (i=0; i < BLOCK_SIZE; i++)
{
for (j=0; j < BLOCK_SIZE; j++)
{
m5[j]=img->m7[i][j];
}
m6[0]=(m5[0]+m5[2])*13;
m6[1]=(m5[0]-m5[2])*13;
m6[2]=m5[1]*7-m5[3]*17;
m6[3]=m5[1]*17+m5[3]*7;
for (j=0; j < 2; j++)
{
j1=3-j;
img->m7[i][j] =min(255,max(0,(m6[j]+m6[j1]+JQQ2)/JQQ1));
img->m7[i][j1]=min(255,max(0,(m6[j]-m6[j1]+JQQ2)/JQQ1));
}
}
// Decoded block moved to frame memory
for (j=0; j < BLOCK_SIZE; j++)
for (i=0; i < BLOCK_SIZE; i++)
imgY[img->pix_y+block_y+j][img->pix_x+block_x+i]=img->m7[i][j];
return nonzero;
}
#endif
#ifdef NO_RDQUANT
int dct_luma_sp(int block_x,int block_y,int *coeff_cost)
{
int sign(int a,int b);
int i,j,i1,j1,ilev,m5[4],m6[4],coeff_ctr,scan_loop_ctr;
int qp_const,pos_x,pos_y,quant_set,level,scan_pos,run;
int nonzero;
int idx;
int scan_mode;
int loop_rep;
int predicted_block[BLOCK_SIZE][BLOCK_SIZE],alpha,quant_set1,Fq1q2,c_err;
qp_const=JQQ4; // inter
pos_x=block_x/BLOCK_SIZE;
pos_y=block_y/BLOCK_SIZE;
// Horizontal transform
for (j=0; j< BLOCK_SIZE; j++)
for (i=0; i< BLOCK_SIZE; i++)
{
img->m7[i][j]+=img->mpr[i+block_x][j+block_y];
predicted_block[i][j]=img->mpr[i+block_x][j+block_y];
}
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < 2; i++)
{
i1=3-i;
m5[i]=img->m7[i][j]+img->m7[i1][j];
m5[i1]=img->m7[i][j]-img->m7[i1][j];
}
img->m7[0][j]=(m5[0]+m5[1])*13;
img->m7[2][j]=(m5[0]-m5[1])*13;
img->m7[1][j]=m5[3]*17+m5[2]*7;
img->m7[3][j]=m5[3]*7-m5[2]*17;
}
// Vertival transform
for (i=0; i < BLOCK_SIZE; i++)
{
for (j=0; j < 2; j++)
{
j1=3-j;
m5[j]=img->m7[i][j]+img->m7[i][j1];
m5[j1]=img->m7[i][j]-img->m7[i][j1];
}
img->m7[i][0]=(m5[0]+m5[1])*13;
img->m7[i][2]=(m5[0]-m5[1])*13;
img->m7[i][1]=m5[3]*17+m5[2]*7;
img->m7[i][3]=m5[3]*7-m5[2]*17;
}
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < 2; i++)
{
i1=3-i;
m5[i]=predicted_block[i][j]+predicted_block[i1][j];
m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
}
predicted_block[0][j]=(m5[0]+m5[1])*13;
predicted_block[2][j]=(m5[0]-m5[1])*13;
predicted_block[1][j]=m5[3]*17+m5[2]*7;
predicted_block[3][j]=m5[3]*7-m5[2]*17;
}
// Vertival transform
for (i=0; i < BLOCK_SIZE; i++)
{
for (j=0; j < 2; j++)
{
j1=3-j;
m5[j]=predicted_block[i][j]+predicted_block[i][j1];
m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
}
predicted_block[i][0]=(m5[0]+m5[1])*13;
predicted_block[i][2]=(m5[0]-m5[1])*13;
predicted_block[i][1]=m5[3]*17+m5[2]*7;
predicted_block[i][3]=m5[3]*7-m5[2]*17;
}
// Quant
quant_set=img->qp;
quant_set1=img->qpsp;
alpha=(JQQ1+JQ[quant_set1][0]/2)/JQ[quant_set1][0];
Fq1q2=(JQQ1*JQ[quant_set1][0]+JQ[quant_set][0]/2)/JQ[quant_set][0];
nonzero=FALSE;
scan_mode=SINGLE_SCAN;
loop_rep=1;
idx=0;
for(scan_loop_ctr=0;scan_loop_ctr<loop_rep;scan_loop_ctr++) // 2 times if double scan, 1 normal scan
{
run=-1;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -