| |
| /*! |
| ************************************************************************************* |
| * \file mv-search.c |
| * |
| * \brief |
| * Motion Vector Search, unified for B and P Pictures |
| * |
| * \author |
| * Main contributors (see contributors.h for copyright, address and affiliation details) |
| * - Stephan Wenger <stewe@cs.tu-berlin.de> |
| * - Inge Lille-Langoy <inge.lille-langoy@telenor.com> |
| * - Rickard Sjoberg <rickard.sjoberg@era.ericsson.se> |
| * - Stephan Wenger <stewe@cs.tu-berlin.de> |
| * - Jani Lainema <jani.lainema@nokia.com> |
| * - Detlev Marpe <marpe@hhi.de> |
| * - Thomas Wedi <wedi@tnt.uni-hannover.de> |
| * - Heiko Schwarz <hschwarz@hhi.de> |
| * - Alexis Michael Tourapis <alexismt@ieee.org> |
| * |
| ************************************************************************************* |
| */ |
| |
| #include "contributors.h" |
| |
| #include <stdlib.h> |
| #include <math.h> |
| #include <limits.h> |
| #include <string.h> |
| #include <time.h> |
| #include <sys/timeb.h> |
| |
| #include "global.h" |
| |
| #include "image.h" |
| #include "mv-search.h" |
| #include "refbuf.h" |
| #include "memalloc.h" |
| #include "mb_access.h" |
| #include "macroblock.h" |
| |
| // Motion estimation distortion header file |
| #include "me_distortion.h" |
| |
| // Motion estimation search algorithms |
| #include "me_epzs.h" |
| #include "me_fullfast.h" |
| #include "me_fullsearch.h" |
| #include "me_umhex.h" |
| #include "me_umhexsmp.h" |
| |
| // Statistics, temporary |
| int max_mvd; |
| short* spiral_search_x; |
| short* spiral_search_y; |
| short* spiral_hpel_search_x; |
| short* spiral_hpel_search_y; |
| |
| int* mvbits; |
| int* refbits; |
| int* byte_abs; |
| int**** motion_cost; |
| int byte_abs_range; |
| |
| static int diff [16]; |
| static int diff64[64]; |
| static imgpel orig_pic [768]; |
| void SetMotionVectorPredictor (short pmv[2], |
| signed char **refPic, |
| short ***tmp_mv, |
| short ref_frame, |
| int list, |
| int block_x, |
| int block_y, |
| int blockshape_x, |
| int blockshape_y); |
| |
| extern ColocatedParams *Co_located; |
| extern const short block_type_shift_factor[8]; |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Set motion vector predictor |
| ************************************************************************ |
| */ |
| void SetMotionVectorPredictor (short pmv[2], |
| signed char **refPic, |
| short ***tmp_mv, |
| short ref_frame, |
| int list, |
| int block_x, |
| int block_y, |
| int blockshape_x, |
| int blockshape_y) |
| { |
| int mb_x = 4*block_x; |
| int mb_y = 4*block_y; |
| int mb_nr = img->current_mb_nr; |
| |
| int mv_a, mv_b, mv_c, pred_vec=0; |
| int mvPredType, rFrameL, rFrameU, rFrameUR; |
| int hv; |
| |
| PixelPos block_a, block_b, block_c, block_d; |
| |
| getLuma4x4Neighbour(mb_nr, mb_x - 1, mb_y, &block_a); |
| getLuma4x4Neighbour(mb_nr, mb_x, mb_y - 1, &block_b); |
| getLuma4x4Neighbour(mb_nr, mb_x + blockshape_x, mb_y - 1, &block_c); |
| getLuma4x4Neighbour(mb_nr, mb_x - 1, mb_y - 1, &block_d); |
| |
| if (mb_y > 0) |
| { |
| if (mb_x < 8) // first column of 8x8 blocks |
| { |
| if (mb_y==8) |
| { |
| if (blockshape_x == 16) block_c.available = 0; |
| } |
| else |
| { |
| if (mb_x+blockshape_x == 8) block_c.available = 0; |
| } |
| } |
| else |
| { |
| if (mb_x+blockshape_x == 16) block_c.available = 0; |
| } |
| } |
| |
| if (!block_c.available) |
| { |
| block_c=block_d; |
| } |
| |
| mvPredType = MVPRED_MEDIAN; |
| |
| if (!img->MbaffFrameFlag) |
| { |
| rFrameL = block_a.available ? refPic[block_a.pos_y][block_a.pos_x] : -1; |
| rFrameU = block_b.available ? refPic[block_b.pos_y][block_b.pos_x] : -1; |
| rFrameUR = block_c.available ? refPic[block_c.pos_y][block_c.pos_x] : -1; |
| } |
| else |
| { |
| if (img->mb_data[img->current_mb_nr].mb_field) |
| { |
| rFrameL = block_a.available |
| ? (img->mb_data[block_a.mb_addr].mb_field |
| ? refPic[block_a.pos_y][block_a.pos_x] |
| : refPic[block_a.pos_y][block_a.pos_x] * 2) : -1; |
| rFrameU = block_b.available |
| ? (img->mb_data[block_b.mb_addr].mb_field |
| ? refPic[block_b.pos_y][block_b.pos_x] |
| : refPic[block_b.pos_y][block_b.pos_x] * 2) : -1; |
| rFrameUR = block_c.available |
| ? (img->mb_data[block_c.mb_addr].mb_field |
| ? refPic[block_c.pos_y][block_c.pos_x] |
| : refPic[block_c.pos_y][block_c.pos_x] * 2) : -1; |
| } |
| else |
| { |
| rFrameL = block_a.available |
| ? (img->mb_data[block_a.mb_addr].mb_field |
| ? refPic[block_a.pos_y][block_a.pos_x] >>1 |
| : refPic[block_a.pos_y][block_a.pos_x]) : -1; |
| rFrameU = block_b.available |
| ? (img->mb_data[block_b.mb_addr].mb_field |
| ? refPic[block_b.pos_y][block_b.pos_x] >>1 |
| : refPic[block_b.pos_y][block_b.pos_x]) : -1; |
| rFrameUR = block_c.available |
| ? (img->mb_data[block_c.mb_addr].mb_field |
| ? refPic[block_c.pos_y][block_c.pos_x] >>1 |
| : refPic[block_c.pos_y][block_c.pos_x]) : -1; |
| } |
| } |
| |
| /* Prediction if only one of the neighbors uses the reference frame |
| * we are checking |
| */ |
| if(rFrameL == ref_frame && rFrameU != ref_frame && rFrameUR != ref_frame) mvPredType = MVPRED_L; |
| else if(rFrameL != ref_frame && rFrameU == ref_frame && rFrameUR != ref_frame) mvPredType = MVPRED_U; |
| else if(rFrameL != ref_frame && rFrameU != ref_frame && rFrameUR == ref_frame) mvPredType = MVPRED_UR; |
| // Directional predictions |
| if(blockshape_x == 8 && blockshape_y == 16) |
| { |
| if(mb_x == 0) |
| { |
| if(rFrameL == ref_frame) |
| mvPredType = MVPRED_L; |
| } |
| else |
| { |
| if( rFrameUR == ref_frame) |
| mvPredType = MVPRED_UR; |
| } |
| } |
| else if(blockshape_x == 16 && blockshape_y == 8) |
| { |
| if(mb_y == 0) |
| { |
| if(rFrameU == ref_frame) |
| mvPredType = MVPRED_U; |
| } |
| else |
| { |
| if(rFrameL == ref_frame) |
| mvPredType = MVPRED_L; |
| } |
| } |
| |
| for (hv=0; hv < 2; hv++) |
| { |
| if (!img->MbaffFrameFlag || hv==0) |
| { |
| mv_a = block_a.available ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] : 0; |
| mv_b = block_b.available ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] : 0; |
| mv_c = block_c.available ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] : 0; |
| } |
| else |
| { |
| if (img->mb_data[img->current_mb_nr].mb_field) |
| { |
| mv_a = block_a.available ? img->mb_data[block_a.mb_addr].mb_field |
| ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] |
| : tmp_mv[block_a.pos_y][block_a.pos_x][hv] / 2 |
| : 0; |
| mv_b = block_b.available ? img->mb_data[block_b.mb_addr].mb_field |
| ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] |
| : tmp_mv[block_b.pos_y][block_b.pos_x][hv] / 2 |
| : 0; |
| mv_c = block_c.available ? img->mb_data[block_c.mb_addr].mb_field |
| ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] |
| : tmp_mv[block_c.pos_y][block_c.pos_x][hv] / 2 |
| : 0; |
| } |
| else |
| { |
| mv_a = block_a.available ? img->mb_data[block_a.mb_addr].mb_field |
| ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] * 2 |
| : tmp_mv[block_a.pos_y][block_a.pos_x][hv] |
| : 0; |
| mv_b = block_b.available ? img->mb_data[block_b.mb_addr].mb_field |
| ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] * 2 |
| : tmp_mv[block_b.pos_y][block_b.pos_x][hv] |
| : 0; |
| mv_c = block_c.available ? img->mb_data[block_c.mb_addr].mb_field |
| ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] * 2 |
| : tmp_mv[block_c.pos_y][block_c.pos_x][hv] |
| : 0; |
| } |
| } |
| |
| switch (mvPredType) |
| { |
| case MVPRED_MEDIAN: |
| if(!(block_b.available || block_c.available)) |
| { |
| pred_vec = mv_a; |
| } |
| else |
| { |
| pred_vec = mv_a+mv_b+mv_c-imin(mv_a,imin(mv_b,mv_c))-imax(mv_a,imax(mv_b,mv_c)); |
| } |
| break; |
| case MVPRED_L: |
| pred_vec = mv_a; |
| break; |
| case MVPRED_U: |
| pred_vec = mv_b; |
| break; |
| case MVPRED_UR: |
| pred_vec = mv_c; |
| break; |
| default: |
| break; |
| } |
| |
| pmv[hv] = pred_vec; |
| } |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Initialize the motion search |
| ************************************************************************ |
| */ |
| void |
| Init_Motion_Search_Module () |
| { |
| int bits, i_min, i_max, k; |
| int i, l; |
| |
| int search_range = input->search_range; |
| int max_search_points = imax(9, (2*search_range+1)*(2*search_range+1)); |
| int max_ref_bits = 1 + 2 * (int)floor(log(imax(16,img->max_num_references+1)) / log(2) + 1e-10); |
| int max_ref = (1<<((max_ref_bits>>1)+1))-1; |
| int number_of_subpel_positions = 4 * (2*search_range+3); |
| int max_mv_bits = 3 + 2 * (int)ceil (log(number_of_subpel_positions+1) / log(2) + 1e-10); |
| max_mvd = (1<<( max_mv_bits >>1) )-1; |
| byte_abs_range = (img->max_imgpel_value > img->max_imgpel_value_uv) ? (img->max_imgpel_value + 1) * 64 : (img->max_imgpel_value_uv + 1) * 64; |
| |
| //===== CREATE ARRAYS ===== |
| //----------------------------- |
| if ((spiral_search_x = (short*)calloc(max_search_points, sizeof(short))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: spiral_search_x"); |
| if ((spiral_search_y = (short*)calloc(max_search_points, sizeof(short))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: spiral_search_y"); |
| if ((spiral_hpel_search_x = (short*)calloc(max_search_points, sizeof(short))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: spiral_hpel_search_x"); |
| if ((spiral_hpel_search_y = (short*)calloc(max_search_points, sizeof(short))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: spiral_hpel_search_y"); |
| if ((mvbits = (int*)calloc(2*max_mvd+1, sizeof(int))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: mvbits"); |
| if ((refbits = (int*)calloc(max_ref, sizeof(int))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: refbits"); |
| if ((byte_abs = (int*)calloc(byte_abs_range, sizeof(int))) == NULL) |
| no_mem_exit("Init_Motion_Search_Module: byte_abs"); |
| |
| get_mem4Dint (&motion_cost, 8, 2, img->max_num_references, 4); |
| |
| //--- set array offsets --- |
| mvbits += max_mvd; |
| byte_abs += byte_abs_range/2; |
| |
| //===== INIT ARRAYS ===== |
| //--------------------------- |
| //--- init array: motion vector bits --- |
| mvbits[0] = 1; |
| for (bits=3; bits<=max_mv_bits; bits+=2) |
| { |
| i_max = 1 << (bits >> 1); |
| i_min = i_max >> 1; |
| |
| for (i = i_min; i < i_max; i++) |
| mvbits[-i] = mvbits[i] = bits; |
| } |
| |
| //--- init array: reference frame bits --- |
| refbits[0] = 1; |
| for (bits=3; bits<=max_ref_bits; bits+=2) |
| { |
| i_max = (1 << ((bits >> 1) + 1)) - 1; |
| i_min = i_max >> 1; |
| |
| for (i = i_min; i < i_max; i++) |
| refbits[i] = bits; |
| } |
| |
| //--- init array: absolute value --- |
| byte_abs[0] = 0; |
| // Set scaler for integer/subpel motion refinement. |
| // Currently only EPZS supports subpel positions |
| |
| |
| for (i=1; i<byte_abs_range/2; i++) |
| { |
| byte_abs[i] = byte_abs[-i] = i; |
| } |
| |
| //--- init array: search pattern --- |
| spiral_search_x[0] = spiral_search_y[0] = 0; |
| spiral_hpel_search_x[0] = spiral_hpel_search_y[0] = 0; |
| |
| for (k=1, l=1; l <= imax(1,search_range); l++) |
| { |
| for (i=-l+1; i< l; i++) |
| { |
| spiral_search_x[k] = i; |
| spiral_search_y[k] = -l; |
| spiral_hpel_search_x[k] = i<<1; |
| spiral_hpel_search_y[k++] = -l<<1; |
| spiral_search_x[k] = i; |
| spiral_search_y[k] = l; |
| spiral_hpel_search_x[k] = i<<1; |
| spiral_hpel_search_y[k++] = l<<1; |
| } |
| for (i=-l; i<=l; i++) |
| { |
| spiral_search_x[k] = -l; |
| spiral_search_y[k] = i; |
| spiral_hpel_search_x[k] = -l<<1; |
| spiral_hpel_search_y[k++] = i<<1; |
| spiral_search_x[k] = l; |
| spiral_search_y[k] = i; |
| spiral_hpel_search_x[k] = l<<1; |
| spiral_hpel_search_y[k++] = i<<1; |
| } |
| } |
| |
| // set global variable prior to ME |
| start_me_refinement_hp = (input->ChromaMEEnable == 1 || input->MEErrorMetric[F_PEL] != input->MEErrorMetric[H_PEL] ) ? 0 : 1; |
| start_me_refinement_qp = (input->ChromaMEEnable == 1 || input->MEErrorMetric[H_PEL] != input->MEErrorMetric[Q_PEL] ) ? 0 : 1; |
| |
| // Setup Distortion Metrics depending on refinement level |
| for (i=0; i<3; i++) |
| { |
| switch(input->MEErrorMetric[i]) |
| { |
| case ERROR_SAD: |
| computeUniPred[i] = computeSAD; |
| computeUniPred[i + 3] = computeSADWP; |
| computeBiPred1[i] = computeBiPredSAD1; |
| computeBiPred2[i] = computeBiPredSAD2; |
| break; |
| case ERROR_SSE: |
| computeUniPred[i] = computeSSE; |
| computeUniPred[i + 3] = computeSSEWP; |
| computeBiPred1[i] = computeBiPredSSE1; |
| computeBiPred2[i] = computeBiPredSSE2; |
| break; |
| case ERROR_SATD : |
| default: |
| computeUniPred[i] = computeSATD; |
| computeUniPred[i + 3] = computeSATDWP; |
| computeBiPred1[i] = computeBiPredSATD1; |
| computeBiPred2[i] = computeBiPredSATD2; |
| break; |
| } |
| } |
| // Setup buffer access methods |
| get_line[0] = FastLine4X; |
| get_line[1] = UMVLine4X; |
| get_crline[0] = FastLine8X_chroma; |
| get_crline[1] = UMVLine8X_chroma; |
| |
| if(input->SearchMode == FAST_FULL_SEARCH) |
| InitializeFastFullIntegerSearch (); |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Free memory used by motion search |
| ************************************************************************ |
| */ |
| void |
| Clear_Motion_Search_Module () |
| { |
| //--- correct array offset --- |
| mvbits -= max_mvd; |
| byte_abs -= byte_abs_range/2; |
| |
| //--- delete arrays --- |
| free (spiral_search_x); |
| free (spiral_search_y); |
| free (spiral_hpel_search_x); |
| free (spiral_hpel_search_y); |
| free (mvbits); |
| free (refbits); |
| free (byte_abs); |
| free_mem4Dint (motion_cost, 8, 2); |
| |
| if(input->SearchMode == FAST_FULL_SEARCH) |
| ClearFastFullIntegerSearch (); |
| } |
| |
| /*! |
| *********************************************************************** |
| * \brief |
| * Motion Cost for Bidirectional modes |
| *********************************************************************** |
| */ |
| int BPredPartitionCost (int blocktype, |
| int block8x8, |
| short ref_l0, |
| short ref_l1, |
| int lambda_factor, |
| int list) |
| { |
| static int bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}}; |
| static int by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}}; |
| |
| int curr_blk[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; // ABT pred.error buffer |
| int bsx = imin(input->blc_size[blocktype][0],8); |
| int bsy = imin(input->blc_size[blocktype][1],8); |
| |
| int pic_pix_x, pic_pix_y, block_x, block_y; |
| int v, h, mcost, i, j, k; |
| int mvd_bits = 0; |
| int parttype = (blocktype<4?blocktype:4); |
| int step_h0 = (input->part_size[ parttype][0]); |
| int step_v0 = (input->part_size[ parttype][1]); |
| int step_h = (input->part_size[blocktype][0]); |
| int step_v = (input->part_size[blocktype][1]); |
| int bxx, byy; // indexing curr_blk |
| |
| short ******all_mv = list ? img->bipred_mv1 : img->bipred_mv2; |
| short ****** p_mv = img->pred_mv; |
| |
| for (v=by0[parttype][block8x8]; v<by0[parttype][block8x8]+step_v0; v+=step_v) |
| { |
| for (h=bx0[parttype][block8x8]; h<bx0[parttype][block8x8]+step_h0; h+=step_h) |
| { |
| mvd_bits += mvbits[ all_mv [v][h][LIST_0][ref_l0][blocktype][0] - p_mv[v][h][LIST_0][ref_l0][blocktype][0] ]; |
| mvd_bits += mvbits[ all_mv [v][h][LIST_0][ref_l0][blocktype][1] - p_mv[v][h][LIST_0][ref_l0][blocktype][1] ]; |
| |
| mvd_bits += mvbits[ all_mv [v][h][LIST_1][ref_l1][blocktype][0] - p_mv[v][h][LIST_1][ref_l1][blocktype][0] ]; |
| mvd_bits += mvbits[ all_mv [v][h][LIST_1][ref_l1][blocktype][1] - p_mv[v][h][LIST_1][ref_l1][blocktype][1] ]; |
| } |
| } |
| mcost = WEIGHTED_COST (lambda_factor, mvd_bits); |
| |
| //----- cost of residual signal ----- |
| for (byy=0, v=by0[parttype][block8x8]; v<by0[parttype][block8x8]+step_v0; byy+=4, v++) |
| { |
| |
| pic_pix_y = img->opix_y + (block_y = (v<<2)); |
| for (bxx=0, h=bx0[parttype][block8x8]; h<bx0[parttype][block8x8]+step_h0; bxx+=4, h++) |
| { |
| pic_pix_x = img->opix_x + (block_x = (h<<2)); |
| LumaPrediction4x4Bi (block_x, block_y, blocktype, blocktype, ref_l0, ref_l1, list); |
| |
| for (k=j=0; j<4; j++) |
| { |
| for ( i=0; i<4; i++) |
| diff64[k++] = curr_blk[byy+j][bxx+i] = |
| imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mpr[j+block_y][i+block_x]; |
| } |
| if ((!input->Transform8x8Mode) || (blocktype>4)) |
| { |
| mcost += distortion4x4 (diff64); |
| } |
| } |
| } |
| if (input->Transform8x8Mode && (blocktype<=4)) // tchen 4-29-04 |
| { |
| for (byy=0; byy < input->blc_size[parttype][1]; byy+=bsy) |
| for (bxx=0; bxx<input->blc_size[parttype][0]; bxx+=bsx) |
| { |
| for (k=0, j=byy;j<byy + 8;j++, k += 8) |
| memcpy(&diff64[k], &(curr_blk[j][bxx]), 8 * sizeof(int)); |
| |
| mcost += distortion8x8(diff64); |
| } |
| } |
| return mcost; |
| } |
| |
| |
| /*! |
| *********************************************************************** |
| * \brief |
| * Block motion search |
| *********************************************************************** |
| */ |
| int //!< minimum motion cost after search |
| BlockMotionSearch (short ref, //!< reference idx |
| int list, //!< reference pciture list |
| int mb_x, //!< x-coordinate inside macroblock |
| int mb_y, //!< y-coordinate inside macroblock |
| int blocktype, //!< block type (1-16x16 ... 7-4x4) |
| int search_range, //!< 1-d search range for integer-position search |
| int* lambda_factor) //!< lagrangian parameter for determining motion cost |
| { |
| // each 48-pel line stores the 16 luma pels (at 0) followed by 8 or 16 crcb[0] (at 16) and crcb[1] (at 32) pels |
| // depending on the type of chroma subsampling used: YUV 4:4:4, 4:2:2, and 4:2:0 |
| imgpel *orig_pic_tmp = orig_pic; |
| |
| short mv[2]; |
| int i, j; |
| |
| int max_value = INT_MAX; |
| int min_mcost = max_value; |
| |
| int block_x = (mb_x>>2); |
| int block_y = (mb_y>>2); |
| |
| int bsx = input->blc_size[blocktype][0]; |
| int bsy = input->blc_size[blocktype][1]; |
| |
| int pic_pix_x = img->opix_x + mb_x; |
| int pic_pix_y = img->opix_y + mb_y; |
| |
| int pic_pix_x_c = pic_pix_x >> (chroma_shift_x - 2); |
| int pic_pix_y_c = pic_pix_y >> (chroma_shift_y - 2); |
| int bsx_c = bsx >> (chroma_shift_x - 2); |
| int bsy_c = bsy >> (chroma_shift_y - 2); |
| |
| short* pred_mv = img->pred_mv[block_y][block_x][list][ref][blocktype]; |
| short****** all_mv = img->all_mv; |
| int list_offset = ((img->MbaffFrameFlag) && (img->mb_data[img->current_mb_nr].mb_field)) ? img->current_mb_nr % 2 ? 4 : 2 : 0; |
| int *prevSad = (input->SearchMode == EPZS)? EPZSDistortion[list + list_offset][blocktype - 1]: NULL; |
| |
| #if GET_METIME |
| static struct TIMEB tstruct1; |
| static struct TIMEB tstruct2; |
| time_t me_tmp_time; |
| |
| ftime( &tstruct1 ); // start time ms |
| #endif |
| //================================== |
| //===== GET ORIGINAL BLOCK ===== |
| //================================== |
| for (j = 0; j < bsy; j++) |
| { |
| memcpy(orig_pic_tmp,&imgY_org[pic_pix_y+j][pic_pix_x], bsx *sizeof(imgpel)); |
| orig_pic_tmp += bsx; |
| } |
| ChromaMEEnable = input->ChromaMEEnable; |
| |
| if ( ChromaMEEnable ) |
| { |
| // copy the original cmp1 and cmp2 data to the orig_pic matrix |
| orig_pic_tmp = orig_pic + 256; |
| for (j = 0; j < bsy_c; j++) |
| { |
| memcpy(orig_pic_tmp, &(imgUV_org[0][pic_pix_y_c+j][pic_pix_x_c]), bsx_c *sizeof(imgpel)); |
| orig_pic_tmp += bsx_c; |
| } |
| orig_pic_tmp = orig_pic + 512; |
| for (j = 0; j < bsy_c; j++) |
| { |
| memcpy(orig_pic_tmp, &(imgUV_org[1][pic_pix_y_c+j][pic_pix_x_c]), bsx_c *sizeof(imgpel)); |
| orig_pic_tmp += bsx_c; |
| } |
| } |
| |
| |
| if(input->SearchMode == UM_HEX) |
| { |
| UMHEX_blocktype = blocktype; |
| bipred_flag = 0; |
| } |
| else if (input->SearchMode == UM_HEX_SIMPLE) |
| { |
| smpUMHEX_setup(ref, list, block_y, block_x, blocktype, all_mv ); |
| } |
| |
| // Set if 8x8 transform will be used if SATD is used |
| test8x8transform = input->Transform8x8Mode && blocktype <= 4; |
| |
| //=========================================== |
| //===== GET MOTION VECTOR PREDICTOR ===== |
| //=========================================== |
| |
| if (input->SearchMode == UM_HEX) |
| UMHEXSetMotionVectorPredictor(pred_mv, enc_picture->ref_idx[list], enc_picture->mv[list], ref, list, block_x, block_y, bsx, bsy, &search_range); |
| else |
| SetMotionVectorPredictor (pred_mv, enc_picture->ref_idx[list], enc_picture->mv[list], ref, list, block_x, block_y, bsx, bsy); |
| |
| //================================== |
| //===== INTEGER-PEL SEARCH ===== |
| //================================== |
| |
| if (input->SearchMode == UM_HEX) |
| { |
| mv[0] = pred_mv[0] / 4; |
| mv[1] = pred_mv[1] / 4; |
| |
| if (!input->rdopt) |
| { |
| //--- adjust search center so that the (0,0)-vector is inside --- |
| mv[0] = iClip3(-search_range, search_range, mv[0]); |
| mv[1] = iClip3(-search_range, search_range, mv[1]); |
| } |
| |
| mv[0] = iClip3(-2047 + search_range, 2047 - search_range, mv[0]); |
| mv[1] = iClip3(LEVELMVLIMIT[img->LevelIndex][0] + search_range, LEVELMVLIMIT[img->LevelIndex][1] - search_range, mv[1]); |
| |
| min_mcost = UMHEXIntegerPelBlockMotionSearch(orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], search_range, |
| min_mcost, lambda_factor[F_PEL]); |
| } |
| else if (input->SearchMode == UM_HEX_SIMPLE) |
| { |
| mv[0] = pred_mv[0] / 4; |
| mv[1] = pred_mv[1] / 4; |
| |
| if (!input->rdopt) |
| { |
| //--- adjust search center so that the (0,0)-vector is inside --- |
| mv[0] = iClip3(-search_range, search_range, mv[0]); |
| mv[1] = iClip3(-search_range, search_range, mv[1]); |
| } |
| |
| mv[0] = iClip3(-2047 + search_range, 2047 - search_range, mv[0]); |
| mv[1] = iClip3(LEVELMVLIMIT[img->LevelIndex][0] + search_range, LEVELMVLIMIT[img->LevelIndex][1] - search_range, mv[1]); |
| |
| |
| min_mcost = smpUMHEXIntegerPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], search_range, |
| min_mcost, lambda_factor[F_PEL]); |
| for (i=0; i < (bsx>>2); i++) |
| { |
| for (j=0; j < (bsy>>2); j++) |
| { |
| if(list == 0) |
| { |
| smpUMHEX_l0_cost[blocktype][(img->pix_y>>2)+block_y+j][(img->pix_x>>2)+block_x+i] = min_mcost; |
| } |
| else |
| { |
| smpUMHEX_l1_cost[blocktype][(img->pix_y>>2)+block_y+j][(img->pix_x>>2)+block_x+i] = min_mcost; |
| } |
| } |
| } |
| } |
| //--- perform motion search using EPZS schemes--- |
| else if (input->SearchMode == EPZS) |
| { |
| //--- set search center --- |
| // This has to be modified in the future |
| if (input->EPZSSubPelGrid) |
| { |
| mv[0] = pred_mv[0]; |
| mv[1] = pred_mv[1]; |
| } |
| else |
| { |
| mv[0] = (pred_mv[0] + 2)>> 2; |
| mv[1] = (pred_mv[1] + 2)>> 2; |
| } |
| |
| if (!input->rdopt) |
| { |
| //--- adjust search center so that the (0,0)-vector is inside --- |
| mv[0] = iClip3 (-search_range<<(input->EPZSSubPelGrid * 2), search_range<<(input->EPZSSubPelGrid * 2), mv[0]); |
| mv[1] = iClip3 (-search_range<<(input->EPZSSubPelGrid * 2), search_range<<(input->EPZSSubPelGrid * 2), mv[1]); |
| } |
| |
| // valid search range limits could be precomputed once during the initialization process |
| mv[0] = iClip3((-2047 + search_range)<<(input->EPZSSubPelGrid * 2), (2047 - search_range)<<(input->EPZSSubPelGrid * 2), mv[0]); |
| mv[1] = iClip3((LEVELMVLIMIT[img->LevelIndex][0] + search_range)<<(input->EPZSSubPelGrid * 2), |
| (LEVELMVLIMIT[img->LevelIndex][1] - search_range)<<(input->EPZSSubPelGrid * 2), mv[1]); |
| |
| min_mcost = EPZSPelBlockMotionSearch (orig_pic, ref, list, list_offset, |
| enc_picture->ref_idx, enc_picture->mv, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv, mv, search_range<<(input->EPZSSubPelGrid * 2), min_mcost, lambda_factor[F_PEL]); |
| |
| } |
| else if (input->SearchMode == FAST_FULL_SEARCH) |
| { |
| // comments: - orig_pic is not used -> be careful |
| // - search center is automatically determined |
| min_mcost = FastFullPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], search_range, |
| min_mcost, lambda_factor[F_PEL]); |
| } |
| else |
| { |
| //--- set search center --- |
| mv[0] = pred_mv[0] / 4; |
| mv[1] = pred_mv[1] / 4; |
| if (!input->rdopt) |
| { |
| //--- adjust search center so that the (0,0)-vector is inside --- |
| mv[0] = iClip3 (-search_range, search_range, mv[0]); |
| mv[1] = iClip3 (-search_range, search_range, mv[1]); |
| } |
| |
| mv[0] = iClip3(-2047 + search_range, 2047 - search_range, mv[0]); |
| mv[1] = iClip3(LEVELMVLIMIT[img->LevelIndex][0] + search_range, LEVELMVLIMIT[img->LevelIndex][1] - search_range, mv[1]); |
| |
| //--- perform motion search --- |
| min_mcost = FullPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], search_range, |
| min_mcost, lambda_factor[F_PEL]); |
| } |
| //===== convert search center to quarter-pel units ===== |
| if (input->EPZSSubPelGrid == 0 || input->SearchMode != EPZS) |
| { |
| mv[0] <<= 2; |
| mv[1] <<= 2; |
| } |
| //============================== |
| //===== SUB-PEL SEARCH ===== |
| //============================== |
| ChromaMEEnable = (input->ChromaMEEnable == ME_YUV_FP_SP ) ? 1 : 0; // set it externally |
| |
| if (!input->DisableSubpelME) |
| { |
| if (input->SearchMode != EPZS || (ref == 0 || img->structure != FRAME || (ref > 0 && min_mcost < 3.5 * prevSad[pic_pix_x >> 2]))) |
| { |
| if ( !start_me_refinement_hp ) |
| { |
| min_mcost = max_value; |
| } |
| |
| if (input->SearchMode == UM_HEX) |
| { |
| if(blocktype >3) |
| { |
| min_mcost = UMHEXSubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], 9, 9, min_mcost, lambda_factor[Q_PEL]); |
| } |
| else |
| { |
| min_mcost = SubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], 9, 9, min_mcost, lambda_factor); |
| } |
| } |
| else if (input->SearchMode == UM_HEX_SIMPLE) |
| { |
| if(blocktype > 1) |
| { |
| min_mcost = smpUMHEXSubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, |
| blocktype, pred_mv[0], pred_mv[1], &mv[0], &mv[1], 9, 9, min_mcost, lambda_factor[Q_PEL]); |
| } |
| else |
| { |
| min_mcost = smpUMHEXFullSubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, |
| blocktype, pred_mv[0], pred_mv[1], &mv[0], &mv[1], 9, 9, min_mcost, lambda_factor[Q_PEL]); |
| } |
| } |
| else if (input->SearchMode == EPZS && input->EPZSSubPelME) |
| { |
| min_mcost = EPZSSubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv, mv, 9, 9, min_mcost, lambda_factor); |
| } |
| else |
| { |
| min_mcost = SubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], &mv[0], &mv[1], 9, 9, min_mcost, lambda_factor); |
| } |
| } |
| } |
| |
| if (!input->rdopt) |
| { |
| // Get the skip mode cost |
| if (blocktype == 1 && (img->type == P_SLICE||img->type == SP_SLICE)) |
| { |
| int cost; |
| |
| FindSkipModeMotionVector (); |
| |
| cost = GetSkipCostMB (); |
| cost -= ((lambda_factor[Q_PEL] + 4096) >> 13); |
| |
| if (cost < min_mcost) |
| { |
| min_mcost = cost; |
| mv[0] = img->all_mv [0][0][0][0][0][0]; |
| mv[1] = img->all_mv [0][0][0][0][0][1]; |
| } |
| } |
| } |
| |
| //=============================================== |
| //===== SET MV'S AND RETURN MOTION COST ===== |
| //=============================================== |
| |
| for (j=block_y; j < block_y + (bsy>>2); j++) |
| { |
| for (i=block_x; i < block_x + (bsx>>2); i++) |
| { |
| all_mv[j][i][list][ref][blocktype][0] = mv[0]; |
| all_mv[j][i][list][ref][blocktype][1] = mv[1]; |
| } |
| } |
| |
| if (img->type==B_SLICE && input->BiPredMotionEstimation!=0 && (blocktype == 1) && (ref==0)) |
| { |
| short ******bipred_mv = list ? img->bipred_mv1 : img->bipred_mv2; |
| int min_mcostbi = max_value; |
| short bimv[2] = {0, 0}, tempmv[2] = {0, 0}; |
| short *pred_mv1 = NULL; |
| short *pred_mv2 = NULL; |
| short iterlist=list; |
| short pred_mv_bi[2]; |
| |
| if (input->SearchMode == UM_HEX) |
| { |
| bipred_flag = 1; |
| UMHEXSetMotionVectorPredictor(pred_mv_bi, enc_picture->ref_idx[list ^ 1], enc_picture->mv[(list == LIST_0? LIST_1: LIST_0)], 0, (list == LIST_0? LIST_1: LIST_0), block_x, block_y, bsx, bsy, &search_range); |
| } |
| else |
| SetMotionVectorPredictor (pred_mv_bi, enc_picture->ref_idx[list ^ 1], enc_picture->mv[(list == LIST_0? LIST_1: LIST_0)], 0, (list == LIST_0? LIST_1: LIST_0), block_x, block_y, bsx, bsy); |
| |
| if ((input->SearchMode != EPZS) || (input->EPZSSubPelGrid == 0)) |
| { |
| mv[0]=(mv[0] + 2)>>2; |
| mv[1]=(mv[1] + 2)>>2; |
| } |
| |
| //Bi-predictive motion Refinements |
| for (i=0;i<=input->BiPredMERefinements;i++) |
| { |
| if (i%2) |
| { |
| pred_mv2=pred_mv; |
| pred_mv1=pred_mv_bi; |
| tempmv[0]=bimv[0]; |
| tempmv[1]=bimv[1]; |
| bimv[0]=mv[0]; |
| bimv[1]=mv[1]; |
| iterlist= list ^ 1; |
| } |
| else |
| { |
| pred_mv1=pred_mv; |
| pred_mv2=pred_mv_bi; |
| |
| if (i!=0) |
| { |
| tempmv[0]=bimv[0]; |
| tempmv[1]=bimv[1]; |
| bimv[0]=mv[0]; |
| bimv[1]=mv[1]; |
| } |
| else |
| { |
| tempmv[0]=mv[0]; |
| tempmv[1]=mv[1]; |
| if ((input->SearchMode != EPZS) || (input->EPZSSubPelGrid == 0)) |
| { |
| bimv[0] = (pred_mv2[0] + 2)>>2; |
| bimv[1] = (pred_mv2[1] + 2)>>2; |
| } |
| else |
| { |
| bimv[0] = pred_mv2[0]; |
| bimv[1] = pred_mv2[1]; |
| } |
| } |
| |
| iterlist=list; |
| } |
| mv[0]=bimv[0]; |
| mv[1]=bimv[1]; |
| |
| if (input->SearchMode == EPZS) |
| { |
| min_mcostbi = EPZSBiPredBlockMotionSearch (orig_pic, ref, iterlist, |
| list_offset, enc_picture->ref_idx, enc_picture->mv, |
| pic_pix_x, pic_pix_y, blocktype, |
| pred_mv1, pred_mv2, bimv, tempmv, |
| (input->BiPredMESearchRange<<(input->EPZSSubPelGrid * 2))>>i, min_mcostbi, lambda_factor[F_PEL]); |
| } |
| else if(input->SearchMode == UM_HEX) |
| { |
| min_mcostbi = UMHEXBipredIntegerPelBlockMotionSearch (orig_pic, ref, iterlist, |
| pic_pix_x, pic_pix_y, blocktype, |
| pred_mv1[0], pred_mv1[1], pred_mv2[0], pred_mv2[1], |
| &bimv[0], &bimv[1], &tempmv[0], &tempmv[1], |
| input->BiPredMESearchRange>>i, min_mcostbi, lambda_factor[F_PEL]); |
| } |
| else if(input->SearchMode == UM_HEX_SIMPLE) |
| { |
| min_mcostbi = smpUMHEXBipredIntegerPelBlockMotionSearch (orig_pic, ref, iterlist, |
| pic_pix_x, pic_pix_y, blocktype, |
| pred_mv[0], pred_mv[1], pred_mv[0], pred_mv[1], |
| &bimv[0], &bimv[1], &tempmv[0], &tempmv[1], |
| input->BiPredMESearchRange>>i, min_mcostbi, lambda_factor[F_PEL]); |
| } |
| else |
| { |
| min_mcostbi = FullPelBlockMotionBiPred (orig_pic, ref, iterlist, |
| pic_pix_x, pic_pix_y, blocktype, |
| pred_mv1[0], pred_mv1[1], pred_mv2[0], pred_mv2[1], |
| &bimv[0], &bimv[1], &tempmv[0], &tempmv[1], |
| input->BiPredMESearchRange>>i, min_mcostbi, lambda_factor[F_PEL]); |
| } |
| if ((mv[0] == bimv[0]) && (mv[1] == bimv[1])) |
| { |
| //mv[0]=tempmv[0]; |
| //mv[1]=tempmv[1]; |
| //break; |
| } |
| |
| mv[0]=tempmv[0]; |
| mv[1]=tempmv[1]; |
| } |
| if ((input->SearchMode != EPZS) || (input->EPZSSubPelGrid == 0)) |
| { |
| mv[0]=tempmv[0] << 2; |
| mv[1]=tempmv[1] << 2; |
| bimv[0] = bimv[0] << 2; |
| bimv[1] = bimv[1] << 2; |
| } |
| |
| if (input->BiPredMESubPel && !input->DisableSubpelME) |
| { |
| if ( !start_me_refinement_hp ) |
| { |
| min_mcostbi = max_value; |
| } |
| |
| if (input->SearchMode == EPZS && input->EPZSSubPelMEBiPred) |
| { |
| min_mcostbi = EPZSSubPelBlockSearchBiPred (orig_pic, ref, iterlist, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv2, pred_mv1, bimv, mv, 9, 9, min_mcostbi, lambda_factor); |
| } |
| else |
| { |
| min_mcostbi = SubPelBlockSearchBiPred (orig_pic, ref, iterlist, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv2[0], pred_mv2[1], &bimv[0], &bimv[1], &mv[0], &mv[1], 9, 9, |
| min_mcostbi, lambda_factor); |
| } |
| } |
| |
| if (input->BiPredMESubPel==2 && !input->DisableSubpelME) |
| { |
| if ( !start_me_refinement_hp || !start_me_refinement_qp) |
| { |
| min_mcostbi = max_value; |
| } |
| |
| if (input->SearchMode == EPZS && input->EPZSSubPelMEBiPred) |
| { |
| min_mcostbi = EPZSSubPelBlockSearchBiPred (orig_pic, ref, iterlist ^ 1, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv1, pred_mv2, mv, bimv, 9, 9, min_mcostbi, lambda_factor); |
| } |
| else |
| { |
| min_mcostbi = SubPelBlockSearchBiPred (orig_pic, ref, iterlist ^ 1, pic_pix_x, pic_pix_y, blocktype, |
| pred_mv1[0], pred_mv1[1], &mv[0], &mv[1], &bimv[0], &bimv[1], 9, 9, |
| min_mcostbi, lambda_factor); |
| } |
| } |
| |
| for (j=block_y; j < block_y + (bsy>>2); j++) |
| { |
| for (i=block_x ; i < block_x + (bsx>>2); i++) |
| { |
| bipred_mv[j][i][iterlist ][0][blocktype][0] = mv[0]; |
| bipred_mv[j][i][iterlist ][0][blocktype][1] = mv[1]; |
| bipred_mv[j][i][iterlist ^ 1][0][blocktype][0] = bimv[0]; |
| bipred_mv[j][i][iterlist ^ 1][0][blocktype][1] = bimv[1]; |
| } |
| } |
| } |
| |
| #if GET_METIME |
| ftime(&tstruct2); // end time ms |
| me_tmp_time=(tstruct2.time*1000+tstruct2.millitm) - (tstruct1.time*1000+tstruct1.millitm); |
| me_tot_time += me_tmp_time; |
| me_time += me_tmp_time; |
| #endif |
| return min_mcost; |
| } |
| |
| |
| /*! |
| *********************************************************************** |
| * \brief |
| * Motion Cost for Bidirectional modes |
| *********************************************************************** |
| */ |
| int BIDPartitionCost (int blocktype, |
| int block8x8, |
| short ref_l0, |
| short ref_l1, |
| int lambda_factor) |
| { |
| static int bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}}; |
| static int by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}}; |
| |
| int curr_blk[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; // ABT pred.error buffer |
| int bsx = imin(input->blc_size[blocktype][0],8); |
| int bsy = imin(input->blc_size[blocktype][1],8); |
| |
| int pic_pix_x, pic_pix_y, block_x, block_y; |
| int v, h, mcost, i, j, k; |
| int mvd_bits = 0; |
| int parttype = (blocktype<4?blocktype:4); |
| int step_h0 = (input->part_size[ parttype][0]); |
| int step_v0 = (input->part_size[ parttype][1]); |
| int step_h = (input->part_size[blocktype][0]); |
| int step_v = (input->part_size[blocktype][1]); |
| int bxx, byy; // indexing curr_blk |
| int bx = bx0[parttype][block8x8]; |
| int by = by0[parttype][block8x8]; |
| short ******all_mv = img->all_mv; |
| short ****** p_mv = img->pred_mv; |
| |
| //----- cost for motion vector bits ----- |
| for (v=by; v<by + step_v0; v+=step_v) |
| { |
| for (h=bx; h<bx + step_h0; h+=step_h) |
| { |
| mvd_bits += mvbits[ all_mv [v][h][LIST_0][ref_l0][blocktype][0] - p_mv[v][h][LIST_0][ref_l0][blocktype][0] ]; |
| mvd_bits += mvbits[ all_mv [v][h][LIST_0][ref_l0][blocktype][1] - p_mv[v][h][LIST_0][ref_l0][blocktype][1] ]; |
| |
| mvd_bits += mvbits[ all_mv [v][h][LIST_1][ref_l1][blocktype][0] - p_mv[v][h][LIST_1][ref_l1][blocktype][0] ]; |
| mvd_bits += mvbits[ all_mv [v][h][LIST_1][ref_l1][blocktype][1] - p_mv[v][h][LIST_1][ref_l1][blocktype][1] ]; |
| } |
| } |
| |
| mcost = WEIGHTED_COST (lambda_factor, mvd_bits); |
| |
| //----- cost of residual signal ----- |
| for (byy=0, v=by; v<by + step_v0; byy+=4, v++) |
| { |
| pic_pix_y = img->opix_y + (block_y = (v<<2)); |
| for (bxx=0, h=bx; h<bx + step_h0; bxx+=4, h++) |
| { |
| pic_pix_x = img->opix_x + (block_x = (h<<2)); |
| LumaPrediction4x4 (block_x, block_y, 2, blocktype, blocktype, ref_l0, ref_l1); |
| |
| for (k=j=0; j<4; j++) |
| { |
| for ( i=0; i<4; i++) |
| diff64[k++] = curr_blk[byy+j][bxx+i] = |
| imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mpr[j+block_y][i+block_x]; |
| } |
| if ((!input->Transform8x8Mode) || (blocktype>4)) |
| mcost += distortion4x4 (diff64); |
| } |
| } |
| if (input->Transform8x8Mode && (blocktype<=4)) // tchen 4-29-04 |
| { |
| for (byy=0; byy < input->blc_size[parttype][1]; byy+=bsy) |
| for (bxx=0; bxx<input->blc_size[parttype][0]; bxx+=bsx) |
| { |
| for (k=0, j=byy;j<byy + 8;j++, k += 8) |
| memcpy(&diff64[k], &(curr_blk[j][bxx]), 8 * sizeof(int)); |
| |
| mcost += distortion8x8(diff64); |
| } |
| } |
| return mcost; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Get cost for skip mode for an macroblock |
| ************************************************************************ |
| */ |
| int GetSkipCostMB (void) |
| { |
| int block_y, block_x, pic_pix_y, pic_pix_x, i, j, k; |
| int cost = 0; |
| |
| int curr_diff[8][8]; |
| int mb_x, mb_y; |
| int block; |
| for(block=0;block<4;block++) |
| { |
| mb_y = (block/2)<<3; |
| mb_x = (block%2)<<3; |
| for (block_y=mb_y; block_y<mb_y+8; block_y+=4) |
| { |
| pic_pix_y = img->opix_y + block_y; |
| for (block_x=mb_x; block_x<mb_x+8; block_x+=4) |
| { |
| pic_pix_x = img->opix_x + block_x; |
| |
| //===== prediction of 4x4 block ===== |
| LumaPrediction4x4 (block_x, block_y, 0, 0, 0, 0, 0); |
| |
| //===== get displaced frame difference ====== |
| for (k=j=0; j<4; j++) |
| for (i=0; i<4; i++, k++) |
| { |
| diff[k] = curr_diff[block_y-mb_y+j][block_x-mb_x+i] = imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mpr[j+block_y][i+block_x]; |
| } |
| |
| if(!((input->rdopt==0)&&(input->Transform8x8Mode))) |
| cost += distortion4x4 (diff); |
| } |
| } |
| |
| if((input->rdopt==0)&&(input->Transform8x8Mode)) |
| { |
| for(k=j=0; j<8; j++, k+=8) |
| memcpy(&diff64[k], &(curr_diff[j]), 8 * sizeof(int)); |
| cost += distortion8x8 (diff64); |
| } |
| } |
| |
| return cost; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Find motion vector for the Skip mode |
| ************************************************************************ |
| */ |
| void FindSkipModeMotionVector () |
| { |
| int bx, by; |
| short ******all_mv = img->all_mv; |
| |
| short pmv[2]; |
| |
| int zeroMotionAbove; |
| int zeroMotionLeft; |
| PixelPos mb_a, mb_b; |
| int a_mv_y = 0; |
| int a_ref_idx = 0; |
| int b_mv_y = 0; |
| int b_ref_idx = 0; |
| short ***mv = enc_picture->mv[LIST_0]; |
| |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| |
| getLuma4x4Neighbour(img->current_mb_nr,-1, 0, &mb_a); |
| getLuma4x4Neighbour(img->current_mb_nr, 0,-1, &mb_b); |
| |
| if (mb_a.available) |
| { |
| a_mv_y = mv[mb_a.pos_y][mb_a.pos_x][1]; |
| a_ref_idx = enc_picture->ref_idx[LIST_0][mb_a.pos_y][mb_a.pos_x]; |
| |
| if (currMB->mb_field && !img->mb_data[mb_a.mb_addr].mb_field) |
| { |
| a_mv_y /=2; |
| a_ref_idx *=2; |
| } |
| if (!currMB->mb_field && img->mb_data[mb_a.mb_addr].mb_field) |
| { |
| a_mv_y *=2; |
| a_ref_idx >>=1; |
| } |
| } |
| |
| if (mb_b.available) |
| { |
| b_mv_y = mv[mb_b.pos_y][mb_b.pos_x][1]; |
| b_ref_idx = enc_picture->ref_idx[LIST_0][mb_b.pos_y][mb_b.pos_x]; |
| |
| if (currMB->mb_field && !img->mb_data[mb_b.mb_addr].mb_field) |
| { |
| b_mv_y /=2; |
| b_ref_idx *=2; |
| } |
| if (!currMB->mb_field && img->mb_data[mb_b.mb_addr].mb_field) |
| { |
| b_mv_y *=2; |
| b_ref_idx >>=1; |
| } |
| } |
| |
| zeroMotionLeft = !mb_a.available ? 1 : a_ref_idx==0 && mv[mb_a.pos_y][mb_a.pos_x][0]==0 && a_mv_y==0 ? 1 : 0; |
| zeroMotionAbove = !mb_b.available ? 1 : b_ref_idx==0 && mv[mb_b.pos_y][mb_b.pos_x][0]==0 && b_mv_y==0 ? 1 : 0; |
| |
| if (zeroMotionAbove || zeroMotionLeft) |
| { |
| for (by = 0;by < 4;by++) |
| for (bx = 0;bx < 4;bx++) |
| { |
| memset(all_mv [by][bx][0][0][0], 0, 2* sizeof(short)); |
| //all_mv [by][bx][0][0][0][0] = 0; |
| //all_mv [by][bx][0][0][0][1] = 0; |
| } |
| } |
| else |
| { |
| SetMotionVectorPredictor (pmv, enc_picture->ref_idx[LIST_0], mv, 0, LIST_0, 0, 0, 16, 16); |
| for (by = 0;by < 4;by++) |
| for (bx = 0;bx < 4;bx++) |
| { |
| memcpy(all_mv [by][bx][0][0][0], pmv, 2* sizeof(short)); |
| } |
| } |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Get cost for direct mode for an 8x8 block |
| ************************************************************************ |
| */ |
| int GetDirectCost8x8 (int block, int *cost8x8) |
| { |
| int block_y, block_x, pic_pix_y, pic_pix_x, i, j, k; |
| int curr_diff[8][8]; |
| int cost = 0; |
| int mb_y = (block/2)<<3; |
| int mb_x = (block%2)<<3; |
| |
| for (block_y=mb_y; block_y<mb_y+8; block_y+=4) |
| { |
| pic_pix_y = img->opix_y + block_y; |
| |
| for (block_x=mb_x; block_x<mb_x+8; block_x+=4) |
| { |
| pic_pix_x = img->opix_x + block_x; |
| |
| if (direct_pdir[pic_pix_y>>2][pic_pix_x>>2]<0) |
| { |
| *cost8x8=INT_MAX; |
| return INT_MAX; //mode not allowed |
| } |
| |
| //===== prediction of 4x4 block ===== |
| |
| LumaPrediction4x4 (block_x, block_y, direct_pdir[pic_pix_y>>2][pic_pix_x>>2], 0, 0, |
| direct_ref_idx[LIST_0][pic_pix_y>>2][pic_pix_x>>2], |
| direct_ref_idx[LIST_1][pic_pix_y>>2][pic_pix_x>>2]); |
| |
| //===== get displaced frame difference ====== |
| for (k=j=0; j<4; j++) |
| for (i=0; i<4; i++, k++) |
| { |
| diff[k] = curr_diff[block_y-mb_y+j][block_x-mb_x+i] = |
| imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mpr[j+block_y][i+block_x]; |
| } |
| |
| cost += distortion4x4 (diff); |
| } |
| } |
| |
| if((input->rdopt==0)&&(input->Transform8x8Mode)) |
| { |
| k=0; |
| for(j=0; j<8; j++, k+=8) |
| memcpy(&diff64[k], &(curr_diff[j]), 8 * sizeof(int)); |
| |
| *cost8x8 += distortion8x8 (diff64); |
| } |
| |
| return cost; |
| } |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Get cost for direct mode for an macroblock |
| ************************************************************************ |
| */ |
| int GetDirectCostMB (void) |
| { |
| int i; |
| int cost = 0; |
| int cost8x8 = 0; |
| |
| for (i=0; i<4; i++) |
| { |
| cost += GetDirectCost8x8 (i, &cost8x8); |
| if (cost8x8 == INT_MAX) return INT_MAX; |
| } |
| |
| switch(input->Transform8x8Mode) |
| { |
| case 1: // Mixture of 8x8 & 4x4 transform |
| if((cost8x8 < cost)|| |
| !(input->InterSearch8x4 && |
| input->InterSearch4x8 && |
| input->InterSearch4x4) |
| ) |
| { |
| cost = cost8x8; //return 8x8 cost |
| } |
| break; |
| case 2: // 8x8 Transform only |
| cost = cost8x8; |
| break; |
| default: // 4x4 Transform only |
| break; |
| } |
| |
| return cost; |
| // T.Nishi(MEI ACC) 04-28-2004 end |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Motion search for a partition |
| ************************************************************************ |
| */ |
| void |
| PartitionMotionSearch (int blocktype, |
| int block8x8, |
| int *lambda_factor) |
| { |
| static int bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}}; |
| static int by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}}; |
| |
| signed char **ref_array; |
| short ***mv_array; |
| short *all_mv; |
| short ref; |
| int v, h, mcost, search_range, i, j; |
| int pic_block_x, pic_block_y; |
| int bslice = (img->type==B_SLICE); |
| int parttype = (blocktype<4?blocktype:4); |
| int step_h0 = (input->part_size[ parttype][0]); |
| int step_v0 = (input->part_size[ parttype][1]); |
| int step_h = (input->part_size[blocktype][0]); |
| int step_v = (input->part_size[blocktype][1]); |
| int list; |
| int numlists = bslice ? 2 : 1; |
| int list_offset = img->mb_data[img->current_mb_nr].list_offset; |
| int *m_cost; |
| int by = by0[parttype][block8x8]; |
| int bx = bx0[parttype][block8x8]; |
| |
| //===== LOOP OVER REFERENCE FRAMES ===== |
| for (list=0; list<numlists;list++) |
| { |
| for (ref=0; ref < listXsize[list+list_offset]; ref++) |
| { |
| m_cost = &motion_cost[blocktype][list][ref][block8x8]; |
| //----- set search range --- |
| #ifdef _FULL_SEARCH_RANGE_ |
| if (input->full_search == 2) |
| search_range = input->search_range; |
| else if (input->full_search == 1) |
| search_range = input->search_range / (imin(ref,1)+1); |
| else |
| search_range = input->search_range / ((imin(ref,1)+1) * imin(2,blocktype)); |
| #else |
| search_range = input->search_range / ((imin(ref,1)+1) * imin(2,blocktype)); |
| #endif |
| |
| //----- set arrays ----- |
| ref_array = enc_picture->ref_idx[list]; |
| mv_array = enc_picture->mv[list]; |
| |
| //----- init motion cost ----- |
| //motion_cost[blocktype][list][ref][block8x8] = 0; |
| *m_cost = 0; |
| |
| //===== LOOP OVER SUB MACRO BLOCK partitions |
| for (v=by; v<by + step_v0; v += step_v) |
| { |
| pic_block_y = img->block_y + v; |
| |
| for (h=bx; h<bx+step_h0; h+=step_h) |
| { |
| all_mv = img->all_mv[v][h][list][ref][blocktype]; |
| pic_block_x = img->block_x + h; |
| |
| //--- motion search for block --- |
| mcost = BlockMotionSearch (ref, list, h<<2, v<<2, blocktype, search_range, lambda_factor); |
| *m_cost += mcost; |
| |
| //--- set motion vectors and reference frame (for motion vector prediction) --- |
| for (j=pic_block_y; j<pic_block_y + step_v; j++) |
| { |
| memset(&ref_array [j][pic_block_x], ref, step_h * sizeof(char)); |
| |
| for (i=pic_block_x; i<pic_block_x + step_h; i++) |
| { |
| memcpy(mv_array [j][i], all_mv, 2* sizeof(short)); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Calculate Direct Motion Vectors ***** |
| ************************************************************************ |
| */ |
| void Get_Direct_Motion_Vectors () |
| { |
| |
| int block_x, block_y, pic_block_x, pic_block_y, opic_block_x, opic_block_y; |
| short ****all_mvs; |
| int mv_scale; |
| int refList; |
| int ref_idx; |
| |
| byte ** moving_block; |
| short **** co_located_mv; |
| signed char *** co_located_ref_idx; |
| int64 *** co_located_ref_id; |
| signed char ** ref_pic_l0 = enc_picture->ref_idx[LIST_0]; |
| signed char ** ref_pic_l1 = enc_picture->ref_idx[LIST_1]; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| |
| if (currMB->list_offset) |
| { |
| if(img->current_mb_nr%2) |
| { |
| moving_block = Co_located->bottom_moving_block; |
| co_located_mv = Co_located->bottom_mv; |
| co_located_ref_idx = Co_located->bottom_ref_idx; |
| co_located_ref_id = Co_located->bottom_ref_pic_id; |
| } |
| else |
| { |
| moving_block = Co_located->top_moving_block; |
| co_located_mv = Co_located->top_mv; |
| co_located_ref_idx = Co_located->top_ref_idx; |
| co_located_ref_id = Co_located->top_ref_pic_id; |
| } |
| } |
| else |
| { |
| moving_block = Co_located->moving_block; |
| co_located_mv = Co_located->mv; |
| co_located_ref_idx = Co_located->ref_idx; |
| co_located_ref_id = Co_located->ref_pic_id; |
| } |
| |
| if (img->direct_spatial_mv_pred_flag) //spatial direct mode copy from decoder |
| { |
| |
| short l0_refA, l0_refB, l0_refD, l0_refC; |
| short l1_refA, l1_refB, l1_refD, l1_refC; |
| short l0_refX,l1_refX; |
| short pmvfw[2]={0,0},pmvbw[2]={0,0}; |
| |
| PixelPos mb_a, mb_b, mb_d, mb_c; |
| |
| getLuma4x4Neighbour(img->current_mb_nr, -1, 0,&mb_a); |
| getLuma4x4Neighbour(img->current_mb_nr, 0, -1,&mb_b); |
| getLuma4x4Neighbour(img->current_mb_nr, 16, -1,&mb_c); |
| getLuma4x4Neighbour(img->current_mb_nr, -1, -1,&mb_d); |
| |
| if (!img->MbaffFrameFlag) |
| { |
| l0_refA = mb_a.available ? ref_pic_l0[mb_a.pos_y][mb_a.pos_x] : -1; |
| l0_refB = mb_b.available ? ref_pic_l0[mb_b.pos_y][mb_b.pos_x] : -1; |
| l0_refD = mb_d.available ? ref_pic_l0[mb_d.pos_y][mb_d.pos_x] : -1; |
| l0_refC = mb_c.available ? ref_pic_l0[mb_c.pos_y][mb_c.pos_x] : l0_refD; |
| |
| l1_refA = mb_a.available ? ref_pic_l1[mb_a.pos_y][mb_a.pos_x] : -1; |
| l1_refB = mb_b.available ? ref_pic_l1[mb_b.pos_y][mb_b.pos_x] : -1; |
| l1_refD = mb_d.available ? ref_pic_l1[mb_d.pos_y][mb_d.pos_x] : -1; |
| l1_refC = mb_c.available ? ref_pic_l1[mb_c.pos_y][mb_c.pos_x] : l1_refD; |
| } |
| else |
| { |
| if (currMB->mb_field) |
| { |
| l0_refA = mb_a.available |
| ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l0[mb_a.pos_y][mb_a.pos_x] < 0 |
| ? ref_pic_l0[mb_a.pos_y][mb_a.pos_x] |
| : ref_pic_l0[mb_a.pos_y][mb_a.pos_x] * 2) : -1; |
| |
| l0_refB = mb_b.available |
| ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l0[mb_b.pos_y][mb_b.pos_x] < 0 |
| ? ref_pic_l0[mb_b.pos_y][mb_b.pos_x] |
| : ref_pic_l0[mb_b.pos_y][mb_b.pos_x] * 2) : -1; |
| |
| l0_refD = mb_d.available |
| ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l0[mb_d.pos_y][mb_d.pos_x] < 0 |
| ? ref_pic_l0[mb_d.pos_y][mb_d.pos_x] |
| : ref_pic_l0[mb_d.pos_y][mb_d.pos_x] * 2) : -1; |
| |
| l0_refC = mb_c.available |
| ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l0[mb_c.pos_y][mb_c.pos_x] < 0 |
| ? ref_pic_l0[mb_c.pos_y][mb_c.pos_x] |
| : ref_pic_l0[mb_c.pos_y][mb_c.pos_x] * 2) : l0_refD; |
| |
| l1_refA = mb_a.available |
| ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l1[mb_a.pos_y][mb_a.pos_x] < 0 |
| ? ref_pic_l1[mb_a.pos_y][mb_a.pos_x] |
| : ref_pic_l1[mb_a.pos_y][mb_a.pos_x] * 2) : -1; |
| |
| l1_refB = mb_b.available |
| ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l1[mb_b.pos_y][mb_b.pos_x] < 0 |
| ? ref_pic_l1[mb_b.pos_y][mb_b.pos_x] |
| : ref_pic_l1[mb_b.pos_y][mb_b.pos_x] * 2) : -1; |
| |
| l1_refD = mb_d.available |
| ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l1[mb_d.pos_y][mb_d.pos_x] < 0 |
| ? ref_pic_l1[mb_d.pos_y][mb_d.pos_x] |
| : ref_pic_l1[mb_d.pos_y][mb_d.pos_x] * 2) : -1; |
| |
| l1_refC = mb_c.available |
| ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l1[mb_c.pos_y][mb_c.pos_x] < 0 |
| ? ref_pic_l1[mb_c.pos_y][mb_c.pos_x] |
| : ref_pic_l1[mb_c.pos_y][mb_c.pos_x] * 2) : l1_refD; |
| } |
| else |
| { |
| l0_refA = mb_a.available |
| ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l0[mb_a.pos_y][mb_a.pos_x] < 0 |
| ? ref_pic_l0[mb_a.pos_y][mb_a.pos_x] >> 1 |
| : ref_pic_l0[mb_a.pos_y][mb_a.pos_x]) : -1; |
| |
| l0_refB = mb_b.available |
| ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l0[mb_b.pos_y][mb_b.pos_x] < 0 |
| ? ref_pic_l0[mb_b.pos_y][mb_b.pos_x] >> 1 |
| : ref_pic_l0[mb_b.pos_y][mb_b.pos_x]) : -1; |
| |
| l0_refD = mb_d.available |
| ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l0[mb_d.pos_y][mb_d.pos_x] < 0 |
| ? ref_pic_l0[mb_d.pos_y][mb_d.pos_x] >> 1 |
| : ref_pic_l0[mb_d.pos_y][mb_d.pos_x]) : -1; |
| |
| l0_refC = mb_c.available |
| ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l0[mb_c.pos_y][mb_c.pos_x] < 0 |
| ? ref_pic_l0[mb_c.pos_y][mb_c.pos_x] >> 1 |
| : ref_pic_l0[mb_c.pos_y][mb_c.pos_x]) : l0_refD; |
| |
| l1_refA = mb_a.available |
| ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l1[mb_a.pos_y][mb_a.pos_x] < 0 |
| ? ref_pic_l1[mb_a.pos_y][mb_a.pos_x] >> 1 |
| : ref_pic_l1[mb_a.pos_y][mb_a.pos_x]) : -1; |
| |
| l1_refB = mb_b.available |
| ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l1[mb_b.pos_y][mb_b.pos_x] < 0 |
| ? ref_pic_l1[mb_b.pos_y][mb_b.pos_x] >> 1 |
| : ref_pic_l1[mb_b.pos_y][mb_b.pos_x]) : -1; |
| |
| l1_refD = mb_d.available |
| ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l1[mb_d.pos_y][mb_d.pos_x] < 0 |
| ? ref_pic_l1[mb_d.pos_y][mb_d.pos_x] >> 1 |
| : ref_pic_l1[mb_d.pos_y][mb_d.pos_x]) : -1; |
| |
| l1_refC = mb_c.available |
| ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l1[mb_c.pos_y][mb_c.pos_x] < 0 |
| ? ref_pic_l1[mb_c.pos_y][mb_c.pos_x] >> 1 |
| : ref_pic_l1[mb_c.pos_y][mb_c.pos_x]) : l1_refD; |
| } |
| } |
| |
| l0_refX = (l0_refA >= 0 && l0_refB >= 0) ? imin(l0_refA,l0_refB): imax(l0_refA,l0_refB); |
| l0_refX = (l0_refX >= 0 && l0_refC >= 0) ? imin(l0_refX,l0_refC): imax(l0_refX,l0_refC); |
| |
| l1_refX = (l1_refA >= 0 && l1_refB >= 0) ? imin(l1_refA,l1_refB): imax(l1_refA,l1_refB); |
| l1_refX = (l1_refX >= 0 && l1_refC >= 0) ? imin(l1_refX,l1_refC): imax(l1_refX,l1_refC); |
| |
| if (l0_refX >=0) |
| SetMotionVectorPredictor (pmvfw, enc_picture->ref_idx[LIST_0], enc_picture->mv[LIST_0], l0_refX, LIST_0, 0, 0, 16, 16); |
| |
| if (l1_refX >=0) |
| SetMotionVectorPredictor (pmvbw, enc_picture->ref_idx[LIST_1], enc_picture->mv[LIST_1], l1_refX, LIST_1, 0, 0, 16, 16); |
| |
| for (block_y=0; block_y<4; block_y++) |
| { |
| pic_block_y = (img->pix_y >> 2) + block_y; |
| opic_block_y = (img->opix_y >> 2) + block_y; |
| |
| for (block_x=0; block_x<4; block_x++) |
| { |
| pic_block_x = (img->pix_x >> 2) + block_x; |
| opic_block_x = (img->opix_x >> 2) + block_x; |
| |
| all_mvs = img->all_mv[block_y][block_x]; |
| |
| if (l0_refX >=0) |
| { |
| if (!l0_refX && !moving_block[opic_block_y][opic_block_x]) |
| { |
| |
| memset(all_mvs[LIST_0][0][0], 0, 2* sizeof(short)); |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x]=0; |
| } |
| else |
| { |
| all_mvs[LIST_0][l0_refX][0][0] = pmvfw[0]; |
| all_mvs[LIST_0][l0_refX][0][1] = pmvfw[1]; |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x]= (signed char)l0_refX; |
| } |
| } |
| else |
| { |
| all_mvs[LIST_0][0][0][0] = 0; |
| all_mvs[LIST_0][0][0][1] = 0; |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x]=-1; |
| } |
| |
| if (l1_refX >=0) |
| { |
| if(l1_refX==0 && !moving_block[opic_block_y][opic_block_x]) |
| { |
| all_mvs[LIST_1][0][0][0] = 0; |
| all_mvs[LIST_1][0][0][1] = 0; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x]= (signed char)l1_refX; |
| } |
| else |
| { |
| all_mvs[LIST_1][l1_refX][0][0] = pmvbw[0]; |
| all_mvs[LIST_1][l1_refX][0][1] = pmvbw[1]; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x]= (signed char)l1_refX; |
| } |
| } |
| else |
| { |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x]=-1; |
| |
| all_mvs[LIST_1][0][0][0] = 0; |
| all_mvs[LIST_1][0][0][1] = 0; |
| } |
| |
| // Test Level Limits if satisfied. |
| if (img->MbaffFrameFlag |
| && (all_mvs[LIST_0][l0_refX < 0? 0 : l0_refX][0][0] < -8192 |
| || all_mvs[LIST_0][l0_refX < 0? 0 : l0_refX][0][0] > 8191 |
| || all_mvs[LIST_0][l0_refX < 0? 0 : l0_refX][0][1] < LEVELMVLIMIT[img->LevelIndex][4] |
| || all_mvs[LIST_0][l0_refX < 0? 0 : l0_refX][0][1] > LEVELMVLIMIT[img->LevelIndex][5] |
| || all_mvs[LIST_1][l1_refX < 0? 0 : l1_refX][0][0] < -8192 |
| || all_mvs[LIST_1][l1_refX < 0? 0 : l1_refX][0][0] > 8191 |
| || all_mvs[LIST_1][l1_refX < 0? 0 : l1_refX][0][1] < LEVELMVLIMIT[img->LevelIndex][4] |
| || all_mvs[LIST_1][l1_refX < 0? 0 : l1_refX][0][1] > LEVELMVLIMIT[img->LevelIndex][5])) |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1; |
| direct_pdir [pic_block_y][pic_block_x] = -1; |
| } |
| else |
| { |
| if (l0_refX < 0 && l1_refX < 0) |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = 0; |
| l0_refX = 0; |
| l1_refX = 0; |
| } |
| if (direct_ref_idx[LIST_1][pic_block_y][pic_block_x] == -1) |
| direct_pdir[pic_block_y][pic_block_x] = 0; |
| else if (direct_ref_idx[LIST_0][pic_block_y][pic_block_x] == -1) |
| direct_pdir[pic_block_y][pic_block_x] = 1; |
| else if (active_pps->weighted_bipred_idc == 1) |
| { |
| int weight_sum, i; |
| Boolean invalid_wp = FALSE; |
| for (i=0;i< (active_sps->chroma_format_idc == YUV400 ? 1 : 3); i++) |
| { |
| weight_sum = wbp_weight[0][l0_refX][l1_refX][i] + wbp_weight[1][l0_refX][l1_refX][i]; |
| if (weight_sum < -128 || weight_sum > 127) |
| { |
| invalid_wp = TRUE; |
| break; |
| } |
| } |
| if (invalid_wp == FALSE) |
| direct_pdir[pic_block_y][pic_block_x] = 2; |
| else |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1; |
| direct_pdir [pic_block_y][pic_block_x] = -1; |
| } |
| } |
| else |
| direct_pdir[pic_block_y][pic_block_x] = 2; |
| } |
| } |
| } |
| } |
| else |
| { |
| int64 *refpic = enc_picture->ref_pic_num[LIST_0 +currMB->list_offset]; |
| |
| //temporal direct mode copy from decoder |
| for (block_y = 0; block_y < 4; block_y++) |
| { |
| pic_block_y = (img->pix_y >> 2) + block_y; |
| opic_block_y = (img->opix_y >> 2) + block_y; |
| |
| for (block_x = 0; block_x < 4; block_x++) |
| { |
| pic_block_x = (img->pix_x>>2) + block_x; |
| opic_block_x = (img->opix_x>>2) + block_x; |
| all_mvs = img->all_mv[block_y][block_x]; |
| |
| refList = (co_located_ref_idx[LIST_0][opic_block_y][opic_block_x]== -1 ? LIST_1 : LIST_0); |
| ref_idx = co_located_ref_idx[refList][opic_block_y][opic_block_x]; |
| |
| // next P is intra mode |
| if (ref_idx==-1) |
| { |
| all_mvs[LIST_0][0][0][0] = 0; |
| all_mvs[LIST_0][0][0][1] = 0; |
| all_mvs[LIST_1][0][0][0] = 0; |
| all_mvs[LIST_1][0][0][1] = 0; |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = 0; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = 0; |
| direct_pdir[pic_block_y][pic_block_x] = 2; |
| } |
| // next P is skip or inter mode |
| else |
| { |
| int mapped_idx=INVALIDINDEX; |
| int iref; |
| |
| for (iref=0;iref<imin(img->num_ref_idx_l0_active,listXsize[LIST_0+currMB->list_offset]);iref++) |
| { |
| if (refpic[iref]==co_located_ref_id[refList ][opic_block_y][opic_block_x]) |
| { |
| mapped_idx=iref; |
| break; |
| } |
| else //! invalid index. Default to zero even though this case should not happen |
| { |
| mapped_idx=INVALIDINDEX; |
| } |
| } |
| |
| if (mapped_idx !=INVALIDINDEX) |
| { |
| mv_scale = img->mvscale[LIST_0+currMB->list_offset][mapped_idx]; |
| |
| if (mv_scale==9999) |
| { |
| // forward |
| all_mvs[LIST_0][0][0][0] = co_located_mv[refList][opic_block_y][opic_block_x][0]; |
| all_mvs[LIST_0][0][0][1] = co_located_mv[refList][opic_block_y][opic_block_x][1]; |
| // backward |
| all_mvs[LIST_1][0][0][0] = 0; |
| all_mvs[LIST_1][0][0][1] = 0; |
| } |
| else |
| { |
| // forward |
| all_mvs[LIST_0][mapped_idx][0][0] = (mv_scale * co_located_mv[refList][opic_block_y][opic_block_x][0] + 128) >> 8; |
| all_mvs[LIST_0][mapped_idx][0][1] = (mv_scale * co_located_mv[refList][opic_block_y][opic_block_x][1] + 128) >> 8; |
| // backward |
| all_mvs[LIST_1][ 0][0][0] = ((mv_scale - 256)* co_located_mv[refList][opic_block_y][opic_block_x][0] + 128) >> 8; |
| all_mvs[LIST_1][ 0][0][1] = ((mv_scale - 256)* co_located_mv[refList][opic_block_y][opic_block_x][1] + 128) >> 8; |
| } |
| |
| // Test Level Limits if satisfied. |
| if ( all_mvs[LIST_0][mapped_idx][0][0] < -8192 |
| || all_mvs[LIST_0][mapped_idx][0][0] > 8191 |
| || all_mvs[LIST_0][mapped_idx][0][1] < LEVELMVLIMIT[img->LevelIndex][4] |
| || all_mvs[LIST_0][mapped_idx][0][1] > LEVELMVLIMIT[img->LevelIndex][5] |
| || all_mvs[LIST_1][0][0][0] < -8192 |
| || all_mvs[LIST_1][0][0][0] > 8191 |
| || all_mvs[LIST_1][0][0][1] < LEVELMVLIMIT[img->LevelIndex][4] |
| || all_mvs[LIST_1][0][0][1] > LEVELMVLIMIT[img->LevelIndex][5]) |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1; |
| direct_pdir[pic_block_y][pic_block_x] = -1; |
| } |
| else |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = mapped_idx; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = 0; |
| direct_pdir[pic_block_y][pic_block_x] = 2; |
| } |
| } |
| else |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1; |
| direct_pdir[pic_block_y][pic_block_x] = -1; |
| } |
| } |
| if (active_pps->weighted_bipred_idc == 1 && direct_pdir[pic_block_y][pic_block_x] == 2) |
| { |
| int weight_sum, i; |
| short l0_refX = direct_ref_idx[LIST_0][pic_block_y][pic_block_x]; |
| short l1_refX = direct_ref_idx[LIST_1][pic_block_y][pic_block_x]; |
| for (i=0;i< (active_sps->chroma_format_idc == YUV400 ? 1 : 3); i++) |
| { |
| weight_sum = wbp_weight[0][l0_refX][l1_refX][i] + wbp_weight[1][l0_refX][l1_refX][i]; |
| if (weight_sum < -128 || weight_sum > 127) |
| { |
| direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1; |
| direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1; |
| direct_pdir [pic_block_y][pic_block_x] = -1; |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
