📄 rdopt.c
字号:
int pic_block_y = pic_pix_y/4;
double min_rdcost = 1e30;
int left_available, up_available, all_available;
int upMode;
int leftMode;
int mostProbableMode;
PixelPos left_block;
PixelPos top_block;
getLuma4x4Neighbour(img->current_mb_nr, block_x/4, block_y/4, -1, 0, &left_block);
getLuma4x4Neighbour(img->current_mb_nr, block_x/4, block_y/4, 0, -1, &top_block);
// constrained intra pred
if (input->UseConstrainedIntraPred)
{
left_block.available = left_block.available ? img->intra_block[left_block.mb_addr] : 0;
top_block.available = top_block.available ? img->intra_block[top_block.mb_addr] : 0;
}
upMode = top_block.available ? img->ipredmode[top_block.pos_x ][top_block.pos_y ] : -1;
leftMode = left_block.available ? img->ipredmode[left_block.pos_x][left_block.pos_y] : -1;
mostProbableMode = (upMode < 0 || leftMode < 0) ? DC_PRED : upMode < leftMode ? upMode : leftMode;
*min_cost = (1<<20);
//===== INTRA PREDICTION FOR 4x4 BLOCK =====
intrapred_luma (pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
//===== LOOP OVER ALL 4x4 INTRA PREDICTION MODES =====
for (ipmode=0; ipmode<NO_INTRA_PMODE; ipmode++)
{
int available_mode = (ipmode==DC_PRED) ||
((ipmode==VERT_PRED||ipmode==VERT_LEFT_PRED||ipmode==DIAG_DOWN_LEFT_PRED) && up_available ) ||
((ipmode==HOR_PRED||ipmode==HOR_UP_PRED) && left_available ) ||(all_available);
if( available_mode)
{
if (!input->rdopt)
{
for (k=j=0; j<4; j++)
for (i=0; i<4; i++, k++)
{
diff[k] = imgY_org[pic_opix_y+j][pic_opix_x+i] - img->mprr[ipmode][j][i];
}
cost = (ipmode == mostProbableMode) ? 0 : (int)floor(4 * lambda );
cost += SATD (diff, input->hadamard);
if (cost < *min_cost)
{
best_ipmode = ipmode;
*min_cost = cost;
}
}
else
{
// get prediction and prediction error
for (j=0; j<4; j++)
for (i=0; i<4; i++)
{
img->mpr[block_x+i][block_y+j] = img->mprr[ipmode][j][i];
img->m7[i][j] = imgY_org[pic_opix_y+j][pic_opix_x+i] - img->mprr[ipmode][j][i];
}
//===== store the coding state =====
store_coding_state (cs_cm);
// get and check rate-distortion cost
if ((rdcost = RDCost_for_4x4IntraBlocks (&c_nz, b8, b4, ipmode, lambda, min_rdcost, mostProbableMode)) < min_rdcost)
{
//--- set coefficients ---
for (j=0; j<2; j++)
for (i=0; i<18;i++) cofAC4x4[j][i]=img->cofAC[b8][b4][j][i];
//--- set reconstruction ---
for (y=0; y<4; y++)
for (x=0; x<4; x++) rec4x4[y][x] = enc_picture->imgY[pic_pix_y+y][pic_pix_x+x];
//--- flag if dct-coefficients must be coded ---
nonzero = c_nz;
//--- set best mode update minimum cost ---
min_rdcost = rdcost;
best_ipmode = ipmode;
}
reset_coding_state (cs_cm);
}
}
}
//===== set intra mode prediction =====
img->ipredmode[pic_block_x][pic_block_y] = best_ipmode;
img->mb_data[img->current_mb_nr].intra_pred_modes[4*b8+b4] = mostProbableMode == best_ipmode ? -1 : best_ipmode < mostProbableMode ? best_ipmode : best_ipmode-1;
if (!input->rdopt)
{
// get prediction and prediction error
for (j=0; j<4; j++)
for (i=0; i<4; i++)
{
img->mpr[block_x+i][block_y+j] = img->mprr[best_ipmode][j][i];
img->m7[i][j] = imgY_org[pic_opix_y+j][pic_opix_x+i] - img->mprr[best_ipmode][j][i];
}
nonzero = dct_luma (block_x, block_y, &dummy, 1);
}
else
{
//===== restore coefficients =====
for (j=0; j<2; j++)
for (i=0; i<18;i++) img->cofAC[b8][b4][j][i]=cofAC4x4[j][i];
//===== restore reconstruction and prediction (needed if single coeffs are removed) =====
for (y=0; y<4; y++)
for (x=0; x<4; x++)
{
enc_picture->imgY[pic_pix_y+y][pic_pix_x+x] = rec4x4[y][x];
img->mpr[block_x+x][block_y+y] = img->mprr[best_ipmode][y][x];
}
}
return nonzero;
}
/*!
*************************************************************************************
* \brief
* Mode Decision for an 8x8 Intra block
*************************************************************************************
*/
int Mode_Decision_for_8x8IntraBlocks(int b8,double lambda,int *cost)
{
int nonzero=0, b4;
int cost4x4;
*cost = (int)floor(6.0 * lambda + 0.4999);
for (b4=0; b4<4; b4++)
{
if (Mode_Decision_for_4x4IntraBlocks (b8, b4, lambda, &cost4x4))
{
nonzero = 1;
}
*cost += cost4x4;
}
return nonzero;
}
/*!
*************************************************************************************
* \brief
* 4x4 Intra mode decision for an macroblock
*************************************************************************************
*/
int Mode_Decision_for_Intra4x4Macroblock (double lambda, int* cost)
{
int cbp=0, b8, cost8x8;
for (*cost=0, b8=0; b8<4; b8++)
{
if (Mode_Decision_for_8x8IntraBlocks (b8, lambda, &cost8x8))
{
cbp |= (1<<b8);
}
*cost += cost8x8;
}
return cbp;
}
/*!
*************************************************************************************
* \brief
* R-D Cost for an 8x8 Partition
*************************************************************************************
*/
double RDCost_for_8x8blocks (int* cnt_nonz, // --> number of nonzero coefficients
int* cbp_blk, // --> cbp blk
double lambda, // <-- lagrange multiplier
int block, // <-- 8x8 block number
int mode, // <-- partitioning mode
int pdir, // <-- prediction direction
int ref, // <-- reference frame
int bwd_ref) // <-- abp type
{
int i, j, k;
int rate=0, distortion=0;
int dummy, mrate;
int fw_mode, bw_mode;
int cbp = 0;
int pax = 8*(block%2);
int pay = 8*(block/2);
int i0 = pax/4;
int j0 = pay/4;
int bframe = (img->type==B_SLICE);
int direct = (bframe && mode==0);
int b8value = B8Mode2Value (mode, pdir);
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
SyntaxElement *currSE = &img->MB_SyntaxElements[currMB->currSEnr];
Slice *currSlice = img->currentSlice;
DataPartition *dataPart;
const int *partMap = assignSE2partition[input->partition_mode];
EncodingEnvironmentPtr eep_dp;
//=====
//===== GET COEFFICIENTS, RECONSTRUCTIONS, CBP
//=====
if (direct)
{
if (direct_pdir[img->block_x+i0][img->block_y+j0]<0) // mode not allowed
{
return (1e20);
}
else
{
*cnt_nonz = LumaResidualCoding8x8 (&cbp, cbp_blk, block, direct_pdir[img->block_x+i0][img->block_y+j0], 0, 0, max(0,direct_ref_idx[LIST_0][img->block_x+i0][img->block_y+j0]), direct_ref_idx[LIST_1][img->block_x+i0][img->block_y+j0]);
}
}
else
{
fw_mode = (pdir==0||pdir==2 ? mode : 0);
bw_mode = (pdir==1||pdir==2 ? mode : 0);
*cnt_nonz = LumaResidualCoding8x8 (&cbp, cbp_blk, block, pdir, fw_mode, bw_mode, ref, bwd_ref);
}
//===== get residue =====
if (input->rdopt==2 && img->type!=B_SLICE)
{
// We need the reconstructed prediction residue for the simulated decoders.
compute_residue_b8block (block, -1);
}
//=====
//===== GET DISTORTION
//=====
if (input->rdopt==2 && img->type!=B_SLICE)
{
for (k=0; k<input->NoOfDecoders ;k++)
{
decode_one_b8block (k, P8x8, block, mode, ref);
for (j=img->opix_y+pay; j<img->opix_y+pay+8; j++)
for (i=img->opix_x+pax; i<img->opix_x+pax+8; i++)
{
distortion += img->quad[imgY_org[j][i] - decs->decY[k][j][i]];
}
}
distortion /= input->NoOfDecoders;
}
else
{
for (j=pay; j<pay+8; j++)
for (i=img->pix_x+pax; i<img->pix_x+pax+8; i++)
{
distortion += img->quad [imgY_org[img->opix_y+j][i] - enc_picture->imgY[img->pix_y+j][i]];
}
}
//=====
//===== GET RATE
//=====
//----- block 8x8 mode -----
if (input->symbol_mode == UVLC)
{
ue_linfo (b8value, dummy, &mrate, &dummy);
rate += mrate;
}
else
{
currSE->value1 = b8value;
currSE->writing = writeB8_typeInfo_CABAC;
currSE->type = SE_MBTYPE;
dataPart = &(currSlice->partArr[partMap[currSE->type]]);
dataPart->writeSyntaxElement (currSE, dataPart);
rate += currSE->len;
currSE++;
currMB->currSEnr++;
}
//----- motion information -----
if (!direct)
{
if ((img->num_ref_idx_l0_active > 1 ) && (pdir==0 || pdir==2))
rate += writeReferenceFrame (mode, i0, j0, 1, ref);
if(img->num_ref_idx_l1_active > 1 && img->type== B_SLICE)
{
if (pdir==1 || pdir==2)
{
rate += writeReferenceFrame (mode, i0, j0, 0, bwd_ref);
}
}
if (pdir==0 || pdir==2)
{
rate += writeMotionVector8x8 (i0, j0, i0+2, j0+2, ref, LIST_0, mode);
}
if (pdir==1 || pdir==2)
{
rate += writeMotionVector8x8 (i0, j0, i0+2, j0+2, bwd_ref, LIST_1, mode);
}
}
//----- coded block pattern (for CABAC only) -----
if (input->symbol_mode == CABAC)
{
dataPart = &(currSlice->partArr[partMap[SE_CBP_INTER]]);
eep_dp = &(dataPart->ee_cabac);
mrate = arienco_bits_written (eep_dp);
writeCBP_BIT_CABAC (block, ((*cnt_nonz>0)?1:0), cbp8x8, currMB, 1, eep_dp);
mrate = arienco_bits_written (eep_dp) - mrate;
rate += mrate;
}
//----- luminance coefficients -----
if (*cnt_nonz)
{
rate += writeLumaCoeff8x8 (block, 0);
}
return (double)distortion + lambda * (double)rate;
}
/*!
*************************************************************************************
* \brief
* Gets mode offset for intra16x16 mode
*************************************************************************************
*/
int I16Offset (int cbp, int i16mode)
{
return (cbp&15?13:1) + i16mode + ((cbp&0x30)>>2);
}
/*!
*************************************************************************************
* \brief
* Sets modes and reference frames for an macroblock
*************************************************************************************
*/
void SetModesAndRefframeForBlocks (int mode)
{
int i,j,k,l;
Macroblock *currMB = &img->mb_data[img->current_mb_nr];
int bframe = (img->type==B_SLICE);
int list_offset = ((img->MbaffFrameFlag)&&(currMB->mb_field))? img->current_mb_nr%2 ? 4 : 2 : 0;
//--- macroblock type ---
currMB->mb_type = mode;
//--- block 8x8 mode and prediction direction ---
switch (mode)
{
case 0:
for(i=0;i<4;i++)
{
currMB->b8mode[i] = 0;
currMB->b8pdir[i] = (bframe?direct_pdir[img->block_x+(i%2)*2][img->block_y+(i/2)*2]:0);
}
break;
case 1:
case 2:
case 3:
for(i=0;i<4;i++)
{
currMB->b8mode[i] = mode;
currMB->b8pdir[i] = best8x8pdir[mode][i];
}
break;
case P8x8:
for(i=0;i<4;i++)
{
currMB->b8mode[i] = best8x8mode[i];
currMB->b8pdir[i] = best8x8pdir[mode][i];
}
break;
case I4MB:
for(i=0;i<4;i++)
{
currMB->b8mode[i] = IBLOCK;
currMB->b8pdir[i] = -1;
}
break;
case I16MB:
for(i=0;i<4;i++)
{
currMB->b8mode[i] = 0;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -