homerHEVC代码阅读（30）——帧间预测的主函数

一、帧间预测的理论知识请看 HEVC/H.265理论知识（4）——帧间预测   HEVC/H.265理论知识（10）——率失真优化

二、motion_inter_full是帧间预测的主函数，实现和理论有点区别：

1、遍历所有的深度，注意不是递归处理，而是用一个while和深度状态来替换递归，处理速度更快

2、判断PU的划分类型，注意目前HomerHEVC只支持两种划分模式：2Nx2N和NxN

3、如果划分类型是2Nx2N，那么按照下面的流程进行处理：

（1）尝试merge模式

（2）尝试skip模式

（3）尝试常规的帧间预测模式（即AMVP+运动估计、运动补偿等等）

（4）综合判断之后，选择最优的模式

4、如果划分类型是NxN，那么按照下面的流程进行处理：

（1）尝试常规的帧间预测（即AMVP+运动估计、运动补偿等等）

（2）尝试帧内预测（千万不要以为帧间预测就不会用到帧内预测，HEVC为了提高压缩率是什么事情都干得出来的）

（3）综合判断之后，选择最优的模式

uint32_t motion_inter_full(henc_thread_t* et, ctu_info_t* ctu){int gcnt = 0;picture_t *currpict = &et->enc_engine->current_pict;slice_t *currslice = &currpict->slice;// dist表示失真，cost则表示代价double dist, best_cost;//, cost_luma, cost_chroma;int position = 0;int curr_depth = 0;ctu_info_t *ctu_rd = et->ctu_rd;cu_partition_info_t*parent_part_info = NULL;cu_partition_info_t*curr_cu_info = ctu->partition_list;int depth_state[MAX_PARTITION_DEPTH] = { 0, 0, 0, 0, 0 };// 代价和，CU自己本身还有四个子CUuint cost_sum[MAX_PARTITION_DEPTH] = { 0, 0, 0, 0, 0 };int abs_index;int num_part_in_cu;double consumed_distortion = 0, avg_distortion = et->enc_engine->avg_dist;int perf_min_depth = et->enc_engine->performance_min_depth;// 是否为快速跳过模式int perf_fast_skip = et->enc_engine->performance_fast_skip_loop;#ifndef COMPUTE_AS_HMint ithreads;uint total_intra_partitions = 0, total_partitions = 0;for (ithreads = 0; ithreads < et->wfpp_num_threads; ithreads++){henc_thread_t* henc_th = et->enc_engine->thread[ithreads];consumed_distortion += henc_th->acc_dist;total_intra_partitions += henc_th->num_intra_partitions;total_partitions += henc_th->num_total_partitions;}//total_partitions = 0;if (total_partitions == 0)total_partitions = 1;if (total_partitions>10 * et->num_partitions_in_cu || total_partitions > et->enc_engine->pict_total_ctu*et->num_partitions_in_cu / 15){avg_distortion = consumed_distortion / (total_partitions);if (et->enc_engine->is_scene_change)et->enc_engine->avg_dist = avg_distortion;//update avg_dist as it evolves}//elseavg_distortion = et->enc_engine->avg_dist;if (et->index == 0 && currslice->slice_type == P_SLICE && et->enc_engine->num_encoded_frames > 1 && et->enc_engine->is_scene_change == 0 && 20 < currslice->poc - et->enc_engine->hvenc->last_gop_reinit && total_partitions > et->enc_engine->pict_total_ctu*et->num_partitions_in_cu / 10){if (total_intra_partitions > (total_partitions*.7)){hmr_rc_change_pic_mode(et, currslice);et->enc_engine->is_scene_change = 1;if (et->enc_engine->gop_reinit_on_scene_change)et->enc_engine->hvenc->last_intra = et->enc_engine->last_intra = currslice->poc;et->enc_engine->last_gop_reinit = currslice->poc;et->enc_engine->hvenc->last_gop_reinit = currslice->poc;#ifdef DBG_TRACEprintf("\r\n---------------------scene change detected. frame:%d, total_intra_partitions:%d, total_partitions:%d , enc_engine->avg_dist:%.2f, avg_distortion:%.2f, ----------------------\r\n", et->enc_engine->num_encoded_frames, total_intra_partitions, total_partitions, et->enc_engine->avg_dist, avg_distortion);#endif}}#endif//init rd auxiliar ctu// 辅助的CTU，用于计算率失真if (et->rd_mode != RD_DIST_ONLY){copy_ctu(ctu, ctu_rd);}int count = 0;while (curr_depth != 0 || depth_state[curr_depth] != 1){++count;double cost = 0, intra_cost = 0;int stop_recursion = FALSE;int is_skipped = FALSE;PartSize part_size_type = (curr_depth < et->max_pred_partition_depth) ? SIZE_2Nx2N : SIZE_NxN;int ref_list;int ref_idx;curr_depth = curr_cu_info->depth;num_part_in_cu = curr_cu_info->num_part_in_cu;abs_index = curr_cu_info->abs_index;position = curr_cu_info->list_index - et->partition_depth_start[curr_depth];//rcif (currslice->slice_type != I_SLICE && curr_depth <= et->enc_engine->qp_depth){//curr_cu_info->variance = calc_variance_cu(et, curr_cu_info);}// 注意这里的量化参数qp是根据率失真优化得来的（根据码率然后得出对应的qp），这样就能灵活的控制码率了curr_cu_info->qp = hmr_rc_get_cu_qp(et, ctu, curr_cu_info, currslice);//  Uni-directional predictionif (curr_cu_info->is_b_inside_frame && curr_cu_info->is_r_inside_frame)//if br (and tl) are inside the frame, process{int mv_cost = 0;/*** 对于2Nx2N的划分模式，按照下面的顺序进行处理：** 1、尝试merge模式** 2、尝试skip模式（一种比较特殊的模式）** 3、尝试常规帧间预测（即AMVP）** 4、然后选取最优的模式*/if (part_size_type == SIZE_2Nx2N){uint sad, merge_dist = MAX_COST, merge_cost = MAX_COST, merge_sum;motion_vector_t merge_mv0, merge_mv1;int merge_ref_idx0, merge_ref_idx1;uint merge_inter_mode;// 运动估计的精度uint motion_estimation_precision = (et->enc_engine->motion_estimation_precision * 2 - 1);//compute all precisions below the configured//encode intercurr_cu_info->prediction_mode = INTER_MODE;if (curr_cu_info->depth >= perf_min_depth)//-1){if (et->enc_engine->num_encoded_frames == 2 && ctu->ctu_number == 5 && curr_cu_info->abs_index >= 144 && curr_cu_info->depth == 2)// && curr_cu_info->abs_index>=32)// && curr_partition_info->abs_index>=192)// && curr_depth==2){int iiiiii = 0;}// 对于2Nx2N先尝试merge模式merge_dist = check_rd_cost_merge_2nx2n(et, ctu, curr_depth, position);//after this call we just need to keep the merge_idx, the motion vector is no longer needed for merge typesmerge_mv0 = curr_cu_info->inter_mv[REF_PIC_LIST_0];merge_ref_idx0 = curr_cu_info->inter_ref_index[REF_PIC_LIST_0];merge_mv1 = curr_cu_info->inter_mv[REF_PIC_LIST_1];merge_ref_idx1 = curr_cu_info->inter_ref_index[REF_PIC_LIST_1];merge_inter_mode = curr_cu_info->inter_mode;merge_sum = curr_cu_info->sum;merge_cost = merge_dist;#ifndef COMPUTE_AS_HMmerge_cost += curr_cu_info->merge_idx;merge_cost = calc_cost_full(merge_cost, curr_depth, avg_distortion);merge_cost += cost_rd(et->enc_engine->avg_dist, curr_cu_info->sum);cost = merge_cost;dist = merge_dist;if (curr_cu_info->skipped){merge_cost *= .95;}// 如果代价小于某个阈值，那表示当前块和邻近块非常相似，不需要再继续处理了，也不需要传送残差信息等给解码器，直接跳过后续处理// 就是skip模式（它是merge模式的一种特例）if ((curr_cu_info->skipped && merge_cost < avg_distortion*ctu->num_part_in_ctu / 2.5))is_skipped = TRUE;#endif}else{memset(curr_cu_info->inter_mv, 0, sizeof(curr_cu_info->inter_mv));curr_cu_info->merge_flag = FALSE;curr_cu_info->skipped = FALSE;cost = curr_cu_info->cost = merge_cost = (uint32_t)MAX_COST;dist = curr_cu_info->distortion = merge_dist = (uint32_t)MAX_COST;is_skipped = FALSE;}// 尝试正常的帧间预测（使用AMVP，然后运动估计、计算残差等等）if (curr_cu_info->depth >= perf_min_depth){if (et->enc_engine->num_encoded_frames == 2 && ctu->ctu_number == 2 && curr_cu_info->depth == 1)// && curr_cu_info->abs_index>=32)// && curr_partition_info->abs_index>=192)// && curr_depth==2){int iiiiii = 0;}// 如果是skip模式，那么表示处理已经完成；否则需要继续处理if (!is_skipped)sad = hmr_cu_motion_estimation(et, ctu, gcnt, curr_depth, position,SIZE_2Nx2N, 2 * curr_cu_info->size*curr_cu_info->size, motion_estimation_precision);//(MOTION_PEL_MASK|MOTION_HALF_PEL_MASK|MOTION_QUARTER_PEL_MASK));//.25*avg_distortion*curr_cu_info->num_part_in_cu);#ifdef COMPUTE_AS_HMmv_cost = predict_inter(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);/*if(check_unidirectional_motion(currslice, curr_cu_info)){mv_cost = predict_inter_uni(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);//.25*avg_distortion*curr_cu_info->num_part_in_cu);}else{mv_cost = predict_inter_bi(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);//.25*avg_distortion*curr_cu_info->num_part_in_cu);}*/dist = encode_inter(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);#else// 如果是skip模式，那么表示处理已经完成；否则需要继续处理if (!is_skipped && (curr_cu_info->size < 64 || (sad < 100 * curr_cu_info->num_part_in_cu)))// && curr_cu_info->size == 64)){mv_cost = predict_inter(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);//.25*avg_distortion*curr_cu_info->num_part_in_cu);dist = encode_inter(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);}else{//printf("64x64 inter computation skipped");mv_cost = 0;dist = MAX_COST;curr_cu_info->sum = 0;curr_cu_info->inter_mv[REF_PIC_LIST_0].hor_vector = curr_cu_info->inter_mv[REF_PIC_LIST_0].ver_vector = 0;curr_cu_info->inter_mv[REF_PIC_LIST_1].hor_vector = curr_cu_info->inter_mv[REF_PIC_LIST_1].ver_vector = 0;}#endifcost = dist;cost += 2 * mv_cost;cost = calc_cost_full(cost, curr_depth, avg_distortion);cost += cost_rd(et->enc_engine->avg_dist, curr_cu_info->sum);#ifdef COMPUTE_AS_HMcost = dist + 5 * curr_depth;#endif// 与merge模式的代价相比较，看看到底是用什么模式好if (cost < merge_cost){curr_cu_info->merge_flag = FALSE;curr_cu_info->skipped = FALSE;}else{curr_cu_info->inter_mv[REF_PIC_LIST_0] = merge_mv0;curr_cu_info->inter_ref_index[REF_PIC_LIST_0] = merge_ref_idx0;curr_cu_info->inter_mv[REF_PIC_LIST_1] = merge_mv1;curr_cu_info->inter_ref_index[REF_PIC_LIST_1] = merge_ref_idx1;curr_cu_info->inter_mode = merge_inter_mode;curr_cu_info->sum = merge_sum;cost = merge_cost;dist = merge_dist;}}curr_cu_info->cost = (uint32_t)cost;curr_cu_info->distortion = (uint32_t)dist;#ifndef COMPUTE_AS_HM//fast skipif (perf_fast_skip && (dist == 0 || (curr_cu_info->sum < curr_cu_info->num_part_in_cu && dist < .25*avg_distortion*curr_cu_info->num_part_in_cu) || (curr_cu_info->sum == 0 && dist < avg_distortion*curr_cu_info->num_part_in_cu))){int max_processing_depth;// 如果启用了merge模式if (curr_cu_info->merge_flag)get_back_consolidated_info(et, ctu, curr_cu_info, curr_depth);stop_recursion = TRUE;consolidate_prediction_info(et, ctu, ctu_rd, curr_cu_info, curr_cu_info->cost, MAX_COST, FALSE, NULL);max_processing_depth = min(et->max_pred_partition_depth + et->max_intra_tr_depth - 1, MAX_PARTITION_DEPTH - 1);if (curr_depth <= max_processing_depth)//{int aux_depth;cu_partition_info_t* aux_partition_info = curr_cu_info;//(parent_part_info!=NULL)?parent_part_info->children[(depth_state[curr_depth])]:&ctu->partition_list[0];abs_index = aux_partition_info->abs_index;num_part_in_cu = aux_partition_info->num_part_in_cu;for (aux_depth = curr_depth; aux_depth <= max_processing_depth; aux_depth++){synchronize_reference_buffs(et, aux_partition_info, et->decoded_mbs_wnd[0], et->decoded_mbs_wnd[aux_depth + 1], gcnt);//for rdif (et->rd_mode != RD_DIST_ONLY)consolidate_info_buffers_for_rd(et, ctu, aux_depth, abs_index, num_part_in_cu);}synchronize_reference_buffs_chroma(et, aux_partition_info, et->decoded_mbs_wnd[0], et->decoded_mbs_wnd[NUM_DECODED_WNDS - 1], gcnt);}}if (perf_fast_skip && ((curr_cu_info->depth >= perf_min_depth) && !stop_recursion && !is_skipped && (curr_cu_info->size < 32 || sad>400 * curr_cu_info->num_part_in_cu)))//if(0)#endif{//encode intrauint inter_sum = curr_cu_info->sum;uint intra_dist;if (!curr_cu_info->merge_flag)put_consolidated_info(et, ctu, curr_cu_info, curr_depth);intra_dist = encode_intra(et, ctu, gcnt, curr_depth, position, SIZE_2Nx2N);#ifdef COMPUTE_AS_HMintra_cost = intra_dist + 5 * curr_depth;if (intra_cost < cost)#elseintra_cost = intra_dist*(1.275 - clip(((double)total_intra_partitions / (double)total_partitions), .0, .15)) + clip(avg_distortion - 400, 40, avg_distortion) / 1.75*curr_depth;intra_cost += cost_rd(et->enc_engine->avg_dist, curr_cu_info->sum);//if(intra_cost*(1.+curr_cu_info[0].qp/50.0)<cost)if (intra_cost < cost)#endif{//we prefer intra and it is already in its buffercurr_cu_info->cost = (uint32_t)intra_cost;curr_cu_info->distortion = (uint32_t)intra_dist;//curr_cu_info->sum = curr_cu_info->sum;curr_cu_info->prediction_mode = INTRA_MODE;curr_cu_info->merge_flag = FALSE;curr_cu_info->skipped = FALSE;}else{//we prefer inter, bring it backget_back_consolidated_info(et, ctu, curr_cu_info, curr_depth);curr_cu_info->cost = (uint32_t)cost;curr_cu_info->distortion = (uint32_t)dist;curr_cu_info->sum = inter_sum;curr_cu_info->prediction_mode = INTER_MODE;}}#ifndef COMPUTE_AS_HMelse if ((curr_cu_info->depth >= perf_min_depth) && !stop_recursion){if (curr_cu_info->merge_flag)get_back_consolidated_info(et, ctu, curr_cu_info, curr_depth);}#endif#ifndef COMPUTE_AS_HM#endif}/*** 对于NxN的划分模式，按照下面的顺序进行处理：** 1、进行常规的帧间预测（即AMVP）** 2、尝试帧内预测** 3、选取最优的模式*/else if (part_size_type == SIZE_NxN)//intra NxN is processed in its current depth, while inter NxN is processed in its father�s depth. So, intra NxN does not have to be compaired{// 只有2Nx2N才会尝试merge模式// 否则直接进行普通的帧间预测cost = dist = curr_cu_info->cost = curr_cu_info->distortion = MAX_COST;if ((curr_depth - 1) == (et->max_cu_depth - et->mincu_mintr_shift_diff) && curr_cu_info->parent->size > 8)//SIZE_NxN{uint sad;uint motion_estimation_precision = (et->enc_engine->motion_estimation_precision * 2 - 1);//compute all precisions below the configuredint position_aux = curr_cu_info->parent->list_index - et->partition_depth_start[curr_depth - 1];uint aux_cost = curr_cu_info->parent->cost;uint aux_dist = curr_cu_info->parent->distortion;uint aux_sum = curr_cu_info->parent->sum;if (et->enc_engine->num_encoded_frames == 1 && curr_cu_info->abs_index >= 32)// && ctu->ctu_number==5 )// && curr_depth==3){int iiiiii = 0;}// 运动估计（里面包含了运动补偿）sad = hmr_cu_motion_estimation(et, ctu, gcnt, curr_depth, position, SIZE_NxN, 0, motion_estimation_precision);//(MOTION_PEL_MASK|MOTION_HALF_PEL_MASK|MOTION_QUARTER_PEL_MASK));//.25*avg_distortion*curr_cu_info->num_part_in_cu);if (et->enc_engine->num_encoded_frames == 1 && ctu->ctu_number == 5 && curr_cu_info->abs_index == 176){int iiiii = 0;}// 运动补偿，并计算残差mv_cost = predict_inter(et, ctu, gcnt, curr_depth, position, SIZE_NxN);//.25*avg_distortion*curr_cu_info->num_part_in_cu);// 变换量化dist = encode_inter(et, ctu, gcnt, curr_depth - 1, position_aux, SIZE_NxN);//this function is referenced by the initial depth, not by the processing depth#ifdef COMPUTE_AS_HMcost = dist + 5 * curr_depth;#elsecost = calc_cost_full(dist, curr_depth, avg_distortion);cost += mv_cost;#endifcurr_cu_info[0].cost = curr_cu_info[1].cost = curr_cu_info[2].cost = curr_cu_info[3].cost = 0;curr_cu_info[0].sum = curr_cu_info[1].sum = curr_cu_info[2].sum = curr_cu_info[3].sum = 0;curr_cu_info[0].distortion = curr_cu_info[1].distortion = curr_cu_info[2].distortion = curr_cu_info[3].distortion = 0;curr_cu_info->cost = (uint32_t)cost;curr_cu_info->distortion = (uint32_t)dist;curr_cu_info->sum = curr_cu_info->parent->sum;curr_cu_info[0].prediction_mode = curr_cu_info[1].prediction_mode = curr_cu_info[2].prediction_mode = curr_cu_info[3].prediction_mode = INTER_MODE;//restore parent valuescurr_cu_info->parent->cost = aux_cost;//este valor se sobreescribe en encode_inter. Deberia intentar hacer que el intra funcionase igual, con 1 sola llamada que hiciese las 4 particiones NxN. Asi se consolidaria el cbf totalmentecurr_cu_info->parent->distortion = aux_dist;curr_cu_info->parent->sum = aux_sum;#ifdef COMPUTE_AS_HM}#else// 还需要尝试帧内预测，比较AMVP（即普通的帧间预测）和帧内预测的失真和代价if (curr_cu_info->size<64 && dist>(1.5*avg_distortion*(4 * curr_cu_info->num_part_in_cu + 4 * curr_depth)/*+4000*curr_cu_info->num_part_in_cu*/))#endif{//intrauint previous_sum = curr_cu_info->sum;uint intra_dist, intra_sum;put_consolidated_info(et, ctu, curr_cu_info->parent, curr_depth);intra_cost = 0;intra_dist = encode_intra(et, ctu, gcnt, curr_depth, position, part_size_type);intra_cost = calc_cost_full(intra_dist, curr_depth, avg_distortion);intra_sum = curr_cu_info[0].sum + curr_cu_info[1].sum + curr_cu_info[2].sum + curr_cu_info[3].sum;curr_cu_info[0].cost = curr_cu_info[1].cost = curr_cu_info[2].cost = curr_cu_info[3].cost = 0;curr_cu_info[0].sum = curr_cu_info[1].sum = curr_cu_info[2].sum = curr_cu_info[3].sum = 0;curr_cu_info[0].distortion = curr_cu_info[1].distortion = curr_cu_info[2].distortion = curr_cu_info[3].distortion = 0;curr_cu_info[0].skipped = curr_cu_info[1].skipped = curr_cu_info[2].skipped = curr_cu_info[3].skipped = 0;#ifdef COMPUTE_AS_HMintra_cost = intra_dist + 5 * curr_depth;if (intra_cost < cost)#elseif ((1.25)*intra_cost + 45 * intra_sum < cost + 45 * previous_sum)// && intra_cost<64*curr_cu_info->variance)#endif{//we prefer intra and it is already in its buffercurr_cu_info->cost = (uint32_t)intra_cost;curr_cu_info->sum = intra_sum;curr_cu_info->distortion = (uint32_t)intra_dist;curr_cu_info[0].prediction_mode = curr_cu_info[1].prediction_mode = curr_cu_info[2].prediction_mode = curr_cu_info[3].prediction_mode = INTRA_MODE;}else{//we prefer inter, bring it backget_back_consolidated_info(et, ctu, curr_cu_info->parent, curr_depth);curr_cu_info->cost = (uint32_t)cost;curr_cu_info->sum = previous_sum;curr_cu_info->distortion = (uint32_t)dist;curr_cu_info[0].prediction_mode = curr_cu_info[1].prediction_mode = curr_cu_info[2].prediction_mode = curr_cu_info[3].prediction_mode = INTER_MODE;}}#ifndef COMPUTE_AS_HM}#endifdepth_state[curr_depth] = 3;}}else{curr_cu_info->cost = MAX_COST;}cost_sum[curr_depth] += curr_cu_info->cost;depth_state[curr_depth]++;if ((curr_depth) < et->max_pred_partition_depth && curr_cu_info->is_tl_inside_frame && !stop_recursion)//depth_state[curr_depth]!=4 is for fast skip//if tl is not inside the frame don't process the next depths{curr_depth++;parent_part_info = curr_cu_info;}else if (depth_state[curr_depth] == 4)//depth =1 already consolidated{int max_processing_depth;while (depth_state[curr_depth] == 4 && curr_depth > 0)//>0 pq consolidamos sobre el padre, {int is_max_depth = (curr_depth == et->max_pred_partition_depth);cost = parent_part_info->children[0]->cost + parent_part_info->children[1]->cost + parent_part_info->children[2]->cost + parent_part_info->children[3]->cost;depth_state[curr_depth] = 0;best_cost = parent_part_info->cost;consolidate_prediction_info(et, ctu, ctu_rd, parent_part_info, (uint32_t)best_cost, (uint32_t)cost, is_max_depth, cost_sum);depth_state[curr_depth] = 0;cost_sum[curr_depth] = 0;curr_depth--;parent_part_info = parent_part_info->parent;#ifndef COMPUTE_AS_HMif (curr_depth > perf_min_depth/*-1*/ && cost_sum[curr_depth] > parent_part_info->cost && depth_state[curr_depth] < 4 && ctu->partition_list[0].is_b_inside_frame && ctu->partition_list[0].is_r_inside_frame){depth_state[curr_depth] = 4;}#endif}max_processing_depth = min(et->max_pred_partition_depth + et->max_intra_tr_depth - 1, MAX_PARTITION_DEPTH - 1);if (curr_depth <= max_processing_depth)//= is needed when et->max_intra_tr_depth!=4{int aux_depth;cu_partition_info_t*aux_partition_info = (parent_part_info != NULL) ? parent_part_info->children[(depth_state[curr_depth] + 3) & 0x3] : &ctu->partition_list[0];abs_index = aux_partition_info->abs_index;num_part_in_cu = aux_partition_info->num_part_in_cu;for (aux_depth = curr_depth; aux_depth <= max_processing_depth; aux_depth++){synchronize_reference_buffs(et, aux_partition_info, et->decoded_mbs_wnd[0], et->decoded_mbs_wnd[aux_depth + 1], gcnt);}synchronize_reference_buffs_chroma(et, aux_partition_info, et->decoded_mbs_wnd[0], et->decoded_mbs_wnd[NUM_DECODED_WNDS - 1], gcnt);}}if (parent_part_info != NULL)curr_cu_info = parent_part_info->children[depth_state[curr_depth]];}curr_cu_info = &ctu->partition_list[0];abs_index = curr_cu_info->abs_index;curr_depth = curr_cu_info->depth;num_part_in_cu = curr_cu_info->num_part_in_cu;if (et->max_pred_partition_depth == 0){CONSOLIDATE_ENC_INFO_BUFFS(et, ctu, curr_depth, abs_index, num_part_in_cu);SET_INTER_INFO_BUFFS(et, ctu, curr_cu_info, abs_index, num_part_in_cu);//, REF_PIC_LIST_0);}return curr_cu_info->cost;}