📄 block.c
字号:
if(!lossless_qpprime)
img->m7[n1+i][n2+j]=ilev;
}
ACLevel[scan_pos] = 0;
}
}
// * reset chroma coeffs
if(coeff_cost < _CHROMA_COEFF_COST_ && !lossless_qpprime)
{
cr_cbp_tmp = 0 ;
for (b8=0; b8 < (img->num_blk8x8_uv/2); b8++)
{
for (b4=0; b4 < 4; b4++)
{
n1 = hor_offset[yuv][b8][b4];
n2 = ver_offset[yuv][b8][b4];
ACLevel = img->cofAC[4+b8+uv_scale][b4][0];
ACRun = img->cofAC[4+b8+uv_scale][b4][1];
if( DCcoded == 0) currMB->cbp_blk &= ~((int64)cbpblk_pattern[yuv] << (uv << (1+yuv))); // if no chroma DC's: then reset coded-bits of this chroma subblock
ACLevel[0] = 0;
for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// ac coeff
{
if (img->field_picture || ( img->MbaffFrameFlag && currMB->mb_field ))
{ // Alternate scan for field coding
i=FIELD_SCAN[coeff_ctr][0];
j=FIELD_SCAN[coeff_ctr][1];
}
else
{
i=SNGL_SCAN[coeff_ctr][0];
j=SNGL_SCAN[coeff_ctr][1];
}
img->m7[n1+i][n2+j]=0;
ACLevel[coeff_ctr] = 0;
}
}
}
}
if(cr_cbp_tmp==2)
cr_cbp = 2;
// IDCT.
// Horizontal.
for (n2=0; n2 < img->mb_cr_size_y && !lossless_qpprime; n2 += BLOCK_SIZE)
{
for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
{
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < BLOCK_SIZE; i++)
{
m5[i]=img->m7[n1+i][n2+j];
}
m6[0]=(m5[0]+m5[2]);
m6[1]=(m5[0]-m5[2]);
m6[2]=(m5[1]>>1)-m5[3];
m6[3]=m5[1]+(m5[3]>>1);
for (i=0; i < 2; i++)
{
i1=3-i;
img->m7[n1+i][n2+j]=m6[i]+m6[i1];
img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
}
}
// Vertical.
for (i=0; i < BLOCK_SIZE && !lossless_qpprime; i++)
{
for (j=0; j < BLOCK_SIZE; j++)
{
m5[j]=img->m7[n1+i][n2+j];
}
m6[0]=(m5[0]+m5[2]);
m6[1]=(m5[0]-m5[2]);
m6[2]=(m5[1]>>1)-m5[3];
m6[3]=m5[1]+(m5[3]>>1);
for (j=0; j < 2; j++)
{
j2=3-j;
// Residue Color Transform
if (!img->residue_transform_flag)
{
img->m7[n1+i][n2+j] =min(img->max_imgpel_value_uv,max(0,(m6[j]+m6[j2]+((long)img->mpr[n1+i][n2+j] <<DQ_BITS)+DQ_ROUND)>>DQ_BITS));
img->m7[n1+i][n2+j2]=min(img->max_imgpel_value_uv,max(0,(m6[j]-m6[j2]+((long)img->mpr[n1+i][n2+j2]<<DQ_BITS)+DQ_ROUND)>>DQ_BITS));
}
else
{
img->m7[n1+i][n2+j] =(m6[j]+m6[j2]+DQ_ROUND)>>DQ_BITS;
img->m7[n1+i][n2+j2]=(m6[j]-m6[j2]+DQ_ROUND)>>DQ_BITS;
}
}
}
}
}
// Decoded block moved to memory
if (!img->residue_transform_flag)
for (j=0; j < img->mb_cr_size_y; j++)
{
for (i=0; i < img->mb_cr_size_x; i++)
{
if(lossless_qpprime)
enc_picture->imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j]+img->mpr[i][j];
else
enc_picture->imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
}
}
return cr_cbp;
}
// Residue Color Transform
int dct_chroma4x4(int uv, int b8, int b4)
{
int sign(int a,int b);
int i,j,i1,j1,ilev,m5[4],m6[4],coeff_ctr;
int qp_const,level,scan_pos,run;
int nonzeroAC;
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
int intra = IS_INTRA (currMB);
int qp_per,qp_rem,q_bits;
int qp_c;
int* ACLevel = img->cofAC[b8][b4][0];
int* ACRun = img->cofAC[b8][b4][1];
Boolean lossless_qpprime = ((img->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
qp_c = currMB->qp + img->chroma_qp_offset[uv];
qp_c = (qp_c < 0)? qp_c : QP_SCALE_CR[qp_c - MIN_QP];
qp_per = (qp_c + img->bitdepth_chroma_qp_scale)/6;
qp_rem = (qp_c + img->bitdepth_chroma_qp_scale)%6;
q_bits = Q_BITS+qp_per;
if (img->type == I_SLICE)
qp_const=(1<<q_bits)/3; // intra
else
qp_const=(1<<q_bits)/6; // inter
// Horizontal transform
if(!lossless_qpprime)
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]);
img->m7[2][j]=(m5[0]-m5[1]);
img->m7[1][j]=m5[3]*2+m5[2];
img->m7[3][j]=m5[3]-m5[2]*2;
}
// Vertical transform
if(!lossless_qpprime)
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]);
img->m7[i][2]=(m5[0]-m5[1]);
img->m7[i][1]=m5[3]*2+m5[2];
img->m7[i][3]=m5[3]-m5[2]*2;
}
// Quant
nonzeroAC=FALSE;
run=-1;
scan_pos=0;
if(lossless_qpprime)
level = abs(img->m7[0][0]);
else if(intra == 1)
level =(abs(img->m7[0][0]) * LevelScale4x4Chroma_Intra[uv][qp_rem][0][0] + qp_const) >> q_bits;
else
level =(abs(img->m7[0][0]) * LevelScale4x4Chroma_Inter[uv][qp_rem][0][0] + qp_const) >> q_bits;
b8 -= 4*(uv+1);
dc_level_temp[uv][2*(b8%2)+(b4%2)][2*(b8/2)+(b4/2)] = sign(level, img->m7[0][0]);
/* Inverse Quantization */
if(qp_per<4)
{
if(intra == 1)
img->m7[0][0] = sign( ((level*InvLevelScale4x4Chroma_Intra[uv][qp_rem][0][0]+(1<<(3-qp_per)))>>(4-qp_per)), img->m7[0][0]);
else
img->m7[0][0] = sign( ((level*InvLevelScale4x4Chroma_Inter[uv][qp_rem][0][0]+(1<<(3-qp_per)))>>(4-qp_per)), img->m7[0][0]);
}
else
{
if(intra == 1)
img->m7[0][0] = sign( ((level*InvLevelScale4x4Chroma_Intra[uv][qp_rem][0][0])<<(qp_per-4)), img->m7[0][0]);
else
img->m7[0][0] = sign( ((level*InvLevelScale4x4Chroma_Inter[uv][qp_rem][0][0])<<(qp_per-4)), img->m7[0][0]);
}
for (coeff_ctr=1;coeff_ctr < 16;coeff_ctr++)
{
i=SNGL_SCAN[coeff_ctr][0];
j=SNGL_SCAN[coeff_ctr][1];
run++;
ilev=0;
if(lossless_qpprime)
level = abs (img->m7[i][j]);
else if(intra == 1)
level = (abs(img->m7[i][j])*LevelScale4x4Chroma_Intra[uv][qp_rem][i][j]+qp_const)>>q_bits;
else
level = (abs(img->m7[i][j])*LevelScale4x4Chroma_Inter[uv][qp_rem][i][j]+qp_const)>>q_bits;
if (level != 0)
{
if(i||j) nonzeroAC=TRUE;
ACLevel[scan_pos] = sign(level,img->m7[i][j]);
ACRun [scan_pos] = run;
++scan_pos;
run=-1; // reset zero level counter
level=sign(level, img->m7[i][j]);
if(lossless_qpprime){
ilev=level;
}
else if(qp_per<4)
{
if(intra == 1)
ilev=(level*InvLevelScale4x4Chroma_Intra[uv][qp_rem][i][j]+(1<<(3-qp_per)))>>(4-qp_per);
else
ilev=(level*InvLevelScale4x4Chroma_Inter[uv][qp_rem][i][j]+(1<<(3-qp_per)))>>(4-qp_per);
}
else
{
if(intra == 1)
ilev=(level*InvLevelScale4x4Chroma_Intra[uv][qp_rem][i][j])<<(qp_per-4);
else
ilev=(level*InvLevelScale4x4Chroma_Inter[uv][qp_rem][i][j])<<(qp_per-4);
}
}
if(!lossless_qpprime)
img->m7[i][j]=ilev;
}
ACLevel[scan_pos] = 0;
// IDCT.
// horizontal
if(!lossless_qpprime)
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]);
m6[1]=(m5[0]-m5[2]);
m6[2]=(m5[1]>>1)-m5[3];
m6[3]=m5[1]+(m5[3]>>1);
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
if(!lossless_qpprime)
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]);
m6[1]=(m5[0]-m5[2]);
m6[2]=(m5[1]>>1)-m5[3];
m6[3]=m5[1]+(m5[3]>>1);
for (j=0; j < 2; j++)
{
j1=3-j;
img->m7[i][j] =(m6[j]+m6[j1]+DQ_ROUND)>>DQ_BITS;
img->m7[i][j1]=(m6[j]-m6[j1]+DQ_ROUND)>>DQ_BITS;
}
}
return nonzeroAC;
}
// Residue Color Transform
int dct_chroma_DC(int uv, int cr_cbp)
{
int run, scan_pos, coeff_ctr, level, i, j;
int* DCLevel = img->cofDC[uv+1][0];
int* DCRun = img->cofDC[uv+1][1];
run=-1;
scan_pos=0;
for (coeff_ctr=0; coeff_ctr < 16; coeff_ctr++)
{
i=SNGL_SCAN[coeff_ctr][0];
j=SNGL_SCAN[coeff_ctr][1];
run++;
level = abs(dc_level[uv][i][j]);
if (level != 0)
{
cr_cbp=max(1,cr_cbp);
DCLevel[scan_pos] = sign(level ,dc_level[uv][i][j]);
DCRun [scan_pos] = run;
scan_pos++;
run=-1;
}
}
DCLevel[scan_pos] = 0;
return cr_cbp;
}
/*!
************************************************************************
* \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.
*
* \par Input:
* block_x,block_y: Block position inside a macro block (0,4,8,12).
*
* \par Output:
* nonzero: 0 if no levels are nonzero. 1 if there are nonzero levels. \n
* coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
*
*
************************************************************************
*/
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;
int qp_const,level,scan_pos,run;
int nonzero;
int predicted_block[BLOCK_SIZE][BLOCK_SIZE],c_err,qp_const2;
int qp_per,qp_rem,q_bits;
int qp_per_sp,qp_rem_sp,q_bits_sp;
int pos_x = block_x/BLOCK_SIZE;
int pos_y = block_y/BLOCK_SIZE;
int b8 = 2*(pos_y/2) + (pos_x/2);
int b4 = 2*(pos_y%2) + (pos_x%2);
int* ACLevel = img->cofAC[b8][b4][0];
int* ACRun = img->cofAC[b8][b4][1];
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
// For encoding optimization
int c_err1, c_err2, level1, level2;
double D_dis1, D_dis2;
int len, info;
double lambda_mode = 0.85 * pow (2, (currMB->qp - SHIFT_QP)/3.0) * 4;
qp_per = (currMB->qp-MIN_QP)/6;
qp_rem = (currMB->qp-MIN_QP)%6;
q_bits = Q_BITS+qp_per;
qp_per_sp = (currMB->qpsp-MIN_QP)/6;
qp_rem_sp = (currMB->qpsp-MIN_QP)%6;
q_bits_sp = Q_BITS+qp_per_sp;
qp_const=(1<<q_bits)/6; // inter
qp_const2=(1<<q_bits_sp)/2; //sp_pred
// 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]);
img->m7[2][j]=(m5[0]-m5[1]);
img->m7[1][j]=m5[3]*2+m5[2];
img->m7[3][j]=m5[3]-m5[2]*2;
}
// Vertical 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[⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -