📄 block.c
字号:
img->mprr[HOR_DOWN_PRED][3][0] = (P_K + P_L + 1) >> 1;
img->mprr[HOR_DOWN_PRED][3][1] = (P_J + 2*P_K + P_L + 2) >> 2;
}
}
/*!
************************************************************************
* \brief
* 16x16 based luma prediction
*
* \par Input:
* Image parameters
*
* \par Output:
* none
************************************************************************
*/
void intrapred_luma_16x16()
{
int s0=0,s1,s2;
imgpel s[2][16];
int i,j;
int ih,iv;
int ib,ic,iaa;
imgpel **imgY_pred = enc_picture->imgY; // For Mb level field/frame coding tools -- default to frame pred
int mb_nr = img->current_mb_nr;
PixelPos up; //!< pixel position p(0,-1)
PixelPos left[17]; //!< pixel positions p(-1, -1..15)
int up_avail, left_avail, left_up_avail;
for (i=0;i<17;i++)
{
getNeighbour(mb_nr, -1, i-1, 1, &left[i]);
}
getNeighbour(mb_nr, 0, -1, 1, &up);
if (!(input->UseConstrainedIntraPred))
{
up_avail = up.available;
left_avail = left[1].available;
left_up_avail = left[0].available;
}
else
{
up_avail = up.available ? img->intra_block[up.mb_addr] : 0;
for (i=1, left_avail=1; i<17;i++)
left_avail &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
}
s1=s2=0;
// make DC prediction
if (up_avail)
{
for (i=0; i < MB_BLOCK_SIZE; i++)
s1 += imgY_pred[up.pos_y][up.pos_x+i]; // sum hor pix
}
if (left_avail)
{
for (i=0; i < MB_BLOCK_SIZE; i++)
s2 += imgY_pred[left[i+1].pos_y][left[i+1].pos_x]; // sum vert pix
}
if (up_avail && left_avail)
s0=(s1+s2+16)/(2*MB_BLOCK_SIZE); // no edge
if (!up_avail && left_avail)
s0=(s2+8)/MB_BLOCK_SIZE; // upper edge
if (up_avail && !left_avail)
s0=(s1+8)/MB_BLOCK_SIZE; // left edge
if (!up_avail && !left_avail)
s0=img->dc_pred_value_luma; // top left corner, nothing to predict from
// vertical prediction
if (up_avail)
memcpy(s[0], &imgY_pred[up.pos_y][up.pos_x], MB_BLOCK_SIZE * sizeof(imgpel));
// horizontal prediction
if (left_avail)
{
for (i=0; i < MB_BLOCK_SIZE; i++)
s[1][i]=imgY_pred[left[i+1].pos_y][left[i+1].pos_x];
}
for (j=0; j < MB_BLOCK_SIZE; j++)
{
memcpy(img->mprr_2[VERT_PRED_16][j], s[0], MB_BLOCK_SIZE * sizeof(imgpel)); // store vertical prediction
for (i=0; i < MB_BLOCK_SIZE; i++)
{
img->mprr_2[HOR_PRED_16 ][j][i]=s[1][j]; // store horizontal prediction
img->mprr_2[DC_PRED_16 ][j][i]=s0; // store DC prediction
}
}
if (!up_avail || !left_avail || !left_up_avail) // edge
return;
// 16 bit integer plan pred
ih=0;
iv=0;
for (i=1;i<9;i++)
{
if (i<8)
ih += i*(imgY_pred[up.pos_y][up.pos_x+7+i] - imgY_pred[up.pos_y][up.pos_x+7-i]);
else
ih += i*(imgY_pred[up.pos_y][up.pos_x+7+i] - imgY_pred[left[0].pos_y][left[0].pos_x]);
iv += i*(imgY_pred[left[8+i].pos_y][left[8+i].pos_x] - imgY_pred[left[8-i].pos_y][left[8-i].pos_x]);
}
ib=(5*ih+32)>>6;
ic=(5*iv+32)>>6;
iaa=16*(imgY_pred[up.pos_y][up.pos_x+15]+imgY_pred[left[16].pos_y][left[16].pos_x]);
for (j=0;j< MB_BLOCK_SIZE;j++)
{
for (i=0;i< MB_BLOCK_SIZE;i++)
{
img->mprr_2[PLANE_16][j][i]=max(0,min((int)img->max_imgpel_value,(iaa+(i-7)*ib +(j-7)*ic + 16)/32));// store plane prediction
}
}
}
#ifdef RDO_Q //TREL_CAVLC
typedef struct TRELLISNODE
{
int level;
int level_idx;
struct TRELLISNODE *prev;
} TrellisNode;
int estCAVLCbits (int m4[4][4], int level_to_enc[16], int nnz, int block_type, int b8, int b4, int param);
int predict_nnz(int i,int j);
int predict_nnz_chroma(int i,int j);
int cmp(const void *arg1, const void *arg2)
{
return (int)(((levelDataStruct *)arg2)->levelDouble - ((levelDataStruct *)arg1)->levelDouble);
}
void TrellisCAVLC_Q(int m4[4][4], levelDataStruct *levelData, int *levelTrellis, int block_type, int b8, int b4, int coeff_num, double lambda)
{
int k, lastnonzero, coeff_ctr, dumb=0;
int level_to_enc[16];
int subblock_x, subblock_y, nnz;
int cstat, bestcstat=0;
int nz_coeff=0;
double lagr, lagrAcc, minlagr=0;
if(block_type == CHROMA_AC)
{
static unsigned char chroma_ac_param[3][8][4] =
{
{{ 4, 20, 5, 21},
{36, 52, 37, 53},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0}},
{{ 4, 20, 5, 21},
{ 6, 22, 7, 23},
{36, 52, 37, 53},
{38, 54, 39, 55},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0},
{ 0, 0, 0, 0}},
{{ 4, 20, 5, 21},
{36, 52, 37, 53},
{ 6, 22, 7, 23},
{38, 54, 39, 55},
{ 8, 24, 9, 25},
{40, 56, 41, 57},
{10, 26, 11, 27},
{42, 58, 43, 59}}
};
int param = chroma_ac_param[img->yuv_format-1][b8][b4];
// chroma AC
subblock_x = param >> 4;
subblock_y = param & 15;
nnz = predict_nnz_chroma(subblock_x,subblock_y);
}
else
{
subblock_x = ((b8&0x1)==0)?(((b4&0x1)==0)?0:1):(((b4&0x1)==0)?2:3);
// horiz. position for coeff_count context
subblock_y = (b8<2)?((b4<2)?0:1):((b4<2)?2:3);
// vert. position for coeff_count context
nnz = predict_nnz(subblock_x,subblock_y);
}
lastnonzero = -1;
lagrAcc=0;
for (coeff_ctr=0;coeff_ctr < coeff_num;coeff_ctr++)
{
levelTrellis[coeff_ctr] = 0;
for(k=0; k<levelData[coeff_ctr].noLevels; k++)
{
levelData[coeff_ctr].errLevel[k] /= 32768;
}
lagrAcc += levelData[coeff_ctr].errLevel[levelData[coeff_ctr].noLevels-1];
level_to_enc[coeff_ctr] = levelData[coeff_ctr].pre_level;
if(levelData[coeff_ctr].noLevels > 1)
{
levelData[coeff_ctr].coeff_ctr = coeff_ctr;
lastnonzero = coeff_ctr;
}
}
if(lastnonzero != -1)
{
//sort the coefficients based on their absolute value
qsort(levelData, lastnonzero+1, sizeof(levelDataStruct), cmp);
for(coeff_ctr=lastnonzero; coeff_ctr>=0; coeff_ctr--) // go over all coeff
{
if(levelData[coeff_ctr].noLevels == 1)
continue;
lagrAcc -= levelData[coeff_ctr].errLevel[levelData[coeff_ctr].noLevels-1];
for(cstat=0; cstat<levelData[coeff_ctr].noLevels; cstat++) // go over all states of cur coeff k
{
level_to_enc[levelData[coeff_ctr].coeff_ctr] = (int) levelData[coeff_ctr].level[cstat];
lagr = lagrAcc + levelData[coeff_ctr].errLevel[cstat];
lagr += lambda*estCAVLCbits(m4, level_to_enc, nnz, block_type, b8, b4, dumb);
if(cstat==0 || lagr<minlagr)
{
minlagr = lagr;
bestcstat = cstat;
}
}
lagrAcc += levelData[coeff_ctr].errLevel[bestcstat];
level_to_enc[levelData[coeff_ctr].coeff_ctr] = (int)levelData[coeff_ctr].level[bestcstat];
}
for(coeff_ctr=0; coeff_ctr<=lastnonzero; coeff_ctr++)
{
levelTrellis[coeff_ctr] = level_to_enc[coeff_ctr];
if(level_to_enc[coeff_ctr] != 0)
nz_coeff++;
}
}
img->nz_coeff [img->current_mb_nr ][subblock_x][subblock_y] = nz_coeff;
}
void TrellisCAVLC4x4(int m4[4][4], int q_bits, int qp_rem, int **levelscale, int **leveloffset, int *levelTrellis, int block_type, int b8, int b4, int coeff_num, double lambda)
{
levelDataStruct levelData[16];
#ifdef INTERNAL_BIT_DEPTH_INCREASE
double normFact=pow(2,(2*DQ_BITS+19))*(1<<(2*img->BitDepthIncrease));
#else
double normFact=pow(2,(2*DQ_BITS+19));
#endif
double err;
int i, j, ii, coeff_ctr, lowerInt, noCoeff;
int level;
const byte (*pos_scan)[2] = SNGL_SCAN;
noCoeff=0;
for (coeff_ctr=0;coeff_ctr < coeff_num;coeff_ctr++)
{
if(block_type == LUMA_INTRA16x16AC || block_type == CHROMA_AC)
{
i=pos_scan[coeff_ctr+1][0]; // scan is shifted due to DC
j=pos_scan[coeff_ctr+1][1]; // scan is shifted due to DC
}
else
{
i=pos_scan[coeff_ctr][0];
j=pos_scan[coeff_ctr][1];
}
levelData[coeff_ctr].levelDouble=absm(m4[j][i]*levelscale[i][j]);
level=(int)(levelData[coeff_ctr].levelDouble>>q_bits);
lowerInt=(((int)levelData[coeff_ctr].levelDouble-(level<<q_bits))<(1<<(q_bits-1)))? 1 : 0;
levelData[coeff_ctr].level[0]=0;
if (level==0 && lowerInt==1)
{
levelData[coeff_ctr].noLevels=1;
}
else if (level==0 && lowerInt==0)
{
levelData[coeff_ctr].level[1] = level+1;
levelData[coeff_ctr].noLevels=2;
}
else if (level>0 && lowerInt==1)
{
if(level > 1)
{
levelData[coeff_ctr].level[1] = level-1;
levelData[coeff_ctr].level[2] = level;
levelData[coeff_ctr].noLevels=3;
}
else
{
levelData[coeff_ctr].level[1] = level;
levelData[coeff_ctr].noLevels=2;
}
}
else
{
levelData[coeff_ctr].level[1] = level;
levelData[coeff_ctr].level[2] = level+1;
levelData[coeff_ctr].noLevels=3;
}
for (ii=0; ii<levelData[coeff_ctr].noLevels; ii++)
{
err=(double)(levelData[coeff_ctr].level[ii]<<q_bits)-(double)levelData[coeff_ctr].levelDouble;
levelData[coeff_ctr].errLevel[ii]=(err*err*(double)estErr4x4[qp_rem][i][j])/normFact;
}
if(levelData[coeff_ctr].noLevels == 1)
levelData[coeff_ctr].pre_level = 0;
else
levelData[coeff_ctr].pre_level = (absm (m4[j][i]) * levelscale[i][j] + leveloffset[i][j]) >> q_bits;
}
TrellisCAVLC_Q(m4, levelData, levelTrellis, block_type, b8, b4, coeff_num, lambda);
}
#endif
/*!
************************************************************************
* \brief
* For new intra pred routines
*
* \par Input:
* Image par, 16x16 based intra mode
*
* \par Output:
* none
************************************************************************
*/
int dct_luma_16x16(int new_intra_mode)
{
//int qp_const;
int i,j;
int ii,jj;
int jdiv, jmod;
int M1[16][16];
int M4[4][4];
int M5[4],M6[4];
int M0[4][4][4][4];
int run,scan_pos,coeff_ctr,level;
int qp_per,qp_rem,q_bits;
int ac_coef = 0;
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
short is_field_mode = (img->field_picture || ( img->MbaffFrameFlag && currMB->mb_field));
int b8, b4;
int* DCLevel = img->cofDC[0][0];
int* DCRun = img->cofDC[0][1];
int* ACLevel;
int* ACRun;
int **levelscale,**leveloffset;
int **invlevelscale;
Boolean lossless_qpprime = (Boolean)((currMB->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
const byte (*pos_scan)[2] = is_field_mode ? FIELD_SCAN : SNGL_SCAN;
#ifdef RDO_Q
levelDataStruct levelData[16];
double lambda_md=0;
#ifdef INTERNAL_BIT_DEPTH_INCREASE
double normFact = pow(2, (2 * DQ_BITS + 19))*(1<<(2*img->BitDepthIncrease));
#else
double normFact = pow(2, (2 * DQ_BITS + 19));
#endif
double err;
int lowerInt, levelTrellis[16], k, kStart, kStop, noCoeff, estBits;
#endif
// Note that we could just use currMB->qp here
qp_per = qp_per_matrix[(currMB->qp + img->bitdepth_luma_qp_scale - MIN_QP)];
qp_rem = qp_rem_matrix[(currMB->qp + img->bitdepth_luma_qp_scale - MIN_QP)];
q_bits = Q_BITS+qp_per;
#ifdef RDO_Q
if(input->UseRDO_Q)
{
if ((img->type==B_SLICE) && img->nal_reference_idc)
{
lambda_md = img->lambda_md[5][img->masterQP];
}
else
{
lambda_md = img->lambda_md[img->type][img->masterQP];
}
}
#endif
#ifdef ADAPTIVE_QUANTIZATION
if(img->slice_fractional_quant_flag)
{
levelscale = LevelScale4x4Luma_IAQMS[img->mb_iaqms_idx][1][qp_rem];
invlevelscale = InvLevelScale4x4Luma_IAQMS[img->mb_iaqms_idx][1][qp_rem];
}
else
{
levelscale = LevelScale4x4Luma[1][qp_rem];
invlevelscale = InvLevelScale4x4Luma[1][qp_rem];
}
leveloffset = LevelOffset4x4Luma[1][qp_per];
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -