📄 macroblock.c
字号:
for (block8x8=0; block8x8<4; block8x8++)
{
int bw_ref;
SetModesAndRefframe (block8x8, &p_dir, &fw_mode, &bw_mode, &refframe, &bw_ref);
sum_cnt_nonz += LumaResidualCoding8x8 (&(currMB->cbp), &(currMB->cbp_blk), block8x8,
p_dir, fw_mode, bw_mode, refframe, bw_ref);
}
if (sum_cnt_nonz <= 5 )
{
currMB->cbp &= 0xfffff0 ;
currMB->cbp_blk &= 0xff0000 ;
for (i=0; i < MB_BLOCK_SIZE; i++)
{
for (j=0; j < MB_BLOCK_SIZE; j++)
{
enc_picture->imgY[img->pix_y+j][img->pix_x+i]=img->mpr[i][j];
}
}
if (img->type==SP_SLICE)
{
for(block8x8=0;block8x8<4;block8x8++)
{
b8_x=(block8x8&1)<<3;
b8_y=(block8x8&2)<<2;
for (i=0;i<8;i+=4)
for (j=0;j<8;j+=4)
copyblock_sp(b8_x+i,b8_y+j);
}
}
}
}
/*!
************************************************************************
* \brief
* Predict one component of a chroma 4x4 block
************************************************************************
*/
void
OneComponentChromaPrediction4x4 (int* mpred, //!< array to store prediction values
int block_c_x, //!< horizontal pixel coordinate of 4x4 block
int block_c_y, //!< vertical pixel coordinate of 4x4 block
int****** mv, //!< motion vector array
int list_idx, //!< reference picture list
int ref, //!< reference index
int blocktype, //!< block type
int uv) //!< chroma component
{
int i, j, ii, jj, ii0, jj0, ii1, jj1, if0, if1, jf0, jf1;
int* mvb;
pel_t** refimage;
int f1 = 8 , f2=f1-1, f3=f1*f1, f4=f3>>1;
int s1 = 3;
int list_offset;
int max_y_cr;
StorablePicture **list;
int curr_mb_field = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field));
// find out the correct list offsets
if (curr_mb_field)
{
if(img->current_mb_nr%2)
list_offset = 4; // top field mb
else
list_offset = 2; // bottom field mb
max_y_cr = img->height_cr/2-1;
}
else
{
list_offset = 0; // no mb aff or frame mb
max_y_cr = img->height_cr-1;
}
list = listX[list_idx + list_offset];
refimage = list[ref]->imgUV[uv];
for (j=0; j<4; j++)
for (i=0; i<4; i++)
{
//ref_idx = enc_picture->ref_idx[list_idx][(img->pix_c_x + block_c_x)>>1][(img->pix_c_y + block_c_y)>>1];
mvb = mv [(i+block_c_x)>>1][(j+block_c_y)>>1][list_idx][ref][blocktype];
ii = ((i+block_c_x+img->opix_c_x)<<s1) + mvb[0];
jj = ((j+block_c_y+img->opix_c_y)<<s1) + mvb[1];
jj += list[ref]->chroma_vector_adjustment;
ii0 = max (0, min (img->width_cr -1, ii>>s1 ));
jj0 = max (0, min (max_y_cr, jj>>s1 ));
ii1 = max (0, min (img->width_cr -1, (ii>>s1)+1));
jj1 = max (0, min (max_y_cr, (jj>>s1)+1));
if1 = (ii&f2); if0 = f1-if1;
jf1 = (jj&f2); jf0 = f1-jf1;
*mpred++ = (if0 * jf0 * refimage[jj0][ii0] +
if1 * jf0 * refimage[jj0][ii1] +
if0 * jf1 * refimage[jj1][ii0] +
if1 * jf1 * refimage[jj1][ii1] + f4) >> 6;
}
}
/*!
************************************************************************
* \brief
* Predict an intra chroma 4x4 block
************************************************************************
*/
void IntraChromaPrediction4x4 (int uv, // <-- colour component
int block_x, // <-- relative horizontal block coordinate of 4x4 block
int block_y) // <-- relative vertical block coordinate of 4x4 block
{
int mode = img->mb_data[img->current_mb_nr].c_ipred_mode;
int i, j;
//===== prediction =====
for (j=block_y; j<block_y+4; j++)
for (i=block_x; i<block_x+4; i++)
{
img->mpr[i][j] = img->mprr_c[uv][mode][i][j];
}
}
/*!
************************************************************************
* \brief
* Predict one chroma 4x4 block
************************************************************************
*/
void
ChromaPrediction4x4 (int uv, // <-- colour component
int block_x, // <-- relative horizontal block coordinate of 4x4 block
int block_y, // <-- relative vertical block coordinate of 4x4 block
int p_dir, // <-- prediction direction
int fw_mode, // <-- forward prediction mode (1-7, 0=DIRECT if bw_mode=0)
int bw_mode, // <-- backward prediction mode (1-7, 0=DIRECT if fw_mode=0)
int fw_ref_idx, // <-- reference frame for forward prediction (if (<0) -> intra prediction)
int bw_ref_idx) // <-- reference frame for backward prediction
{
static int fw_pred[16];
static int bw_pred[16];
int i, j;
int block_x4 = block_x+4;
int block_y4 = block_y+4;
int* fpred = fw_pred;
int* bpred = bw_pred;
int****** mv_array = img->all_mv;
//int apply_weights = ( (input->WeightedPrediction && (img->type == P_SLICE||img->type == SP_SLICE)) ||
// (input->WeightedBiprediction && (img->type == B_SLICE)));
int apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
(active_pps->weighted_bipred_idc && (img->type == B_SLICE)));
//===== INTRA PREDICTION =====
if (p_dir==-1)
{
IntraChromaPrediction4x4 (uv, block_x, block_y);
return;
}
//===== INTER PREDICTION =====
if ((p_dir==0) || (p_dir==2))
{
OneComponentChromaPrediction4x4 (fw_pred, block_x, block_y, mv_array, LIST_0, fw_ref_idx, fw_mode, uv);
}
if ((p_dir==1) || (p_dir==2))
{
OneComponentChromaPrediction4x4 (bw_pred, block_x, block_y, mv_array, LIST_1, bw_ref_idx, bw_mode, uv);
}
if (apply_weights)
{
if (p_dir==2)
{
for (j=block_y; j<block_y4; j++)
for (i=block_x; i<block_x4; i++)
img->mpr[i][j] = clip1a(((wbp_weight[0][fw_ref_idx][bw_ref_idx][uv+1] * *fpred++ + wbp_weight[1][fw_ref_idx][bw_ref_idx][uv+1] * *bpred++
+ 2*wp_chroma_round) >> (chroma_log_weight_denom + 1)) + ((wp_offset[0][fw_ref_idx][uv+1] + wp_offset[1][bw_ref_idx][uv+1] + 1)>>1) );
}
else if (p_dir==0)
{
for (j=block_y; j<block_y4; j++)
for (i=block_x; i<block_x4; i++)
img->mpr[i][j] = clip1a(((wp_weight[0][fw_ref_idx][uv+1] * *fpred++ + wp_chroma_round) >> chroma_log_weight_denom) + wp_offset[0][fw_ref_idx][uv+1]);
}
else // (p_dir==1)
{
for (j=block_y; j<block_y4; j++)
for (i=block_x; i<block_x4; i++)
img->mpr[i][j] = clip1a(((wp_weight[1][bw_ref_idx][uv+1] * *bpred++ + wp_chroma_round) >> chroma_log_weight_denom) + wp_offset[1][bw_ref_idx][uv+1]);
}
}
else
{
if (p_dir==2)
{
for (j=block_y; j<block_y4; j++)
for (i=block_x; i<block_x4; i++)
img->mpr[i][j] = (*fpred++ + *bpred++ + 1) / 2;
}
else if (p_dir==0)
{
for (j=block_y; j<block_y4; j++)
for (i=block_x; i<block_x4; i++) img->mpr[i][j] = *fpred++;
}
else // (p_dir==1)
{
for (j=block_y; j<block_y4; j++)
for (i=block_x; i<block_x4; i++) img->mpr[i][j] = *bpred++;
}
}
}
/*!
************************************************************************
* \brief
* Chroma residual coding for an macroblock
************************************************************************
*/
void ChromaResidualCoding (int* cr_cbp)
{
int uv, block8, block_y, block_x, j, i;
int p_dir, fw_mode, bw_mode, refframe;
int skipped = (img->mb_data[img->current_mb_nr].mb_type == 0 && (img->type == P_SLICE || img->type == SP_SLICE));
int bw_ref;
for (*cr_cbp=0, uv=0; uv<2; uv++)
{
//===== prediction of chrominance blocks ===d==
block8 = 0;
for (block_y=0; block_y<8; block_y+=4)
for (block_x=0; block_x<8; block_x+=4, block8++)
{
SetModesAndRefframe (block8, &p_dir, &fw_mode, &bw_mode, &refframe, &bw_ref);
ChromaPrediction4x4 (uv, block_x, block_y, p_dir, fw_mode, bw_mode, refframe, bw_ref);
}
// ==== set chroma residue to zero for skip Mode in SP frames
if (img->NoResidueDirect)
{
for (j=0; j<8; j++)
for (i=0; i<8; i++)
{
enc_picture->imgUV[uv][img->pix_c_y+j][img->pix_c_x+i] = img->mpr[i][j];
}
}
else
if (skipped && img->type==SP_SLICE)
{
for (j=0; j<8; j++)
for (i=0; i<8; i++)
{
img->m7[i][j] = 0;
}
}
else
if (skipped)
{
for (j=0; j<8; j++)
for (i=0; i<8; i++)
{
enc_picture->imgUV[uv][img->pix_c_y+j][img->pix_c_x+i] = img->mpr[i][j];
}
}
else
{
for (j=0; j<8; j++)
for (i=0; i<8; i++)
{
img->m7[i][j] = imgUV_org[uv][img->opix_c_y+j][img->opix_c_x+i] - img->mpr[i][j];
}
}
//===== DCT, Quantization, inverse Quantization, IDCT, and Reconstruction =====
//===== Call function for skip mode in SP frames to properly process frame ====
if (skipped && img->type==SP_SLICE)
{
*cr_cbp=dct_chroma_sp(uv,*cr_cbp);
}
else
{
if (!img->NoResidueDirect && !skipped)
{
if (img->type!=SP_SLICE || IS_INTRA (&img->mb_data[img->current_mb_nr]))
*cr_cbp=dct_chroma (uv,*cr_cbp);
else
*cr_cbp=dct_chroma_sp(uv,*cr_cbp);
}
}
}
//===== update currMB->cbp =====
img->mb_data[img->current_mb_nr].cbp += ((*cr_cbp)<<4);
}
/*!
************************************************************************
* \brief
* Predict an intra chroma 8x8 block
************************************************************************
*/
void IntraChromaPrediction8x8 (int *mb_up, int *mb_left, int*mb_up_left)
{
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
int s, s0, s1, s2, s3, i, j, k;
pel_t** image;
int block_x, block_y;
int mb_nr = img->current_mb_nr;
int mb_available_up;
int mb_available_left[2];
int mb_available_up_left;
int ih,iv;
int ib,ic,iaa;
int uv;
int hline[8], vline[9];
int mode;
int best_mode = DC_PRED_8; //just an initilaization here, should always be overwritten
int cost;
int min_cost;
int diff[16];
PixelPos up; //!< pixel position p(0,-1)
PixelPos left[9]; //!< pixel positions p(-1, -1..8)
for (i=0;i<9;i++)
{
getNeighbour(mb_nr, -1 , i-1 , 0, &left[i]);
}
getNeighbour(mb_nr, 0 , -1 , 0, &up);
mb_available_up = up.available;
mb_available_up_left = left[0].available;
mb_available_left[0] = mb_available_left[1] = left[1].available;
if(input->UseConstrainedIntraPred)
{
mb_available_up = up.available ? img->intra_block[up.mb_addr] : 0;
for (i=1, mb_available_left[0]=1; i<5;i++)
mb_available_left[0] &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
for (i=5, mb_available_left[1]=1; i<9;i++)
mb_available_left[1] &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
mb_available_up_left = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
}
if (mb_up)
*mb_up = mb_available_up;
if (mb_left)
*mb_left = mb_available_left[0] && mb_available_left[1];
if( mb_up_left )
*mb_up_left = mb_available_up_left;
// compute all chroma intra prediction modes for both U and V
for (uv=0; uv<2; uv++)
{
image = enc_picture->imgUV[uv];
// DC prediction
for (block_y=0; block_y<8; block_y+=4)
for (block_x=0; block_x<8; block_x+=4)
{
s=128;
s0=s1=s2=s3=0;
//===== get prediction value =====
switch ((block_y>>1) + (block_x>>2))
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -