开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
me_umhex.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：55k
源码类别：

Audio

开发平台：

Visual C++

me_umhex.c：源码内容
  2. /*!
  3.  ************************************************************************
  4.  *
  5.  * file me_umhex.c
  6.  *
  7.  * brief
  8.  *   Fast integer pel motion estimation and fractional pel motion estimation
  9.  *   algorithms are described in this file.
  10.  *   1. UMHEX_get_mem() and UMHEX_free_mem() are functions for allocation and release
  11.  *      of memories about motion estimation
  12.  *   2. UMHEX_BlockMotionSearch() is the function for fast integer pel motion
  13.  *      estimation and fractional pel motion estimation
  14.  *   3. UMHEX_DefineThreshold() defined thresholds for early termination
  15.  * author
  16.  *    Main contributors: (see contributors.h for copyright, address and affiliation details)
  17.  *    - Zhibo Chen         <chenzhibo@tsinghua.org.cn>
  18.  *    - JianFeng Xu        <fenax@video.mdc.tsinghua.edu.cn>
  19.  *    - Wenfang Fu         <fwf@video.mdc.tsinghua.edu.cn>
  20.  *    - Xiaozhong Xu       <xxz@video.mdc.tsinghua.edu.cn>
  21.  * date
  22.  *    2006.1
  23.  ************************************************************************
  24.  */
  26. #include <limits.h>
  28. #include "global.h"
  29. #include "memalloc.h"
  30. #include "me_umhex.h"
  31. #include "refbuf.h"
  32. #include "mb_access.h"
  33. #include "image.h"
  34. #include "enc_statistics.h"
  35. #include "me_distortion.h"
  36. #include "mv-search.h"
  38. #define Q_BITS          15
  39. #define MIN_IMG_WIDTH   176
  40. extern  int*   byte_abs;
  42. extern  short*   spiral_search_x;
  43. extern  short*   spiral_search_y;
  46. static const int Diamond_x[4] = {-1, 0, 1, 0};
  47. static const int Diamond_y[4] = {0, 1, 0, -1};
  48. static const int Hexagon_x[6] = {2, 1, -1, -2, -1, 1};
  49. static const int Hexagon_y[6] = {0, -2, -2, 0,  2, 2};
  50. static const int Big_Hexagon_x[16] = {0,-2, -4,-4,-4, -4, -4, -2,  0,  2,  4,  4, 4, 4, 4, 2};
  51. static const int Big_Hexagon_y[16] = {4, 3, 2,  1, 0, -1, -2, -3, -4, -3, -2, -1, 0, 1, 2, 3};
  53. // for bipred mode
  54. static int pred_MV_ref_flag;
  55. static int dist_method;
  56. static StorablePicture *ref_pic_ptr;
  58. static const int   Multi_Ref_Thd[8]    = {0,  300,  120,  120,  60,  30,   30,  15};
  59. static const int   Big_Hexagon_Thd[8]  = {0, 3000, 1500, 1500, 800, 400,  400, 200};
  60. static const int   Median_Pred_Thd[8]  = {0,  750,  350,  350, 170,  80,   80,  40};
  61. static const int   Threshold_DSR[8]    = {0, 2200, 1000, 1000, 500, 250,  250, 120};
  63. static int BlockType_LUT[4][4];
  64. static int Median_Pred_Thd_MB[8];
  65. static int Big_Hexagon_Thd_MB[8];
  66. static int Multi_Ref_Thd_MB[8];
  68. extern const int quant_coef[6][4][4];
  71. void UMHEX_DefineThreshold()
  72. {
  73.   AlphaFourth_1[1] = 0.01f;
  74.   AlphaFourth_1[2] = 0.01f;
  75.   AlphaFourth_1[3] = 0.01f;
  76.   AlphaFourth_1[4] = 0.02f;
  77.   AlphaFourth_1[5] = 0.03f;
  78.   AlphaFourth_1[6] = 0.03f;
  79.   AlphaFourth_1[7] = 0.04f;
  81.   AlphaFourth_2[1] = 0.06f;
  82.   AlphaFourth_2[2] = 0.07f;
  83.   AlphaFourth_2[3] = 0.07f;
  84.   AlphaFourth_2[4] = 0.08f;
  85.   AlphaFourth_2[5] = 0.12f;
  86.   AlphaFourth_2[6] = 0.11f;
  87.   AlphaFourth_2[7] = 0.15f;
  89.   UMHEX_DefineThresholdMB();
  91.   BlockType_LUT[0][0] = 7; // 4x4
  92.   BlockType_LUT[0][1] = 6; // 4x8
  93.   BlockType_LUT[1][0] = 5; // 8x4
  94.   BlockType_LUT[1][1] = 4; // 8x8
  95.   BlockType_LUT[1][3] = 3; // 8x16
  96.   BlockType_LUT[3][1] = 2; // 16x8
  97.   BlockType_LUT[3][3] = 1; // 16x16
  99.   return;
  100. }
  101. /*!
  102.  ************************************************************************
  103.  * brief
  104.  *    Set MB thresholds for fast motion estimation
  105.  *    Those thresholds may be adjusted to trade off rate-distortion
  106.  *    performance and UMHEX speed
  107.  ************************************************************************
  108.  */
  110. void UMHEX_DefineThresholdMB()
  111. {
  112.   int gb_qp_per    = (params->qpN)/6;
  113.   int gb_qp_rem    = (params->qpN)%6;
  115.   int gb_q_bits    = Q_BITS+gb_qp_per;
  116.   int gb_qp_const,Thresh4x4;
  118.   float Quantize_step;
  119.   int i;
  120. // scale factor: defined for different image sizes
  121.   float scale_factor = (float)((1-params->UMHexScale*0.1)+params->UMHexScale*0.1*(img->width/MIN_IMG_WIDTH));
  122. // QP factor: defined for different quantization steps
  123.   float QP_factor = (float)((1.0-0.90*(params->qpN/51.0f)));
  125.   gb_qp_const=(1<<gb_q_bits)/6;
  126.   Thresh4x4 =   ((1<<gb_q_bits) - gb_qp_const)/quant_coef[gb_qp_rem][0][0];
  127.   Quantize_step = Thresh4x4/(4*5.61f)*2.0f*scale_factor;
  128.   Bsize[7]=(16*16)*Quantize_step;
  130.   Bsize[6]=Bsize[7]*4;
  131.   Bsize[5]=Bsize[7]*4;
  132.   Bsize[4]=Bsize[5]*4;
  133.   Bsize[3]=Bsize[4]*4;
  134.   Bsize[2]=Bsize[4]*4;
  135.   Bsize[1]=Bsize[2]*4;
  137.   for(i=1;i<8;i++)
  138.   {
  139.     //ET_Thd1: early termination after median prediction
  140.     Median_Pred_Thd_MB[i]  = (int) (Median_Pred_Thd[i]* scale_factor*QP_factor);
  141.     //ET_thd2: early termination after every circle of 16 points Big-Hex Search
  142.     Big_Hexagon_Thd_MB[i]  = (int) (Big_Hexagon_Thd[i]* scale_factor*QP_factor);
  143.     //threshold for multi ref case
  144.     Multi_Ref_Thd_MB[i]    = (int) (Multi_Ref_Thd[i]  * scale_factor*QP_factor);
  145.     //threshold for usage of DSR technique. DSR ref to JVT-R088
  146.     Threshold_DSR_MB[i]    = (int) (Threshold_DSR[i]  * scale_factor*QP_factor);
  147.   }
  148. }
  150. /*!
  151.  ************************************************************************
  152.  * brief
  153.  *    Allocation of space for fast motion estimation
  154.  ************************************************************************
  155.  */
  156. int UMHEX_get_mem()
  157. {
  158.   int memory_size = 0;
  159.   if (NULL==(flag_intra = calloc ((img->width>>4)+1,sizeof(byte)))) no_mem_exit("UMHEX_get_mem: flag_intra"); //fwf 20050330
  161.   memory_size += get_mem2D(&McostState, 2*params->search_range+1, 2*params->search_range+1);
  162.   memory_size += get_mem4Dint(&(fastme_ref_cost), img->max_num_references, 9, 4, 4);
  163.   memory_size += get_mem3Dint(&(fastme_l0_cost), 9, img->height/4, img->width/4);
  164.   memory_size += get_mem3Dint(&(fastme_l1_cost), 9, img->height/4, img->width/4);
  165.   memory_size += get_mem2D(&SearchState,7,7);
  166.   memory_size += get_mem2Dint(&(fastme_best_cost), 7, img->width/4);
  167.   if(params->BiPredMotionEstimation == 1)//memory allocation for bipred mode
  168.   {
  169.     memory_size += get_mem3Dint(&(fastme_l0_cost_bipred), 9, img->height/4, img->width/4);//for bipred
  170.     memory_size += get_mem3Dint(&(fastme_l1_cost_bipred), 9, img->height/4, img->width/4);//for bipred
  171.   }
  173.   return memory_size;
  174. }
  176. /*!
  177.  ************************************************************************
  178.  * brief
  179.  *    Free space for fast motion estimation
  180.  ************************************************************************
  181.  */
  182. void UMHEX_free_mem()
  183. {
  184.   free_mem2D(McostState);
  185.   free_mem4Dint(fastme_ref_cost);
  186.   free_mem3Dint(fastme_l0_cost );
  187.   free_mem3Dint(fastme_l1_cost);
  188.   free_mem2D(SearchState);
  189.   free_mem2Dint(fastme_best_cost);
  190.   free (flag_intra);
  191.   if(params->BiPredMotionEstimation == 1)
  192.   {
  193.     free_mem3Dint(fastme_l0_cost_bipred);//for bipred
  194.     free_mem3Dint(fastme_l1_cost_bipred);//for bipred
  195.   }
  196. }
  198. /*!
  199.  ************************************************************************
  200.  * brief
  201.  *    UMHEXIntegerPelBlockMotionSearch: fast pixel block motion search
  202.  *    this algorithm is called UMHexagonS(see JVT-D016),which includes
  203.  *    four steps with different kinds of search patterns
  204.  * par Input:
  205.  * imgpel*   orig_pic,     // <--  original picture
  206.  * int       ref,          // <--  reference frame (0... or -1 (backward))
  207.  * int       pic_pix_x,    // <--  absolute x-coordinate of regarded AxB block
  208.  * int       pic_pix_y,    // <--  absolute y-coordinate of regarded AxB block
  209.  * int       blocktype,    // <--  block type (1-16x16 ... 7-4x4)
  210.  * int       pred_mv[2],   // <--  motion vector predictor (x|y) in sub-pel units
  211.  * int       mv[2],        //  --> motion vector (x|y) - in pel units
  212.  * int       search_range, // <--  1-d search range in pel units
  213.  * int       min_mcost,    // <--  minimum motion cost (cost for center or huge value)
  214.  * int       lambda_factor // <--  lagrangian parameter for determining motion cost
  215.  * par
  216.  * Two macro definitions defined in this program:
  217.  * 1. EARLY_TERMINATION: early termination algrithm, refer to JVT-D016.doc
  218.  * 2. SEARCH_ONE_PIXEL: search one pixel in search range
  219.  * author
  220.  *   Main contributors: (see contributors.h for copyright, address and affiliation details)
  221.  *   - Zhibo Chen         <chenzhibo@tsinghua.org.cn>
  222.  *   - JianFeng Xu        <fenax@video.mdc.tsinghua.edu.cn>
  223.  *   - Xiaozhong Xu       <xxz@video.mdc.tsinghua.edu.cn>
  224.  * date   :
  225.  *   2006.1
  226.  ************************************************************************
  227.  */
  228. int                                     //  ==> minimum motion cost after search
  229. UMHEXIntegerPelBlockMotionSearch  (Macroblock *currMB,     // <--  current Macroblock
  230.                                   imgpel   *orig_pic,      // < <--  not used
  231.                                   short     ref,           // < <--  reference frame (0... or -1 (backward))
  232.                                   int       list,          // < <--  reference picture list
  233.                                   int       list_offset,   // < <--  MBAFF list offset
  234.                                   char   ***refPic,        // <--  reference array
  235.                                   short ****tmp_mv,        // <--  mv array
  236.                                   int       pic_pix_x,     // < <--  absolute x-coordinate of regarded AxB block
  237.                                   int       pic_pix_y,     // < <--  absolute y-coordinate of regarded AxB block
  238.                                   int       blocktype,     // < <--  block type (1-16x16 ... 7-4x4)
  239.                                   short     pred_mv[2],    // < <--  motion vector predictor (x|y) in sub-pel units
  240.                                   short     mv[2],         // < --> motion vector (x|y) - in pel units
  241.                                   int       search_range,  // < <--  1-d search range in pel units
  242.                                   int       min_mcost,     // < <--  minimum motion cost (cost for center or huge value)
  243.                                   int       lambda_factor, // < <--  lagrangian parameter for determining motion cost
  244.                                   int       apply_weights
  245.                                   )
  246. {
  247.   int   mvshift       = 2;                                        //!< motion vector shift for getting sub-pel units
  248.   int   blocksize_y   = params->blc_size[blocktype][1];            //!< vertical block size
  249.   int   blocksize_x   = params->blc_size[blocktype][0];            //!< horizontal block size
  250.   int   pred_x        = (pic_pix_x << mvshift) + pred_mv[0];       //!< predicted position x (in sub-pel units)
  251.   int   pred_y        = (pic_pix_y << mvshift) + pred_mv[1];       //!< predicted position y (in sub-pel units)
  252.   int   center_x      = pic_pix_x + mv[0];                        //!< center position x (in pel units)
  253.   int   center_y      = pic_pix_y + mv[1];                        //!< center position y (in pel units)
  254.   int   best_x        = 0, best_y = 0;
  255.   int   search_step, iYMinNow, iXMinNow;
  256.   int   pos, cand_x, cand_y,  mcost;
  257.   int   i,m,j;
  258.   float betaFourth_1,betaFourth_2;
  259.   int  temp_Big_Hexagon_x[16];//  temp for Big_Hexagon_x;
  260.   int  temp_Big_Hexagon_y[16];//  temp for Big_Hexagon_y;
  261.   short mb_x = pic_pix_x - img->opix_x;
  262.   short mb_y = pic_pix_y - img->opix_y;
  263.   short pic_pix_x2 = pic_pix_x >> 2;
  264.   short block_x = (mb_x >> 2);
  265.   short block_y = (mb_y >> 2);
  266.   int ET_Thred = Median_Pred_Thd_MB[blocktype];//ET threshold in use
  267.   int   *SAD_prediction = fastme_best_cost[blocktype-1];//multi ref SAD prediction
  268.   //===== Use weighted Reference for ME ====
  270.   dist_method = F_PEL + 3 * apply_weights;
  272.   ref_pic_ptr = listX[list+list_offset][ref];
  274.   // Note that following seem to be universal for all functions and could be moved to a separate, clean public function in me_distortion.c
  275.   
  276.   ref_pic_sub.luma = ref_pic_ptr->p_curr_img_sub;
  278.   img_width  = ref_pic_ptr->size_x;
  279.   img_height = ref_pic_ptr->size_y;
  280.   width_pad  = ref_pic_ptr->size_x_pad;
  281.   height_pad = ref_pic_ptr->size_y_pad;
  283.   if (apply_weights)
  284.   {
  285.     weight_luma = wp_weight[list + list_offset][ref][0];
  286.     offset_luma = wp_offset[list + list_offset][ref][0];
  287.   }
  289.   if (ChromaMEEnable)
  290.   {
  291.     ref_pic_sub.crcb[0] = ref_pic_ptr->imgUV_sub[0];
  292.     ref_pic_sub.crcb[1] = ref_pic_ptr->imgUV_sub[1];
  293.     width_pad_cr  = ref_pic_ptr->size_x_cr_pad;
  294.     height_pad_cr = ref_pic_ptr->size_y_cr_pad;
  296.     if (apply_weights)
  297.     {
  298.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  299.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  300.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  301.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  302.     }
  303.   }
  305.   //===== set function for getting reference picture lines =====
  306.   if ((center_x > search_range) && (center_x < img_width - 1 - search_range - blocksize_x) &&
  307.     (center_y > search_range) && (center_y < img_height - 1 - search_range - blocksize_y))
  308.   {
  309.     ref_access_method = FAST_ACCESS;
  310.   }
  311.   else
  312.   {
  313.     ref_access_method = UMV_ACCESS;
  314.   }
  316.   //////allocate memory for search state//////////////////////////
  317.   memset(McostState[0],0,(2*params->search_range+1)*(2*params->search_range+1));
  320.   //check the center median predictor
  321.   cand_x = center_x ;
  322.   cand_y = center_y ;
  323.   mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y);
  325.   mcost += computeUniPred[dist_method](orig_pic, blocksize_y,blocksize_x, min_mcost - mcost,
  326.     (cand_x << 2) + IMG_PAD_SIZE_TIMES4, (cand_y << 2) + IMG_PAD_SIZE_TIMES4);
  328.   McostState[search_range][search_range] = 1;
  329.   if (mcost < min_mcost)
  330.   {
  331.     min_mcost = mcost;
  332.     best_x    = cand_x;
  333.     best_y    = cand_y;
  334.   }
  336.   iXMinNow = best_x;
  337.   iYMinNow = best_y;
  338.   for (m = 0; m < 4; m++)
  339.   {
  340.     cand_x = iXMinNow + Diamond_x[m];
  341.     cand_y = iYMinNow + Diamond_y[m];
  342.     SEARCH_ONE_PIXEL
  343.   }
  345.   if(center_x != pic_pix_x || center_y != pic_pix_y)
  346.   {
  347.     cand_x = pic_pix_x ;
  348.     cand_y = pic_pix_y ;
  349.     SEARCH_ONE_PIXEL
  351.     iXMinNow = best_x;
  352.     iYMinNow = best_y;
  353.     for (m = 0; m < 4; m++)
  354.     {
  355.       cand_x = iXMinNow + Diamond_x[m];
  356.       cand_y = iYMinNow + Diamond_y[m];
  357.       SEARCH_ONE_PIXEL
  358.     }
  359.   }
  360.   /***********************************init process*************************/
  361.   //for multi ref
  362.   if(ref>0 && img->structure == FRAME  && min_mcost > ET_Thred && SAD_prediction[pic_pix_x2]<Multi_Ref_Thd_MB[blocktype])
  363.     goto terminate_step;
  365.   //ET_Thd1: early termination for low motion case
  366.   if( min_mcost < ET_Thred)
  367.   {
  368.     goto terminate_step;
  369.   }
  370.   else // hybrid search for main search loop
  371.   {
  372.     /****************************(MV and SAD prediction)********************************/
  373.     UMHEX_setup(ref, list, block_y, block_x, blocktype, img->all_mv );
  374.     ET_Thred = Big_Hexagon_Thd_MB[blocktype];  // ET_Thd2: early termination Threshold for strong motion
  378.     // Threshold defined for EARLY_TERMINATION
  379.     if (pred_SAD == 0)
  380.     {
  381.       betaFourth_1=0;
  382.       betaFourth_2=0;
  383.     }
  384.     else
  385.     {
  386.       betaFourth_1 = Bsize[blocktype]/(pred_SAD*pred_SAD)-AlphaFourth_1[blocktype];
  387.       betaFourth_2 = Bsize[blocktype]/(pred_SAD*pred_SAD)-AlphaFourth_2[blocktype];
  389.     }
  390.     /*********************************************end of init ***********************************************/
  391.   }
  392.   // first_step: initial start point prediction
  394.   if(blocktype>1)
  395.   {
  396.     cand_x = pic_pix_x + (pred_MV_uplayer[0]/4);
  397.     cand_y = pic_pix_y + (pred_MV_uplayer[1]/4);
  398.     SEARCH_ONE_PIXEL
  399.   }
  402.   //prediction using mV of last ref moiton vector
  403.   if(pred_MV_ref_flag == 1)      //Notes: for interlace case, ref==1 should be added
  404.   {
  405.     cand_x = pic_pix_x + (pred_MV_ref[0]/4);
  406.     cand_y = pic_pix_y + (pred_MV_ref[1]/4);
  407.     SEARCH_ONE_PIXEL
  408.   }
  409.   //small local search
  410.   iXMinNow = best_x;
  411.   iYMinNow = best_y;
  412.   for (m = 0; m < 4; m++)
  413.   {
  414.     cand_x = iXMinNow + Diamond_x[m];
  415.     cand_y = iYMinNow + Diamond_y[m];
  416.     SEARCH_ONE_PIXEL
  417.   }
  419.   //early termination algorithm, refer to JVT-G016
  420.   EARLY_TERMINATION
  422.   if(blocktype>6)
  423.     goto fourth_1_step;
  424.   else
  425.     goto sec_step;
  427. sec_step: //Unsymmetrical-cross search
  428.   iXMinNow = best_x;
  429.   iYMinNow = best_y;
  431.   for(i = 1; i < search_range; i+=2)
  432.   {
  433.     search_step = i;
  434.     cand_x = iXMinNow + search_step;
  435.     cand_y = iYMinNow ;
  436.     SEARCH_ONE_PIXEL
  437.     cand_x = iXMinNow - search_step;
  438.     cand_y = iYMinNow ;
  439.     SEARCH_ONE_PIXEL
  440.   }
  441.   for(i = 1; i < (search_range/2);i+=2)
  442.   {
  443.     search_step = i;
  444.     cand_x = iXMinNow ;
  445.     cand_y = iYMinNow + search_step;
  446.     SEARCH_ONE_PIXEL
  447.     cand_x = iXMinNow ;
  448.     cand_y = iYMinNow - search_step;
  449.     SEARCH_ONE_PIXEL
  450.   }
  453.   //early termination alogrithm, refer to JVT-G016
  454.   EARLY_TERMINATION
  456.   iXMinNow = best_x;
  457.   iYMinNow = best_y;
  459.   //third_step:    // Uneven Multi-Hexagon-grid Search
  460.   //sub step 1: 5x5 squre search
  461.   for(pos=1;pos<25;pos++)
  462.   {
  463.     cand_x = iXMinNow + spiral_search_x[pos];
  464.     cand_y = iYMinNow + spiral_search_y[pos];
  465.     SEARCH_ONE_PIXEL
  466.   }
  468.   //early termination alogrithm, refer to JVT-G016
  469.   EARLY_TERMINATION
  471.   //sub step 2:  Multi-Hexagon-grid search
  472.   memcpy(temp_Big_Hexagon_x,Big_Hexagon_x,64);
  473.   memcpy(temp_Big_Hexagon_y,Big_Hexagon_y,64);
  474.   for(i=1;i<=(search_range/4); i++)
  475.   {
  477.     for (m = 0; m < 16; m++)
  478.     {
  479.       cand_x = iXMinNow + temp_Big_Hexagon_x[m];
  480.       cand_y = iYMinNow + temp_Big_Hexagon_y[m];
  481.       temp_Big_Hexagon_x[m] += Big_Hexagon_x[m];
  482.       temp_Big_Hexagon_y[m] += Big_Hexagon_y[m];
  484.       SEARCH_ONE_PIXEL
  485.     }
  486.     // ET_Thd2: early termination Threshold for strong motion
  487.     if(min_mcost < ET_Thred)
  488.     {
  489.       goto terminate_step;
  490.     }
  491.   }
  494.   //fourth_step:  //Extended Hexagon-based Search
  495.   // the fourth step with a small search pattern
  496. fourth_1_step:  //sub step 1: small Hexagon search
  497.   for(i = 0; i < search_range; i++)
  498.   {
  499.     iXMinNow = best_x;
  500.     iYMinNow = best_y;
  501.     for (m = 0; m < 6; m++)
  502.     {
  503.       cand_x = iXMinNow + Hexagon_x[m];
  504.       cand_y = iYMinNow + Hexagon_y[m];
  505.       SEARCH_ONE_PIXEL
  506.     }
  508.     if (best_x == iXMinNow && best_y == iYMinNow)
  509.     {
  510.       break;
  511.     }
  512.   }
  513. fourth_2_step: //sub step 2: small Diamond search
  515.   for(i = 0; i < search_range; i++)
  516.   {
  517.     iXMinNow = best_x;
  518.     iYMinNow = best_y;
  519.     for (m = 0; m < 4; m++)
  520.     {
  521.       cand_x = iXMinNow + Diamond_x[m];
  522.       cand_y = iYMinNow + Diamond_y[m];
  523.       SEARCH_ONE_PIXEL
  524.     }
  525.     if(best_x == iXMinNow && best_y == iYMinNow)
  526.       break;
  527.   }
  529. terminate_step:
  531.   // store SAD infomation for prediction
  532.   //FAST MOTION ESTIMATION. ZHIBO CHEN 2003.3
  533.   for (i=0; i < (blocksize_x>>2); i++)
  534.   {
  535.     for (j=0; j < (blocksize_y>>2); j++)
  536.     {
  537.       if(list == 0)
  538.       {
  539.         fastme_ref_cost[ref][blocktype][block_y+j][block_x+i] = min_mcost;
  540.         if (ref==0)
  541.           fastme_l0_cost[blocktype][(img->pix_y>>2)+block_y+j][(img->pix_x>>2)+block_x+i] = min_mcost;
  542.       }
  543.       else
  544.       {
  545.         fastme_l1_cost[blocktype][(img->pix_y>>2)+block_y+j][(img->pix_x>>2)+block_x+i] = min_mcost;
  546.       }
  547.     }
  548.   }
  549.   //for multi ref SAD prediction
  550.   if ((ref==0) || (SAD_prediction[pic_pix_x2] > min_mcost))
  551.     SAD_prediction[pic_pix_x2] = min_mcost;
  553.   mv[0] = (short) (best_x - pic_pix_x);
  554.   mv[1] = (short) (best_y - pic_pix_y);
  555.   return min_mcost;
  556. }
  559. int                                                   //  ==> minimum motion cost after search
  560. UMHEXSubPelBlockMotionSearch (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  561.                              short     ref,           // <--  reference frame (0... or -1 (backward))
  562.                              int       list,
  563.                              int       list_offset,
  564.                              int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  565.                              int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  566.                              int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  567.                              short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  568.                              short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in sub-pel units
  569.                              int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  570.                              int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  571.                              int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  572.                              int       lambda_factor,
  573.                              int       apply_weights
  574.                              )
  575. {
  576.   static int Diamond_x[4] = {-1, 0, 1, 0};
  577.   static int Diamond_y[4] = {0, 1, 0, -1};
  578.   int   mcost;
  579.   int   cand_mv_x, cand_mv_y;
  581.   StorablePicture *ref_picture = listX[list+list_offset][ref];
  582.   int   mv_shift        = 0;
  583.   int   blocksize_x     = params->blc_size[blocktype][0];
  584.   int   blocksize_y     = params->blc_size[blocktype][1];
  585.   int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<< 2);
  586.   int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<< 2);
  587.   short max_pos_x4      = ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  588.   short max_pos_y4      = ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);
  590.   int   search_range_dynamic,iXMinNow,iYMinNow,i;
  591.   int   m,currmv_x = 0,currmv_y = 0;
  592.   int   pred_frac_mv_x,pred_frac_mv_y,abort_search;
  594.   int   pred_frac_up_mv_x, pred_frac_up_mv_y;
  596.   dist_method = Q_PEL + 3 * apply_weights;
  597.   if ((pic4_pix_x + mv[0] > 1) && (pic4_pix_x + mv[0] < max_pos_x4 - 1) &&
  598.     (pic4_pix_y + mv[1] > 1) && (pic4_pix_y + mv[1] < max_pos_y4 - 1)   )
  599.   {
  600.     ref_access_method = FAST_ACCESS;
  601.   }
  602.   else
  603.   {
  604.     ref_access_method = UMV_ACCESS;
  605.   }
  607.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  609.   img_width  = ref_picture->size_x;
  610.   img_height = ref_picture->size_y;
  611.   width_pad  = ref_picture->size_x_pad;
  612.   height_pad = ref_picture->size_y_pad;
  614.   if (apply_weights)
  615.   {
  616.     weight_luma = wp_weight[list + list_offset][ref][0];
  617.     offset_luma = wp_offset[list + list_offset][ref][0];
  618.   }
  620.   if (ChromaMEEnable )
  621.   {
  622.     ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
  623.     ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
  624.     width_pad_cr  = ref_picture->size_x_cr_pad;
  625.     height_pad_cr = ref_picture->size_y_cr_pad;
  627.     if (apply_weights)
  628.     {
  629.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  630.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  631.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  632.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  633.     }
  634.   }
  636.   search_range_dynamic = 3;
  637.   pred_frac_mv_x = (pred_mv[0] - mv[0])%4;
  638.   pred_frac_mv_y = (pred_mv[1] - mv[1])%4;
  640.   pred_frac_up_mv_x = (pred_MV_uplayer[0] - mv[0])%4;
  641.   pred_frac_up_mv_y = (pred_MV_uplayer[1] - mv[1])%4;
  644.   memset(SearchState[0],0,(2*search_range_dynamic+1)*(2*search_range_dynamic+1));
  646.   if( !start_me_refinement_hp )
  647.   {
  648.     cand_mv_x = mv[0];
  649.     cand_mv_y = mv[1];
  650.     mcost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  652.     mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
  653.       min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  655.     SearchState[search_range_dynamic][search_range_dynamic] = 1;
  656.     if (mcost < min_mcost)
  657.     {
  658.       min_mcost = mcost;
  659.       currmv_x = cand_mv_x;
  660.       currmv_y = cand_mv_y;
  661.     }
  662.   }
  663.   else
  664.   {
  665.     SearchState[search_range_dynamic][search_range_dynamic] = 1;
  666.     currmv_x = mv[0];
  667.     currmv_y = mv[1];
  668.   }
  670.   if(pred_frac_mv_x!=0 || pred_frac_mv_y!=0)
  671.   {
  672.     cand_mv_x = mv[0] + pred_frac_mv_x;
  673.     cand_mv_y = mv[1] + pred_frac_mv_y;
  674.     mcost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  675.     mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
  676.       min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  677.     SearchState[cand_mv_y -mv[1] + search_range_dynamic][cand_mv_x - mv[0] + search_range_dynamic] = 1;
  678.     if (mcost < min_mcost)
  679.     {
  680.       min_mcost = mcost;
  681.       currmv_x = cand_mv_x;
  682.       currmv_y = cand_mv_y;
  683.     }
  684.   }
  687.   iXMinNow = currmv_x;
  688.   iYMinNow = currmv_y;
  689.   for(i=0;i<search_range_dynamic;i++)
  690.   {
  691.     abort_search=1;
  692.     for (m = 0; m < 4; m++)
  693.     {
  694.       cand_mv_x = iXMinNow + Diamond_x[m];
  695.       cand_mv_y = iYMinNow + Diamond_y[m];
  697.       if(iabs(cand_mv_x - mv[0]) <=search_range_dynamic && iabs(cand_mv_y - mv[1])<= search_range_dynamic)
  698.       {
  699.         if(!SearchState[cand_mv_y -mv[1]+ search_range_dynamic][cand_mv_x -mv[0]+ search_range_dynamic])
  700.         {
  701.           mcost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  702.           mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
  703.             min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  704.           SearchState[cand_mv_y - mv[1] + search_range_dynamic][cand_mv_x - mv[0] + search_range_dynamic] = 1;
  705.           if (mcost < min_mcost)
  706.           {
  707.             min_mcost = mcost;
  708.             currmv_x = cand_mv_x;
  709.             currmv_y = cand_mv_y;
  710.             abort_search = 0;
  711.           }
  712.         }
  713.       }
  714.     }
  715.     iXMinNow = currmv_x;
  716.     iYMinNow = currmv_y;
  717.     if(abort_search)
  718.       break;
  719.   }
  721.   mv[0] = currmv_x;
  722.   mv[1] = currmv_y;
  724.   //===== return minimum motion cost =====
  725.   return min_mcost;
  726. }
  728. int                                                   //  ==> minimum motion cost after search
  729. UMHEXSubPelBlockME (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  730.                     short     ref,           // <--  reference frame (0... or -1 (backward))
  731.                     int       list,
  732.                     int       list_offset,   // <--  MBAFF list offset
  733.                     int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  734.                     int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  735.                     int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  736.                     short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  737.                     short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in sub-pel units
  738.                     int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  739.                     int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  740.                     int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  741.                     int*      lambda,
  742.                     int       apply_weights
  743.                     )
  744. {  
  745.   if(blocktype >3)
  746.   {
  747.     min_mcost =  UMHEXSubPelBlockMotionSearch (orig_pic, ref, list, list_offset, pic_pix_x, pic_pix_y, blocktype,
  748.       pred_mv, mv, 9, 9, min_mcost, lambda[Q_PEL], apply_weights);
  749.   }
  750.   else
  751.   {
  752.     min_mcost =  SubPelBlockMotionSearch (orig_pic, ref, list, list_offset, pic_pix_x, pic_pix_y, blocktype,
  753.       pred_mv, mv,  9, 9, min_mcost, lambda, apply_weights);
  754.   }
  755.  
  756.   return min_mcost;
  757. }
  759. /*!
  760.  ************************************************************************
  761.  * brief
  762.  * Functions for SAD prediction of intra block cases.
  763.  * 1. void UMHEX_decide_intrabk_SAD() judges the block coding type(intra/inter)
  764.  *    of neibouring blocks
  765.  * 2. void UMHEX_skip_intrabk_SAD() set the SAD to zero if neigouring block coding
  766.  *    type is intra
  767.  * date
  768.  *    2003.4
  769.  ************************************************************************
  770.  */
  771. void UMHEX_decide_intrabk_SAD()
  772. {
  773.   if (img->type != I_SLICE)
  774.   {
  775.     if (img->pix_x == 0 && img->pix_y == 0)
  776.     {
  777.       flag_intra_SAD = 0;
  778.     }
  779.     else if (img->pix_x == 0)
  780.     {
  781.       flag_intra_SAD = flag_intra[(img->pix_x)>>4];
  782.     }
  783.     else if (img->pix_y == 0)
  784.     {
  785.       flag_intra_SAD = flag_intra[((img->pix_x)>>4)-1];
  786.     }
  787.     else
  788.     {
  789.       flag_intra_SAD = ((flag_intra[(img->pix_x)>>4])||(flag_intra[((img->pix_x)>>4)-1])||(flag_intra[((img->pix_x)>>4)+1])) ;
  790.     }
  791.   }
  792.   return;
  793. }
  795. void UMHEX_skip_intrabk_SAD(int best_mode, int ref_max)
  796. {
  797.   int i,j,k, ref;
  798.   if (img->number > 0)
  799.     flag_intra[(img->pix_x)>>4] = (best_mode == 9 || best_mode == 10) ? 1:0;
  800.   if (img->type != I_SLICE  && (best_mode == 9 || best_mode == 10))
  801.   {
  802.     for (i=0; i < 4; i++)
  803.     {
  804.       for (j=0; j < 4; j++)
  805.       {
  806.         for (k=0; k < 9;k++)
  807.         {
  808.           fastme_l0_cost[k][j][i] = 0;
  809.           fastme_l1_cost[k][j][i] = 0;
  810.           for (ref=0; ref<ref_max;ref++)
  811.           {
  812.             fastme_ref_cost[ref][k][j][i] = 0;
  813.           }
  814.         }
  815.       }
  816.     }
  818.   }
  819.   return;
  820. }
  823. void UMHEX_setup(short ref, int list, int block_y, int block_x, int blocktype, short   ******all_mv)
  824. {
  825.   int  N_Bframe=0;
  826.   int n_Bframe=0;
  827.   int temp_blocktype = 0;
  828.   int indication_blocktype[8]={0,0,1,1,2,4,4,5};
  829.   N_Bframe = params->successive_Bframe;
  830.   n_Bframe =(N_Bframe) ? (stats->frame_ctr[B_SLICE]%(N_Bframe+1)): 0;
  833.   /**************************** MV prediction **********************/
  834.   //MV uplayer prediction
  835.   if (blocktype>1)
  836.   {
  837.     temp_blocktype = indication_blocktype[blocktype];
  838.     pred_MV_uplayer[0] = all_mv[list][ref][temp_blocktype][block_y][block_x][0];
  839.     pred_MV_uplayer[1] = all_mv[list][ref][temp_blocktype][block_y][block_x][1];
  840.   }
  843.   //MV ref-frame prediction
  844.   pred_MV_ref_flag = 0;
  845.   if(list==0)
  846.   {
  847.     if (img->field_picture)
  848.     {
  849.       if ( ref > 1)
  850.       {
  851.         pred_MV_ref[0] = all_mv[0][ref-2][blocktype][block_y][block_x][0];
  852.         pred_MV_ref[0] = (int)(pred_MV_ref[0]*((ref>>1)+1)/(float)((ref>>1)));
  853.         pred_MV_ref[1] = all_mv[0][ref-2][blocktype][block_y][block_x][1];
  854.         pred_MV_ref[1] = (int)(pred_MV_ref[1]*((ref>>1)+1)/(float)((ref>>1)));
  855.         pred_MV_ref_flag = 1;
  856.       }
  857.       if (img->type == B_SLICE &&  (ref==0 || ref==1) )
  858.       {
  859.         pred_MV_ref[0] =(int) (all_mv[1][0][blocktype][block_y][block_x][0]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  860.         pred_MV_ref[1] =(int) (all_mv[1][0][blocktype][block_y][block_x][1]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  861.         pred_MV_ref_flag = 1;
  862.       }
  863.     }
  864.     else //frame case
  865.     {
  866.       if ( ref > 0)
  867.       {
  868.         pred_MV_ref[0] = all_mv[0][ref-1][blocktype][block_y][block_x][0];
  869.         pred_MV_ref[0] = (int)(pred_MV_ref[0]*(ref+1)/(float)(ref));
  870.         pred_MV_ref[1] = all_mv[0][ref-1][blocktype][block_y][block_x][1];
  871.         pred_MV_ref[1] = (int)(pred_MV_ref[1]*(ref+1)/(float)(ref));
  872.         pred_MV_ref_flag = 1;
  873.       }
  874.       if (img->type == B_SLICE && (ref==0)) //B frame forward prediction, first ref
  875.       {
  876.         pred_MV_ref[0] =(int) (all_mv[1][0][blocktype][block_y][block_x][0] * (-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  877.         pred_MV_ref[1] =(int) (all_mv[1][0][blocktype][block_y][block_x][1] * (-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  878.         pred_MV_ref_flag = 1;
  879.       }
  880.     }
  881.   }
  882.   /******************************SAD prediction**********************************/
  883.   if (list==0 && ref>0)  //pred_SAD_ref
  884.   {
  886.     if (flag_intra_SAD) //add this for irregular motion
  887.     {
  888.       pred_SAD = 0;
  889.     }
  890.     else
  891.     {
  892.       if (img->field_picture)
  893.       {
  894.         if (ref > 1)
  895.         {
  896.           pred_SAD = fastme_ref_cost[ref-2][blocktype][block_y][block_x];
  897.         }
  898.         else
  899.         {
  900.           pred_SAD = fastme_ref_cost[0][blocktype][block_y][block_x];
  901.         }
  902.       }
  903.       else
  904.       {
  905.         pred_SAD = fastme_ref_cost[ref-1][blocktype][block_y][block_x];
  906.       }
  908.     }
  909.   }
  910.   else if (blocktype>1)  // pred_SAD_uplayer
  911.   {
  912.     if (flag_intra_SAD)
  913.     {
  914.       pred_SAD = 0;
  915.     }
  916.     else
  917.     {
  918.       pred_SAD = (list==1) ? (fastme_l1_cost[temp_blocktype][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]) : (fastme_l0_cost[temp_blocktype][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
  919.       pred_SAD /= 2;
  920.     }
  921.   }
  922.   else pred_SAD = 0 ;  // pred_SAD_space
  924. }
  926. /*!
  927.  ************************************************************************
  928.  * brief
  929.  *    UMHEXBipredIntegerPelBlockMotionSearch: fast pixel block motion search for bipred mode
  930.  *    this algrithm is called UMHexagonS(see JVT-D016),which includes
  931.  *    four steps with different kinds of search patterns
  932.  * author
  933.  *   Main contributors: (see contributors.h for copyright, address and affiliation details)
  934.  *   - Zhibo Chen         <chenzhibo@tsinghua.org.cn>
  935.  *   - JianFeng Xu        <fenax@video.mdc.tsinghua.edu.cn>
  936.  *   - Xiaozhong Xu       <xxz@video.mdc.tsinghua.edu.cn>
  937.  * date   :
  938.  *   2006.1
  939.  ************************************************************************
  940.  */
  941. int                                                //  ==> minimum motion cost after search
  942. UMHEXBipredIntegerPelBlockMotionSearch (Macroblock *currMB,      // <--  current Macroblock
  943.                                         imgpel*   cur_pic,       // <--  original pixel values for the AxB block
  944.                                         short     ref,           // <--  reference frame (0... or -1 (backward))
  945.                                         int       list,          // <--  current reference list
  946.                                         int       list_offset,   // <--  MBAFF list offset
  947.                                         char   ***refPic,        // <--  reference array
  948.                                         short ****tmp_mv,        // <--  mv array
  949.                                         int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  950.                                         int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  951.                                         int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  952.                                         short     pred_mv1[2],   // <--  motion vector predictor (x|y) in sub-pel units
  953.                                         short     pred_mv2[2],   // <--  motion vector predictor (x|y) in sub-pel units
  954.                                         short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  955.                                         short     s_mv[2],       // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  956.                                         int       search_range,  // <--  1-d search range in pel units
  957.                                         int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  958.                                         int       iteration_no,  // <--  bi pred iteration number
  959.                                         int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  960.                                         int       apply_weights
  961.                                         )
  962. {
  963.   int   temp_Big_Hexagon_x[16];// = Big_Hexagon_x;
  964.   int   temp_Big_Hexagon_y[16];// = Big_Hexagon_y;
  965.   int   mvshift       = 2;                  // motion vector shift for getting sub-pel units
  967.   int   search_step,iYMinNow, iXMinNow;
  968.   int   i,m,j;
  969.   float betaFourth_1,betaFourth_2;
  970.   int   pos, cand_x, cand_y,mcost;
  971.   int   blocksize_y   = params->blc_size[blocktype][1];            // vertical block size
  972.   int   blocksize_x   = params->blc_size[blocktype][0];            // horizontal block size
  973.   int   pred_x1        = (pic_pix_x << 2) + pred_mv1[0];       // predicted position x (in sub-pel units)
  974.   int   pred_y1        = (pic_pix_y << 2) + pred_mv1[1];       // predicted position y (in sub-pel units)
  975.   int   pred_x2        = (pic_pix_x << 2) + pred_mv2[0];       // predicted position x (in sub-pel units)
  976.   int   pred_y2        = (pic_pix_y << 2) + pred_mv2[1];       // predicted position y (in sub-pel units)
  977.   short center2_x      = pic_pix_x + mv[0];                      // center position x (in pel units)
  978.   short center2_y      = pic_pix_y + mv[1];                      // center position y (in pel units)
  979.   short center1_x      = pic_pix_x + s_mv[0];                      // mvx of second pred (in pel units)
  980.   short center1_y      = pic_pix_y + s_mv[1];                      // mvy of second pred (in pel units)
  981.   short mb_x = pic_pix_x - img->opix_x;
  982.   short mb_y = pic_pix_y - img->opix_y;
  983.   short block_x = (mb_x >> 2);
  984.   short block_y = (mb_y >> 2);
  985.   int   best_x = center2_x;
  986.   int   best_y = center2_y;
  987.   int   ET_Thred = Median_Pred_Thd_MB[blocktype];
  989.   short offset1 = (apply_weights ? (list == 0?  wp_offset[list_offset    ][ref][0]:  wp_offset[list_offset + 1][0  ][ref]) : 0);
  990.   short offset2 = (apply_weights ? (list == 0?  wp_offset[list_offset + 1][ref][0]:  wp_offset[list_offset    ][0  ][ref]) : 0);
  992.   ref_pic1_sub.luma = listX[list + list_offset][ref]->p_curr_img_sub;
  993.   ref_pic2_sub.luma = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->p_curr_img_sub;
  995.   img_width  = listX[list + list_offset][ref]->size_x;
  996.   img_height = listX[list + list_offset][ref]->size_y;
  997.   width_pad  = listX[list + list_offset][ref]->size_x_pad;
  998.   height_pad = listX[list + list_offset][ref]->size_y_pad;
  1000.   if (apply_weights)
  1001.   {
  1002.     weight1 = list == 0 ? wbp_weight[list_offset         ][ref][0][0] : wbp_weight[list_offset + LIST_1][0  ][ref][0];
  1003.     weight2 = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][0] : wbp_weight[list_offset         ][0  ][ref][0];
  1004.     offsetBi=(offset1 + offset2 + 1)>>1;
  1005.     computeBiPred = computeBiPredSAD2; //ME only supports SAD computations
  1006.   }
  1007.   else
  1008.   {
  1009.     weight1 = 1<<luma_log_weight_denom;
  1010.     weight2 = 1<<luma_log_weight_denom;
  1011.     offsetBi = 0;
  1012.     computeBiPred = computeBiPredSAD1; //ME only supports SAD computations
  1013.   }
  1015.   if (ChromaMEEnable )
  1016.   {
  1017.     ref_pic1_sub.crcb[0] = listX[list + list_offset][ref]->imgUV_sub[0];
  1018.     ref_pic1_sub.crcb[1] = listX[list + list_offset][ref]->imgUV_sub[1];
  1019.     ref_pic2_sub.crcb[0] = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgUV_sub[0];
  1020.     ref_pic2_sub.crcb[1] = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgUV_sub[1];
  1021.     width_pad_cr  = listX[list + list_offset][ref]->size_x_cr_pad;
  1022.     height_pad_cr = listX[list + list_offset][ref]->size_y_cr_pad;
  1023.     if (apply_weights)
  1024.     {
  1025.       weight1_cr[0] = list == 0 ? wbp_weight[list_offset         ][ref][0][1] : wbp_weight[list_offset + LIST_1][0  ][ref][1];
  1026.       weight1_cr[1] = list == 0 ? wbp_weight[list_offset         ][ref][0][2] : wbp_weight[list_offset + LIST_1][0  ][ref][2];
  1027.       weight2_cr[0] = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][1] : wbp_weight[list_offset         ][0  ][ref][1];
  1028.       weight2_cr[1] = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][2] : wbp_weight[list_offset         ][0  ][ref][2];
  1029.       offsetBi_cr[0] = (list == 0)
  1030.         ? (wp_offset[list_offset         ][ref][1] + wp_offset[list_offset + LIST_1][ref][1] + 1) >> 1
  1031.         : (wp_offset[list_offset + LIST_1][0  ][1] + wp_offset[list_offset         ][0  ][1] + 1) >> 1;
  1032.       offsetBi_cr[1] = (list == 0)
  1033.         ? (wp_offset[list_offset         ][ref][2] + wp_offset[list_offset + LIST_1][ref][2] + 1) >> 1
  1034.         : (wp_offset[list_offset + LIST_1][0  ][2] + wp_offset[list_offset         ][0  ][2] + 1) >> 1;
  1035.     }
  1036.     else
  1037.     {
  1038.       weight1_cr[0] = 1<<chroma_log_weight_denom;
  1039.       weight1_cr[1] = 1<<chroma_log_weight_denom;
  1040.       weight2_cr[0] = 1<<chroma_log_weight_denom;
  1041.       weight2_cr[1] = 1<<chroma_log_weight_denom;
  1042.       offsetBi_cr[0] = 0;
  1043.       offsetBi_cr[1] = 0;
  1044.     }
  1045.   }
  1047.   //===== set function for getting reference picture lines =====
  1048.   if ((center2_x > search_range) && (center2_x < img_width -1-search_range-blocksize_x) &&
  1049.     (center2_y > search_range) && (center2_y < img_height-1-search_range-blocksize_y)   )
  1050.   {
  1051.     bipred2_access_method = FAST_ACCESS;
  1052.   }
  1053.   else
  1054.   {
  1055.     bipred2_access_method = UMV_ACCESS;
  1056.   }
  1058.   //===== set function for getting reference picture lines =====
  1059.   if ((center1_y > search_range) && (center1_y < img_height-1-search_range-blocksize_y)   )
  1060.   {
  1061.     bipred1_access_method = FAST_ACCESS;
  1062.   }
  1063.   else
  1064.   {
  1065.     bipred1_access_method = UMV_ACCESS;
  1066.   }
  1068.   //////////////////////////////////////////////////////////////////////////
  1070.   //////allocate memory for search state//////////////////////////
  1071.   memset(McostState[0],0,(2*search_range+1)*(2*search_range+1));
  1073.   //check the center median predictor
  1074.   cand_x = center2_x ;
  1075.   cand_y = center2_y ;
  1076.   mcost  = MV_COST (lambda_factor, mvshift, center1_x, center1_y, pred_x1, pred_y1);
  1077.   mcost += MV_COST (lambda_factor, mvshift, cand_x,    cand_y,    pred_x2, pred_y2);
  1079.   mcost += computeBiPred( cur_pic,
  1080.                          blocksize_y, blocksize_x, INT_MAX,
  1081.                          (center1_x << 2) + IMG_PAD_SIZE_TIMES4,
  1082.                          (center1_y << 2) + IMG_PAD_SIZE_TIMES4,
  1083.                          (cand_x << 2) + IMG_PAD_SIZE_TIMES4,
  1084.                          (cand_y << 2) + IMG_PAD_SIZE_TIMES4);
  1086.   McostState[search_range][search_range] = 1;
  1088.   if (mcost < min_mcost)
  1089.   {
  1090.     min_mcost = mcost;
  1091.     best_x = cand_x;
  1092.     best_y = cand_y;
  1093.   }
  1095.   iXMinNow = best_x;
  1096.   iYMinNow = best_y;
  1097.   for (m = 0; m < 4; m++)
  1098.   {
  1099.     cand_x = iXMinNow + Diamond_x[m];
  1100.     cand_y = iYMinNow + Diamond_y[m];
  1101.     SEARCH_ONE_PIXEL_BIPRED;
  1102.   }
  1104.   if(center2_x != pic_pix_x || center2_y != pic_pix_y)
  1105.   {
  1106.     cand_x = pic_pix_x ;
  1107.     cand_y = pic_pix_y ;
  1109.     SEARCH_ONE_PIXEL_BIPRED;
  1111.     iXMinNow = best_x;
  1112.     iYMinNow = best_y;
  1113.     for (m = 0; m < 4; m++)
  1114.     {
  1115.       cand_x = iXMinNow + Diamond_x[m];
  1116.       cand_y = iYMinNow + Diamond_y[m];
  1117.       SEARCH_ONE_PIXEL_BIPRED;
  1118.     }
  1119.   }
  1120.   /***********************************init process*************************/
  1122.   if( min_mcost < ET_Thred)
  1123.   {
  1124.     goto terminate_step;
  1125.   }
  1126.   else
  1127.   {
  1128.     int  N_Bframe=0;
  1129.     int  n_Bframe=0;
  1130.     short****** bipred_mv = img->bipred_mv[list];
  1131.     N_Bframe = params->successive_Bframe;
  1132.     n_Bframe = stats->frame_ctr[B_SLICE]%(N_Bframe+1);
  1135.     /**************************** MV prediction **********************/
  1136.     //MV uplayer prediction
  1137.     // non for bipred mode
  1139.     //MV ref-frame prediction
  1141.     if(list==0)
  1142.     {
  1143.       if (img->field_picture)
  1144.       {
  1145.         pred_MV_ref[0] =(int) (bipred_mv[1][0][blocktype][block_y][block_x][0]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  1146.         pred_MV_ref[1] =(int) (bipred_mv[1][0][blocktype][block_y][block_x][1]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  1147.       }
  1148.       else //frame case
  1149.       {
  1150.         pred_MV_ref[0] =(int) (bipred_mv[1][0][blocktype][block_y][block_x][0]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  1151.         pred_MV_ref[1] =(int) (bipred_mv[1][0][blocktype][block_y][block_x][1]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
  1152.       }
  1153.     }
  1154.     /******************************SAD prediction**********************************/
  1156.     pred_SAD =imin(imin(SAD_a,SAD_b),SAD_c);  // pred_SAD_space
  1157.     ET_Thred = Big_Hexagon_Thd_MB[blocktype];
  1159.     ///////Threshold defined for early termination///////////////////
  1160.     if (pred_SAD == 0)
  1161.     {
  1162.       betaFourth_1=0;
  1163.       betaFourth_2=0;
  1164.     }
  1165.     else
  1166.     {
  1167.       betaFourth_1 = Bsize[blocktype]/(pred_SAD*pred_SAD)-AlphaFourth_1[blocktype];
  1168.       betaFourth_2 = Bsize[blocktype]/(pred_SAD*pred_SAD)-AlphaFourth_2[blocktype];
  1169.     }
  1170.   }
  1172.   /***********************************end of init *************************/
  1176.   // first_step: initial start point prediction
  1177.   //prediction using mV of last ref moiton vector
  1178.   if(list == 0)
  1179.   {
  1180.     cand_x = pic_pix_x + (pred_MV_ref[0]/4);
  1181.     cand_y = pic_pix_y + (pred_MV_ref[1]/4);
  1182.     SEARCH_ONE_PIXEL_BIPRED;
  1183.   }
  1186.   //small local search
  1187.   iXMinNow = best_x;
  1188.   iYMinNow = best_y;
  1189.   for (m = 0; m < 4; m++)
  1190.   {
  1191.     cand_x = iXMinNow + Diamond_x[m];
  1192.     cand_y = iYMinNow + Diamond_y[m];
  1193.     SEARCH_ONE_PIXEL_BIPRED;
  1194.   }
  1196.   //early termination alogrithm, refer to JVT-G016
  1197.   EARLY_TERMINATION;
  1200.   //sec_step: //Unsymmetrical-cross search
  1201.   iXMinNow = best_x;
  1202.   iYMinNow = best_y;
  1204.   for(i = 1; i < search_range; i+=2)
  1205.   {
  1206.     search_step = i;
  1207.     cand_x = iXMinNow + search_step;
  1208.     cand_y = iYMinNow ;
  1209.     SEARCH_ONE_PIXEL_BIPRED;
  1210.     cand_x = iXMinNow - search_step;
  1211.     cand_y = iYMinNow ;
  1212.     SEARCH_ONE_PIXEL_BIPRED;
  1213.   }
  1215.   for(i = 1; i < (search_range/2);i+=2)
  1216.   {
  1217.     search_step = i;
  1218.     cand_x = iXMinNow ;
  1219.     cand_y = iYMinNow + search_step;
  1220.     SEARCH_ONE_PIXEL_BIPRED;
  1221.     cand_x = iXMinNow ;
  1222.     cand_y = iYMinNow - search_step;
  1223.     SEARCH_ONE_PIXEL_BIPRED;
  1224.   }
  1225.   //early termination alogrithm, refer to JVT-G016
  1226.   EARLY_TERMINATION;
  1228.   //third_step:     // Uneven Multi-Hexagon-grid Search
  1229.   iXMinNow = best_x;
  1230.   iYMinNow = best_y;
  1231.   //sub step1: 5x5 square search
  1232.   for(pos=1;pos<25;pos++)
  1233.   {
  1234.     cand_x = iXMinNow + spiral_search_x[pos];
  1235.     cand_y = iYMinNow + spiral_search_y[pos];
  1236.     SEARCH_ONE_PIXEL_BIPRED;
  1237.   }
  1239.   //early termination alogrithm, refer to JVT-G016
  1240.   EARLY_TERMINATION;      //added back by xxz
  1242.   //sub step2: multi-grid-hexagon-search
  1243.   memcpy(temp_Big_Hexagon_x,Big_Hexagon_x,64);
  1244.   memcpy(temp_Big_Hexagon_y,Big_Hexagon_y,64);
  1245.   for(i=1;i<=(params->search_range>>2); i++)
  1246.   {
  1248.     for (m = 0; m < 16; m++)
  1249.     {
  1250.       cand_x = iXMinNow + temp_Big_Hexagon_x[m];
  1251.       cand_y = iYMinNow + temp_Big_Hexagon_y[m];
  1252.       temp_Big_Hexagon_x[m] += Big_Hexagon_x[m];
  1253.       temp_Big_Hexagon_y[m] += Big_Hexagon_y[m];
  1255.       SEARCH_ONE_PIXEL_BIPRED;
  1256.     }
  1257.     if(min_mcost < ET_Thred)
  1258.     {
  1259.       goto terminate_step;
  1261.     }
  1262.   }
  1263.   //fourth step: Local Refinement: Extended Hexagon-based Search
  1264. fourth_1_step:
  1266.   for(i=0; i < search_range; i++)
  1267.   {
  1268.     iXMinNow = best_x;
  1269.     iYMinNow = best_y;
  1270.     for (m = 0; m < 6; m++)
  1271.     {
  1272.       cand_x = iXMinNow + Hexagon_x[m];
  1273.       cand_y = iYMinNow + Hexagon_y[m];
  1274.       SEARCH_ONE_PIXEL_BIPRED;
  1275.     }
  1276.     if(best_x == iXMinNow && best_y == iYMinNow)
  1277.       break;
  1278.   }
  1279. fourth_2_step:
  1281.   for(i = 0; i < search_range; i++)
  1282.   {
  1283.     iXMinNow = best_x;
  1284.     iYMinNow = best_y;
  1285.     for (m = 0; m < 4; m++)
  1286.     {
  1287.       cand_x = iXMinNow + Diamond_x[m];
  1288.       cand_y = iYMinNow + Diamond_y[m];
  1289.       SEARCH_ONE_PIXEL_BIPRED;
  1290.     }
  1291.     if(best_x == iXMinNow && best_y == iYMinNow)
  1292.       break;
  1293.   }
  1295. terminate_step:
  1296.   for (i=0; i < (blocksize_x>>2); i++)
  1297.   {
  1298.     for (j=0; j < (blocksize_y>>2); j++)
  1299.     {
  1300.       if(list == 0)
  1301.       {
  1302.         fastme_l0_cost_bipred[blocktype][(img->pix_y>>2)+block_y+j][(img->pix_x>>2)+block_x+i] = min_mcost;
  1303.       }
  1304.       else
  1305.       {
  1306.         fastme_l1_cost_bipred[blocktype][(img->pix_y>>2)+block_y+j][(img->pix_x>>2)+block_x+i] = min_mcost;
  1307.       }
  1308.     }
  1309.   }
  1311.   mv[0] = best_x - pic_pix_x;
  1312.   mv[1] = best_y - pic_pix_y;
  1314.   return min_mcost;
  1315. }
  1317. /*!
  1318.  ************************************************************************
  1319.  * brief
  1320.  *    Set motion vector predictor
  1321.  ************************************************************************
  1322.  */
  1323. void UMHEXSetMotionVectorPredictor (Macroblock *currMB, 
  1324.                                     short  pmv[2],
  1325.                                     char   **refPic,
  1326.                                     short  ***tmp_mv,
  1327.                                     short  ref_frame,
  1328.                                     int    list,
  1329.                                     int    mb_x,
  1330.                                     int    mb_y,
  1331.                                     int    blockshape_x,
  1332.                                     int    blockshape_y,
  1333.                                     int    *search_range)
  1334. {
  1335.   int mv_a, mv_b, mv_c, pred_vec=0;
  1336.   int mvPredType, rFrameL, rFrameU, rFrameUR;
  1337.   int hv;
  1339.   PixelPos block_a, block_b, block_c, block_d;
  1341.   // added for bipred mode
  1342.   int *** fastme_l0_cost_flag = (bipred_flag ? fastme_l0_cost_bipred:fastme_l0_cost);
  1343.   int *** fastme_l1_cost_flag = (bipred_flag ? fastme_l1_cost_bipred:fastme_l1_cost);
  1345.   //Dynamic Search Range
  1347.   int dsr_temp_search_range[2];
  1348.   int dsr_mv_avail, dsr_mv_max, dsr_mv_sum, dsr_small_search_range;
  1349.   int *mb_size = img->mb_size[IS_LUMA];
  1351.   // neighborhood SAD init
  1352.   SAD_a=0;
  1353.   SAD_b=0;
  1354.   SAD_c=0;
  1355.   SAD_d=0;
  1357.   get4x4Neighbour(currMB, mb_x - 1           , mb_y    , mb_size, &block_a);
  1358.   get4x4Neighbour(currMB, mb_x               , mb_y - 1, mb_size, &block_b);
  1359.   get4x4Neighbour(currMB, mb_x + blockshape_x, mb_y - 1, mb_size, &block_c);
  1360.   get4x4Neighbour(currMB, mb_x - 1           , mb_y - 1, mb_size, &block_d);
  1362.   if (mb_y > 0)
  1363.   {
  1364.     if (mb_x < 8)  // first column of 8x8 blocks
  1365.     {
  1366.       if (mb_y==8)
  1367.       {
  1368.         if (blockshape_x == 16)      block_c.available  = 0;
  1369.       }
  1370.       else
  1371.       {
  1372.         if (mb_x+blockshape_x == 8)  block_c.available = 0;
  1373.       }
  1374.     }
  1375.     else
  1376.     {
  1377.       if (mb_x+blockshape_x == 16)   block_c.available = 0;
  1378.     }
  1379.   }
  1381.   if (!block_c.available)
  1382.   {
  1383.     block_c=block_d;
  1384.   }
  1386.   mvPredType = MVPRED_MEDIAN;
  1388.   if (!img->MbaffFrameFlag)
  1389.   {
  1390.     rFrameL    = block_a.available    ? refPic[block_a.pos_y][block_a.pos_x] : -1;
  1391.     rFrameU    = block_b.available    ? refPic[block_b.pos_y][block_b.pos_x] : -1;
  1392.     rFrameUR   = block_c.available    ? refPic[block_c.pos_y][block_c.pos_x] : -1;
  1393.   }
  1394.   else
  1395.   {
  1396.     if (img->mb_data[img->current_mb_nr].mb_field)
  1397.     {
  1398.       rFrameL  = block_a.available
  1399.         ? (img->mb_data[block_a.mb_addr].mb_field
  1400.         ? refPic[block_a.pos_y][block_a.pos_x]
  1401.         : refPic[block_a.pos_y][block_a.pos_x] * 2) : -1;
  1402.       rFrameU  = block_b.available
  1403.         ? (img->mb_data[block_b.mb_addr].mb_field
  1404.         ? refPic[block_b.pos_y][block_b.pos_x]
  1405.         : refPic[block_b.pos_y][block_b.pos_x] * 2) : -1;
  1406.       rFrameUR = block_c.available
  1407.         ? (img->mb_data[block_c.mb_addr].mb_field
  1408.         ? refPic[block_c.pos_y][block_c.pos_x]
  1409.         : refPic[block_c.pos_y][block_c.pos_x] * 2) : -1;
  1410.     }
  1411.     else
  1412.       {
  1413.       rFrameL = block_a.available
  1414.         ? (img->mb_data[block_a.mb_addr].mb_field
  1415.         ? refPic[block_a.pos_y][block_a.pos_x] >>1
  1416.         : refPic[block_a.pos_y][block_a.pos_x]) : -1;
  1417.       rFrameU    = block_b.available    ?
  1418.         img->mb_data[block_b.mb_addr].mb_field ?
  1419.         refPic[block_b.pos_y][block_b.pos_x] >>1:
  1420.       refPic[block_b.pos_y][block_b.pos_x] :
  1421.       -1;
  1422.       rFrameUR    = block_c.available    ?
  1423.         img->mb_data[block_c.mb_addr].mb_field ?
  1424.         refPic[block_c.pos_y][block_c.pos_x] >>1:
  1425.       refPic[block_c.pos_y][block_c.pos_x] :
  1426.       -1;
  1427.     }
  1428.   }
  1430.   /* Prediction if only one of the neighbors uses the reference frame
  1431.   * we are checking
  1432.   */
  1433.   if(rFrameL == ref_frame && rFrameU != ref_frame && rFrameUR != ref_frame)       mvPredType = MVPRED_L;
  1434.   else if(rFrameL != ref_frame && rFrameU == ref_frame && rFrameUR != ref_frame)  mvPredType = MVPRED_U;
  1435.   else if(rFrameL != ref_frame && rFrameU != ref_frame && rFrameUR == ref_frame)  mvPredType = MVPRED_UR;
  1436.   // Directional predictions
  1437.   if(blockshape_x == 8 && blockshape_y == 16)
  1438.   {
  1439.     if(mb_x == 0)
  1440.     {
  1441.       if(rFrameL == ref_frame)
  1442.         mvPredType = MVPRED_L;
  1443.     }
  1444.     else
  1445.     {
  1446.       if( rFrameUR == ref_frame)
  1447.         mvPredType = MVPRED_UR;
  1448.     }
  1449.   }
  1450.   else if(blockshape_x == 16 && blockshape_y == 8)
  1451.   {
  1452.     if(mb_y == 0)
  1453.     {
  1454.       if(rFrameU == ref_frame)
  1455.         mvPredType = MVPRED_U;
  1456.     }
  1457.     else
  1458.     {
  1459.       if(rFrameL == ref_frame)
  1460.         mvPredType = MVPRED_L;
  1461.     }
  1462.   }
  1464.   // neighborhood SAD prediction
  1465.   if((params->UMHexDSR == 1 || params->BiPredMotionEstimation == 1))
  1466.   {
  1467.     SAD_a = block_a.available ? ((list==1) ? (fastme_l1_cost_flag[UMHEX_blocktype][block_a.pos_y][block_a.pos_x]) : (fastme_l0_cost_flag[UMHEX_blocktype][block_a.pos_y][block_a.pos_x])) : 0;
  1468.     SAD_b = block_b.available ? ((list==1) ? (fastme_l1_cost_flag[UMHEX_blocktype][block_b.pos_y][block_b.pos_x]) : (fastme_l0_cost_flag[UMHEX_blocktype][block_b.pos_y][block_b.pos_x])) : 0;
  1469.     SAD_d = block_d.available ? ((list==1) ? (fastme_l1_cost_flag[UMHEX_blocktype][block_d.pos_y][block_d.pos_x]) : (fastme_l0_cost_flag[UMHEX_blocktype][block_d.pos_y][block_d.pos_x])) : 0;
  1470.     SAD_c = block_c.available ? ((list==1) ? (fastme_l1_cost_flag[UMHEX_blocktype][block_c.pos_y][block_c.pos_x]) : (fastme_l0_cost_flag[UMHEX_blocktype][block_c.pos_y][block_c.pos_x])) : SAD_d;
  1471.   }
  1472.   for (hv=0; hv < 2; hv++)
  1473.   {
  1474.     if (!img->MbaffFrameFlag || hv==0)
  1475.     {
  1476.       mv_a = block_a.available  ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] : 0;
  1477.       mv_b = block_b.available  ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] : 0;
  1478.       mv_c = block_c.available  ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] : 0;
  1479.     }
  1480.     else
  1481.     {
  1482.       if (img->mb_data[img->current_mb_nr].mb_field)
  1483.       {
  1484.         mv_a = block_a.available  ? img->mb_data[block_a.mb_addr].mb_field
  1485.           ? tmp_mv[block_a.pos_y][block_a.pos_x][hv]
  1486.           : tmp_mv[block_a.pos_y][block_a.pos_x][hv] / 2
  1487.           : 0;
  1488.         mv_b = block_b.available  ? img->mb_data[block_b.mb_addr].mb_field
  1489.           ? tmp_mv[block_b.pos_y][block_b.pos_x][hv]
  1490.           : tmp_mv[block_b.pos_y][block_b.pos_x][hv] / 2
  1491.           : 0;
  1492.         mv_c = block_c.available  ? img->mb_data[block_c.mb_addr].mb_field
  1493.           ? tmp_mv[block_c.pos_y][block_c.pos_x][hv]
  1494.           : tmp_mv[block_c.pos_y][block_c.pos_x][hv] / 2
  1495.           : 0;
  1496.       }
  1497.       else
  1498.       {
  1499.         mv_a = block_a.available  ? img->mb_data[block_a.mb_addr].mb_field
  1500.           ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] * 2
  1501.           : tmp_mv[block_a.pos_y][block_a.pos_x][hv]
  1502.           : 0;
  1503.         mv_b = block_b.available  ? img->mb_data[block_b.mb_addr].mb_field
  1504.           ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] * 2
  1505.           : tmp_mv[block_b.pos_y][block_b.pos_x][hv]
  1506.           : 0;
  1507.         mv_c = block_c.available  ? img->mb_data[block_c.mb_addr].mb_field
  1508.           ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] * 2
  1509.           : tmp_mv[block_c.pos_y][block_c.pos_x][hv]
  1510.           : 0;
  1511.       }
  1512.     }
  1514.     switch (mvPredType)
  1515.     {
  1516.     case MVPRED_MEDIAN:
  1517.       if(!(block_b.available || block_c.available))
  1518.       {
  1519.         pred_vec = mv_a;
  1520.       }
  1521.       else
  1522.       {
  1523.         pred_vec = mv_a+mv_b+mv_c-imin(mv_a,imin(mv_b,mv_c))-imax(mv_a,imax(mv_b,mv_c));
  1524.       }
  1525.       break;
  1526.     case MVPRED_L:
  1527.       pred_vec = mv_a;
  1528.       break;
  1529.     case MVPRED_U:
  1530.       pred_vec = mv_b;
  1531.       break;
  1532.     case MVPRED_UR:
  1533.       pred_vec = mv_c;
  1534.       break;
  1535.     default:
  1536.       break;
  1537.     }
  1539.     pmv[hv] = pred_vec;
  1540.     //Dynamic Search Range
  1541.     if (params->UMHexDSR)
  1542.     {
  1543.       dsr_mv_avail=block_a.available+block_b.available+block_c.available;
  1544.       if(dsr_mv_avail < 2)
  1545.       {
  1546.         dsr_temp_search_range[hv] = params->search_range;
  1547.       }
  1548.       else
  1549.       {
  1550.         dsr_mv_max = imax(iabs(mv_a),imax(iabs(mv_b),iabs(mv_c)));
  1551.         dsr_mv_sum = (iabs(mv_a)+iabs(mv_b)+iabs(mv_c));
  1552.         if(dsr_mv_sum == 0) dsr_small_search_range = (params->search_range + 4) >> 3;
  1553.         else if(dsr_mv_sum > 3 ) dsr_small_search_range = (params->search_range + 2) >>2;
  1554.         else dsr_small_search_range = (3*params->search_range + 8) >> 4;
  1555.         dsr_temp_search_range[hv]=imin(params->search_range,imax(dsr_small_search_range,dsr_mv_max<<1));
  1556.         if(imax(SAD_a,imax(SAD_b,SAD_c)) > Threshold_DSR_MB[UMHEX_blocktype])
  1557.           dsr_temp_search_range[hv] = params->search_range;
  1558.       }
  1559.     }
  1560.   }
  1562.   //Dynamic Search Range
  1563.   if (params->UMHexDSR) 
  1564.   {
  1565.     dsr_new_search_range = imax(dsr_temp_search_range[0],dsr_temp_search_range[1]);
  1567.     if      (params->full_search == 2) 
  1568.       *search_range = dsr_new_search_range;
  1569.     else if (params->full_search == 1) 
  1570.       *search_range = dsr_new_search_range /  (imin(ref_frame,1)+1);
  1571.     else                              
  1572.       *search_range = dsr_new_search_range / ((imin(ref_frame,1)+1) * imin(2,BlockType_LUT[(blockshape_y >> 2) - 1][(blockshape_x >> 2) - 1]));
  1573.   }
  1574. }