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

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

Audio

开发平台：

Visual C++

me_umhexsmp.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  *
  5.  * file me_umhexsmp.c
  6.  *
  7.  * brief
  8.  *   Fast integer pixel and sub pixel motion estimation
  9.  *   Improved and simplified from the original UMHexagonS algorithms
  10.  *   See JVT-P021 for details
  11.  *
  12.  * author
  13.  *    Main contributors: (see contributors.h for copyright, address and affiliation details)
  14.  *    - Zhibo Chen                      <chenzhibo@tsinghua.org.cn>
  15.  *    - JianFeng Xu                     <fenax@video.mdc.tsinghua.edu.cn>
  16.  *    - Wenfang Fu                      <fwf@video.mdc.tsinghua.edu.cn>
  17.  *
  18.  *    - Xiaoquan Yi                     <xyi@engr.scu.edu>
  19.  *    - Jun Zhang                       <jzhang2@engr.scu.edu>
  20.  *
  21.  * date
  22.  *    6. Nov. 2006
  23.  *************************************************************************************
  24.  */
  26. #include <limits.h>
  28. #include "global.h"
  29. #include "memalloc.h"
  30. #include "me_umhexsmp.h"
  31. #include "refbuf.h"
  32. #include "me_distortion.h"
  33. #include "mv-search.h"
  36. static const short Diamond_X[4]      = {-1, 1, 0, 0};
  37. static const short Diamond_Y[4]      = { 0, 0,-1, 1};
  38. static const short Hexagon_X[6]      = {-2, 2,-1, 1,-1, 1};
  39. static const short Hexagon_Y[6]      = { 0, 0,-2, 2, 2,-2};
  40. static const short Big_Hexagon_X[16] = {-4, 4, 0, 0,-4, 4,-4, 4,-4, 4,-4, 4,-2, 2,-2, 2};
  41. static const short Big_Hexagon_Y[16] = { 0, 0,-4, 4,-1, 1, 1,-1,-2, 2, 2,-2,-3, 3, 3,-3};
  43. const short block_type_shift_factor[8] = {0, 0, 1, 1, 2, 3, 3, 1}; // last one relaxed to 1 instead 4
  45. static StorablePicture *ref_pic_ptr;
  46. static int dist_method;
  48. extern short*  spiral_hpel_search_x;
  49. extern short*  spiral_hpel_search_y;
  50. extern short*  spiral_search_x;
  51. extern short*  spiral_search_y;
  53. // Macro for motion estimation cost computation per match
  54. #define SEARCH_ONE_PIXEL_HELPER                                                           
  55.   if(iabs(cand_x - center_x) <= search_range && iabs(cand_y - center_y) <= search_range)  
  56.   {                                                                                       
  57.     mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y);             
  58.     mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,             
  59.           min_mcost - mcost, (cand_x + IMG_PAD_SIZE) << 2, (cand_y + IMG_PAD_SIZE) << 2); 
  60.     if (mcost < min_mcost)                                                                
  61.     {                                                                                     
  62.       best_x    = cand_x;                                                                 
  63.       best_y    = cand_y;                                                                 
  64.       min_mcost = mcost;                                                                  
  65.     }                                                                                     
  66. }
  68. #define SEARCH_ONE_PIXEL_BIPRED_HELPER                                                    
  69. if (iabs(cand_x - center2_x) <= search_range && iabs(cand_y - center2_y) <= search_range) 
  70. {                                                                                         
  71.   mcost  = MV_COST (lambda_factor, mvshift, center1_x, center1_y, pred_x1, pred_y1);      
  72.   mcost += MV_COST (lambda_factor, mvshift, cand_x,    cand_y,    pred_x2, pred_y2);      
  73.   if (mcost < min_mcost)                                                                  
  74.   {                                                                                       
  75.     mcost  += computeBiPred(cur_pic, blocksize_y, blocksize_x,                            
  76.                            min_mcost - mcost,                                             
  77.                            (center1_x << 2) + IMG_PAD_SIZE_TIMES4,                        
  78.                            (center1_y << 2) + IMG_PAD_SIZE_TIMES4,                        
  79.                            (cand_x << 2) + IMG_PAD_SIZE_TIMES4,                           
  80.                            (cand_y << 2) + IMG_PAD_SIZE_TIMES4);                          
  81.     if (mcost < min_mcost)                                                                
  82.     {                                                                                     
  83.       best_x = cand_x;                                                                    
  84.       best_y = cand_y;                                                                    
  85.       min_mcost = mcost;                                                                  
  86.     }                                                                                     
  87.   }                                                                                       
  88. }
  90. /*!
  91.  ************************************************************************
  92.  * brief
  93.  *    Set thresholds for fast motion estimation
  94.  *    Those thresholds may be adjusted to trade off rate-distortion
  95.  *    performance and simplified UMHEX speed
  96.  ************************************************************************
  97.  */
  98. void smpUMHEX_init()
  99. {
  100.   SymmetricalCrossSearchThreshold1 =  800;
  101.   SymmetricalCrossSearchThreshold2 = 7000;
  102.   ConvergeThreshold                = 1000;
  103.   SubPelThreshold1                 = 1000;
  104.   SubPelThreshold3                 =  400;
  105. }
  107. /*!
  108.  ************************************************************************
  109.  * brief
  110.  *    Allocation of space for fast motion estimation
  111.  ************************************************************************
  112.  */
  113. int smpUMHEX_get_mem()
  114. {
  115.   int memory_size = 0;
  116.   if (NULL==(smpUMHEX_flag_intra = calloc((img->width>>4)+1, sizeof(byte))))
  117.     no_mem_exit("smpUMHEX_get_mem: smpUMHEX_flag_intra");
  119.   memory_size += get_mem3Dint(&smpUMHEX_l0_cost, 9, img->height/4, img->width/4);
  120.   memory_size += get_mem3Dint(&smpUMHEX_l1_cost, 9, img->height/4, img->width/4);
  121.   memory_size += get_mem2D(&smpUMHEX_SearchState, 7, 7);
  123.   return memory_size;
  124. }
  126. /*!
  127.  ************************************************************************
  128.  * brief
  129.  *    Free space for fast motion estimation
  130.  ************************************************************************
  131.  */
  132. void smpUMHEX_free_mem()
  133. {
  134.   free_mem3Dint(smpUMHEX_l0_cost );
  135.   free_mem3Dint(smpUMHEX_l1_cost );
  136.   free_mem2D(smpUMHEX_SearchState);
  138.   free (smpUMHEX_flag_intra);
  139. }
  142. /*!
  143. ************************************************************************
  144. * brief
  145. *    Fast integer pixel block motion estimation
  146. ************************************************************************
  147. */
  148. int                                     //  ==> minimum motion cost after search
  149. smpUMHEXIntegerPelBlockMotionSearch (Macroblock *currMB,      // <--  current Macroblock
  150.                                      imgpel   *orig_pic,      // <--  not used
  151.                                      short     ref,           // <--  reference frame (0... or -1 (backward))
  152.                                      int       list,          // <--  reference picture list
  153.                                      int       list_offset,   // <--  MBAFF list offset
  154.                                      char   ***refPic,        // <--  reference array
  155.                                      short ****tmp_mv,        // <--  mv array
  156.                                      int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  157.                                      int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  158.                                      int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  159.                                      short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  160.                                      short     mv[2],         //  --> motion vector (x|y) - in pel units
  161.                                      int       search_range,  // <--  1-d search range in pel units
  162.                                      int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  163.                                      int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  164.                                      int       apply_weights
  165.                                      )
  166. {
  167.   int   mvshift       = 2;                                        // motion vector shift for getting sub-pel units
  168.   int   blocksize_y   = params->blc_size[blocktype][1];            // vertical block size
  169.   int   blocksize_x   = params->blc_size[blocktype][0];            // horizontal block size
  170.   int   pred_x        = (pic_pix_x << mvshift) + pred_mv[0];       // predicted position x (in sub-pel units)
  171.   int   pred_y        = (pic_pix_y << mvshift) + pred_mv[1];       // predicted position y (in sub-pel units)
  172.   int   center_x      = pic_pix_x + mv[0];                        // center position x (in pel units)
  173.   int   center_y      = pic_pix_y + mv[1];                        // center position y (in pel units)
  174.   int   best_x        = 0, best_y = 0;
  175.   int   search_step, iYMinNow, iXMinNow;
  176.   int   cand_x, cand_y, mcost;
  178.   unsigned short  i, j, m;
  181.   //===== Use weighted Reference for ME ====
  182.   dist_method = F_PEL + 3 * apply_weights;
  184.   ref_pic_ptr = listX[list+list_offset][ref];
  186.   // Note that following seem to be universal for all functions and could be moved to a separate, clean public function in me_distortion.c
  187.   ref_pic_sub.luma = ref_pic_ptr->p_curr_img_sub;
  189.   img_width  = ref_pic_ptr->size_x;
  190.   img_height = ref_pic_ptr->size_y;
  191.   width_pad  = ref_pic_ptr->size_x_pad;
  192.   height_pad = ref_pic_ptr->size_y_pad;
  194.   if (apply_weights)
  195.   {
  196.     weight_luma = wp_weight[list + list_offset][ref][0];
  197.     offset_luma = wp_offset[list + list_offset][ref][0];
  198.   }
  200.   if (ChromaMEEnable)
  201.   {
  202.     ref_pic_sub.crcb[0] = ref_pic_ptr->imgUV_sub[0];
  203.     ref_pic_sub.crcb[1] = ref_pic_ptr->imgUV_sub[1];
  204.     width_pad_cr  = ref_pic_ptr->size_x_cr_pad;
  205.     height_pad_cr = ref_pic_ptr->size_y_cr_pad;
  207.     if (apply_weights)
  208.     {
  209.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  210.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  211.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  212.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  213.     }
  214.   }
  216.   //===== set function for getting reference picture lines =====
  217.   if ((center_x > search_range) && (center_x < img_width - 1 - search_range - blocksize_x) &&
  218.     (center_y > search_range) && (center_y < img_height - 1 - search_range - blocksize_y))
  219.   {
  220.     ref_access_method = FAST_ACCESS;
  221.   }
  222.   else
  223.   {
  224.     ref_access_method = UMV_ACCESS;
  225.   }
  227.   //check the center median predictor
  228.   cand_x = center_x ;
  229.   cand_y = center_y ;
  230.   mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y);
  233.   mcost += computeUniPred[dist_method](orig_pic, blocksize_y,blocksize_x, min_mcost - mcost,
  234.     (cand_x << 2) + IMG_PAD_SIZE_TIMES4,  (cand_y << 2) + IMG_PAD_SIZE_TIMES4);
  236.   if (mcost < min_mcost)
  237.   {
  238.     min_mcost = mcost;
  239.     best_x    = cand_x;
  240.     best_y    = cand_y;
  241.   }
  243.   iXMinNow = best_x;
  244.   iYMinNow = best_y;
  245.   if ((0 != pred_mv[0]) || (0 != pred_mv[1]))
  246.   {
  247.     cand_x = pic_pix_x;
  248.     cand_y = pic_pix_y;
  249.     SEARCH_ONE_PIXEL_HELPER
  250.   }
  252.   // If the min_mcost is small enough, do a local search then terminate
  253.   // Ihis is good for stationary or quasi-stationary areas
  254.   if (min_mcost < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
  255.   {
  256.     for (m = 0; m < 4; m++)
  257.     {
  258.       cand_x = iXMinNow + Diamond_X[m];
  259.       cand_y = iYMinNow + Diamond_Y[m];
  260.       SEARCH_ONE_PIXEL_HELPER
  261.     }
  262.     mv[0] = (short) (best_x - pic_pix_x);
  263.     mv[1] = (short) (best_y - pic_pix_y);
  264.     return min_mcost;
  265.   }
  267.   // Small local search
  268.   for (m = 0; m < 4; m++)
  269.   {
  270.     cand_x = iXMinNow + Diamond_X[m];
  271.     cand_y = iYMinNow + Diamond_Y[m];
  272.     SEARCH_ONE_PIXEL_HELPER
  273.   }
  275.   // First_step: Symmetrical-cross search
  276.   // If distortion is large, use large shapes. Otherwise, compact shapes are faster
  277.   if ( (blocktype == 1 &&
  278.     min_mcost > (SymmetricalCrossSearchThreshold1>>block_type_shift_factor[blocktype])) ||
  279.     (min_mcost > (SymmetricalCrossSearchThreshold2>>block_type_shift_factor[blocktype])) )
  280.   {
  281.     iXMinNow = best_x;
  282.     iYMinNow = best_y;
  284.     for(i = 1; i <= search_range/2; i++)
  285.     {
  286.       search_step = (i<<1) - 1;
  287.       cand_x = iXMinNow + search_step;
  288.       cand_y = iYMinNow;
  289.       SEARCH_ONE_PIXEL_HELPER
  291.         cand_x = iXMinNow - search_step;
  292.       SEARCH_ONE_PIXEL_HELPER
  294.         cand_x = iXMinNow;
  295.       cand_y = iYMinNow + search_step;
  296.       SEARCH_ONE_PIXEL_HELPER
  298.         cand_y = iYMinNow - search_step;
  299.       SEARCH_ONE_PIXEL_HELPER
  300.     }
  302.     // Hexagon Search
  303.     iXMinNow = best_x;
  304.     iYMinNow = best_y;
  305.     for (m = 0; m < 6; m++)
  306.     {
  307.       cand_x = iXMinNow + Hexagon_X[m];
  308.       cand_y = iYMinNow + Hexagon_Y[m];
  309.       SEARCH_ONE_PIXEL_HELPER
  310.     }
  311.     // Multi Big Hexagon Search
  312.     iXMinNow = best_x;
  313.     iYMinNow = best_y;
  314.     for(i = 1; i <= search_range/4; i++)
  315.     {
  316.       for (m = 0; m < 16; m++)
  317.       {
  318.         cand_x = iXMinNow + Big_Hexagon_X[m]*i;
  319.         cand_y = iYMinNow + Big_Hexagon_Y[m]*i;
  320.         SEARCH_ONE_PIXEL_HELPER
  321.       }
  322.     }
  323.   }
  325.   // Search up_layer predictor for non 16x16 blocks
  326.   if (blocktype > 1)
  327.   {
  328.     cand_x = pic_pix_x + (smpUMHEX_pred_MV_uplayer_X/4);
  329.     cand_y = pic_pix_y + (smpUMHEX_pred_MV_uplayer_Y/4);
  330.     SEARCH_ONE_PIXEL_HELPER
  331.   }
  333.   if(center_x != pic_pix_x || center_y != pic_pix_y)
  334.   {
  335.     cand_x = pic_pix_x;
  336.     cand_y = pic_pix_y;
  337.     SEARCH_ONE_PIXEL_HELPER
  339.       iXMinNow = best_x;
  340.     iYMinNow = best_y;
  341.     // Local diamond search
  342.     for (m = 0; m < 4; m++)
  343.     {
  344.       cand_x = iXMinNow + Diamond_X[m];
  345.       cand_y = iYMinNow + Diamond_Y[m];
  346.       SEARCH_ONE_PIXEL_HELPER
  347.     }
  348.   }
  350.   // If the minimum cost is small enough, do a local search
  351.   // and finish the search here
  352.   if (min_mcost < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
  353.   {
  354.     iXMinNow = best_x;
  355.     iYMinNow = best_y;
  356.     for (m = 0; m < 4; m++)
  357.     {
  358.       cand_x = iXMinNow + Diamond_X[m];
  359.       cand_y = iYMinNow + Diamond_Y[m];
  360.       SEARCH_ONE_PIXEL_HELPER
  361.     }
  362.     mv[0] = (short) (best_x - pic_pix_x);
  363.     mv[1] = (short) (best_y - pic_pix_y);
  364.     return min_mcost;
  365.   }
  367.   //second_step:  Extended Hexagon-based Search
  368.   for(i = 0; i < search_range; i++)
  369.   {
  370.     iXMinNow = best_x;
  371.     iYMinNow = best_y;
  372.     for (m = 0; m < 6; m++)
  373.     {
  374.       cand_x = iXMinNow + Hexagon_X[m];
  375.       cand_y = iYMinNow + Hexagon_Y[m];
  376.       SEARCH_ONE_PIXEL_HELPER
  377.     }
  378.     // The minimum cost point happens in the center
  379.     if (best_x == iXMinNow && best_y == iYMinNow)
  380.     {
  381.       break;
  382.     }
  383.   }
  385.   //third_step: Small diamond search
  386.   for(i = 0; i < search_range; i++)
  387.   {
  388.     iXMinNow = best_x;
  389.     iYMinNow = best_y;
  390.     for (m = 0; m < 4; m++)
  391.     {
  392.       cand_x = iXMinNow + Diamond_X[m];
  393.       cand_y = iYMinNow + Diamond_Y[m];
  394.       SEARCH_ONE_PIXEL_HELPER
  395.     }
  397.     // The minimum cost point happens in the center
  398.     if (best_x == iXMinNow && best_y == iYMinNow)
  399.     {
  400.       break;
  401.     }
  402.   }
  404.   mv[0] = (short) (best_x - pic_pix_x);
  405.   mv[1] = (short) (best_y - pic_pix_y);
  407.   for (j=(pic_pix_y>>2); j < (pic_pix_y>>2) + (blocksize_y>>2); j++)
  408.   {
  409.     for (i=(pic_pix_x>>2); i < (pic_pix_x>>2) + (blocksize_x>>2); i++)    
  410.     {
  411.       if(list == 0)
  412.       {
  413.         smpUMHEX_l0_cost[blocktype][j][i] = min_mcost;
  414.       }
  415.       else
  416.       {
  417.         smpUMHEX_l1_cost[blocktype][j][i] = min_mcost;
  418.       }
  419.     }
  420.   }
  422.   return min_mcost;
  423. }
  425. /*!
  426.  ***********************************************************************
  427.  * brief
  428.  *    Sub pixel block motion search enhanced
  429.  ***********************************************************************
  430.  */
  431. int                                               //  ==> minimum motion cost after search
  432. smpUMHEXFullSubPelBlockMotionSearch (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  433.                                      short     ref,           // <--  reference frame (0... or -1 (backward))
  434.                                      int       list,          // <--  reference picture list
  435.                                      int       list_offset,
  436.                                      int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  437.                                      int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  438.                                      int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  439.                                      short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  440.                                      short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  441.                                      int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  442.                                      int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  443.                                      int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  444.                                      int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  445.                                      int       apply_weights
  446.                                      )
  447. {
  448.   int   pos, best_pos, mcost;
  450.   int   cand_mv_x, cand_mv_y;
  452.   int   check_position0 = (!params->rdopt && img->type!=B_SLICE && ref==0 && blocktype==1 && mv[0]==0 && mv[1]==0);
  453.   int   blocksize_x     = params->blc_size[blocktype][0];
  454.   int   blocksize_y     = params->blc_size[blocktype][1];
  455.   int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<< 2);
  456.   int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<< 2);
  457.   int   max_pos2        = ( !start_me_refinement_hp ? imax(1,search_pos2) : search_pos2);
  459.   int   cmv_x, cmv_y;
  461.   StorablePicture *ref_picture = listX[list+list_offset][ref];
  463.   int max_pos_x4 = ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  464.   int max_pos_y4 = ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);
  466.   dist_method = Q_PEL + 3 * apply_weights;
  468.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  470.   img_width  = ref_picture->size_x;
  471.   img_height = ref_picture->size_y;
  472.   width_pad  = ref_picture->size_x_pad;
  473.   height_pad = ref_picture->size_y_pad;
  475.   if (apply_weights)
  476.   {
  477.     weight_luma = wp_weight[list + list_offset][ref][0];
  478.     offset_luma = wp_offset[list + list_offset][ref][0];
  479.   }
  481.   if (ChromaMEEnable)
  482.   {
  483.     ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
  484.     ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
  485.     width_pad_cr  = ref_picture->size_x_cr_pad;
  486.     height_pad_cr = ref_picture->size_y_cr_pad;
  488.     if (apply_weights)
  489.     {
  490.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  491.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  492.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  493.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  494.     }
  495.   }
  497.   /*********************************
  498.    *****                       *****
  499.    *****  HALF-PEL REFINEMENT  *****
  500.    *****                       *****
  501.    *********************************/
  503.   //===== set function for getting pixel values =====
  504.   if ((pic4_pix_x + mv[0] > 1) && (pic4_pix_x + mv[0] < max_pos_x4 - 1) &&
  505.     (pic4_pix_y + mv[1] > 1) && (pic4_pix_y + mv[1] < max_pos_y4 - 1)   )
  506.   {
  507.     ref_access_method = FAST_ACCESS;
  508.   }
  509.   else
  510.   {
  511.     ref_access_method = UMV_ACCESS;
  512.   }
  514.   //===== loop over search positions =====
  515.   for (best_pos = 0, pos = start_me_refinement_hp; pos < max_pos2; pos++)
  516.   {
  517.     cand_mv_x = mv[0] + (spiral_hpel_search_x[pos]);    // quarter-pel units
  518.     cand_mv_y = mv[1] + (spiral_hpel_search_y[pos]);    // quarter-pel units
  520.     //----- set motion vector cost -----
  521.     mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  523.     if (mcost >= min_mcost) continue;
  525.     cmv_x = cand_mv_x + pic4_pix_x;
  526.     cmv_y = cand_mv_y + pic4_pix_y;
  528.     mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x, min_mcost - mcost, cmv_x, cmv_y);
  530.     if (pos==0 && check_position0)
  531.     {
  532.       mcost -= WEIGHTED_COST (lambda_factor, 16);
  533.     }
  535.     if (mcost < min_mcost)
  536.     {
  537.       min_mcost = mcost;
  538.       best_pos  = pos;
  539.     }
  540.     if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
  541.     {
  542.       break;
  543.     }
  544.   }
  546.   if (best_pos)
  547.   {
  548.     mv[0] += (spiral_hpel_search_x [best_pos]);
  549.     mv[1] += (spiral_hpel_search_y [best_pos]);
  550.   }
  552.   if ((mv[0] == 0) && (mv[1] == 0) && (pred_mv[0] == 0 && pred_mv[1] == 0) &&
  553.     (min_mcost < (SubPelThreshold1>>block_type_shift_factor[blocktype])) )
  554.   {
  555.     best_pos = 0;
  556.     return min_mcost;
  557.   }
  559.   if ( !start_me_refinement_qp )
  560.     min_mcost = INT_MAX;
  562.   /************************************
  563.    *****                          *****
  564.    *****  QUARTER-PEL REFINEMENT  *****
  565.    *****                          *****
  566.    ************************************/
  567.   //===== set function for getting pixel values =====
  568.   if ((pic4_pix_x + mv[0] > 0) && (pic4_pix_x + mv[0] < max_pos_x4) &&
  569.     (pic4_pix_y + mv[1] > 0) && (pic4_pix_y + mv[1] < max_pos_y4)   )
  570.   {
  571.     ref_access_method = FAST_ACCESS;
  572.   }
  573.   else
  574.   {
  575.     ref_access_method = UMV_ACCESS;
  576.   }
  578.   //===== loop over search positions =====
  579.   for (best_pos = 0, pos = start_me_refinement_qp; pos < search_pos4; pos++)
  580.   {
  581.     cand_mv_x = mv[0] + spiral_search_x[pos];    // quarter-pel units
  582.     cand_mv_y = mv[1] + spiral_search_y[pos];    // quarter-pel units
  584.     //----- set motion vector cost -----
  585.     mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  587.     if (mcost >= min_mcost) continue;
  589.     cmv_x = cand_mv_x + pic4_pix_x;
  590.     cmv_y = cand_mv_y + pic4_pix_y;
  592.     mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x, min_mcost - mcost, cmv_x, cmv_y);
  594.     if (mcost < min_mcost)
  595.     {
  596.       min_mcost = mcost;
  597.       best_pos  = pos;
  598.     }
  599.     if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
  600.     {
  601.       break;
  602.     }
  603.   }
  605.   if (best_pos)
  606.   {
  607.     mv[0] += spiral_search_x [best_pos];
  608.     mv[1] += spiral_search_y [best_pos];
  609.   }
  611.   //===== return minimum motion cost =====
  612.   return min_mcost;
  613. }
  616. /*!
  617.  ************************************************************************
  618.  * brief
  619.  *    Fast sub pixel block motion estimation
  620.  ************************************************************************
  621.  */
  622. int                                     //  ==> minimum motion cost after search
  623. smpUMHEXSubPelBlockMotionSearch  (
  624.                                   imgpel* orig_pic,        // <--  original pixel values for the AxB block
  625.                                   short     ref,           // <--  reference frame (0... or -1 (backward))
  626.                                   int       list,          // <--  reference picture list
  627.                                   int       list_offset,   // <--  MBAFF list offset
  628.                                   int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  629.                                   int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  630.                                   int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  631.                                   short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  632.                                   short     mv[2],         // <--> in: search center (x|y) / out: MV (x|y) - in pel units
  633.                                   int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  634.                                   int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  635.                                   int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  636.                                   int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  637.                                   int       apply_weights
  638.                                   )
  639. {
  640.   int   mcost;
  641.   int   cand_mv_x, cand_mv_y;
  643.   StorablePicture *ref_picture = listX[list+list_offset][ref];
  645.   short mv_shift        = 0;
  646.   short blocksize_x     = (short) params->blc_size[blocktype][0];
  647.   short blocksize_y     = (short) params->blc_size[blocktype][1];
  648.   int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<<2);
  649.   int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<<2);
  650.   short max_pos_x4      = (short) ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  651.   short max_pos_y4      = (short) ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);
  653.   int   iXMinNow, iYMinNow;
  654.   short dynamic_search_range, i, m;
  655.   int   currmv_x = 0, currmv_y = 0;
  656.   int   pred_frac_mv_x,pred_frac_mv_y,abort_search;
  657.   int   pred_frac_up_mv_x, pred_frac_up_mv_y;
  659.   dist_method = Q_PEL + 3 * apply_weights;
  661.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  663.   img_width  = ref_pic_ptr->size_x;
  664.   img_height = ref_pic_ptr->size_y;
  665.   width_pad  = ref_pic_ptr->size_x_pad;
  666.   height_pad = ref_pic_ptr->size_y_pad;
  668.   if (apply_weights)
  669.   {
  670.     weight_luma = wp_weight[list + list_offset][ref][0];
  671.     offset_luma = wp_offset[list + list_offset][ref][0];
  672.   }
  674.   if (ChromaMEEnable)
  675.   {
  676.     ref_pic_sub.crcb[0] = ref_pic_ptr->imgUV_sub[0];
  677.     ref_pic_sub.crcb[1] = ref_pic_ptr->imgUV_sub[1];
  678.     width_pad_cr  = ref_pic_ptr->size_x_cr_pad;
  679.     height_pad_cr = ref_pic_ptr->size_y_cr_pad;
  681.     if (apply_weights)
  682.     {
  683.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  684.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  685.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  686.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  687.     }
  688.   }
  691.   if ((pic4_pix_x + mv[0] > 1) && (pic4_pix_x + mv[0] < max_pos_x4 - 1) &&
  692.     (pic4_pix_y + mv[1] > 1) && (pic4_pix_y + mv[1] < max_pos_y4 - 1))
  693.   {
  694.     ref_access_method = FAST_ACCESS;
  695.   }
  696.   else
  697.   {
  698.     ref_access_method = UMV_ACCESS;
  699.   }
  701.   dynamic_search_range = 3;
  702.   pred_frac_mv_x = (pred_mv[0] - mv[0]) % 4;
  703.   pred_frac_mv_y = (pred_mv[1] - mv[1]) % 4;
  705.   pred_frac_up_mv_x = (smpUMHEX_pred_MV_uplayer_X - mv[0]) % 4;
  706.   pred_frac_up_mv_y = (smpUMHEX_pred_MV_uplayer_Y - mv[1]) % 4;
  708.   memset(smpUMHEX_SearchState[0], 0,
  709.     (2*dynamic_search_range+1)*(2*dynamic_search_range+1));
  711.   smpUMHEX_SearchState[dynamic_search_range][dynamic_search_range] = 1;
  712.   if( !start_me_refinement_hp )
  713.   {
  714.     cand_mv_x = mv[0];
  715.     cand_mv_y = mv[1];
  716.     mcost   = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  717.     mcost   += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
  718.       min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  719.     if (mcost < min_mcost)
  720.     {
  721.       min_mcost = mcost;
  722.       currmv_x  = cand_mv_x;
  723.       currmv_y  = cand_mv_y;
  724.     }
  725.   }
  726.   else
  727.   {
  728.     currmv_x = mv[0];
  729.     currmv_y = mv[1];
  730.   }
  732.   // If the min_mcost is small enough and other statistics are positive,
  733.   // better to stop the search now
  734.   if ( ((mv[0]) == 0) && ((mv[1]) == 0) &&
  735.     (pred_frac_mv_x == 0 && pred_frac_up_mv_x == 0) &&
  736.     (pred_frac_mv_y == 0 && pred_frac_up_mv_y == 0) &&
  737.     (min_mcost < (SubPelThreshold1>>block_type_shift_factor[blocktype])) )
  738.   {
  739.     mv[0] = (short) currmv_x;
  740.     mv[1] = (short) currmv_y;
  741.     return min_mcost;
  742.   }
  744.   if(pred_frac_mv_x || pred_frac_mv_y)
  745.   {
  746.     cand_mv_x = mv[0] + pred_frac_mv_x;
  747.     cand_mv_y = mv[1] + pred_frac_mv_y;
  748.     mcost   = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  749.     mcost   += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
  750.       min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  752.     smpUMHEX_SearchState[cand_mv_y -mv[1] + dynamic_search_range][cand_mv_x - mv[0] + dynamic_search_range] = 1;
  753.     if (mcost < min_mcost)
  754.     {
  755.       min_mcost = mcost;
  756.       currmv_x  = cand_mv_x;
  757.       currmv_y  = cand_mv_y;
  758.     }
  759.   }
  761.   // Multiple small diamond search
  762.   for(i = 0; i < dynamic_search_range; i++)
  763.   {
  764.     abort_search = 1;
  766.     iXMinNow = currmv_x;
  767.     iYMinNow = currmv_y;
  768.     for (m = 0; m < 4; m++)
  769.     {
  770.       cand_mv_x = iXMinNow + Diamond_X[m];
  771.       cand_mv_y = iYMinNow + Diamond_Y[m];
  773.       if(iabs(cand_mv_x - mv[0]) <= dynamic_search_range && iabs(cand_mv_y - mv[1]) <= dynamic_search_range)
  774.       {
  775.         if(!smpUMHEX_SearchState[cand_mv_y - mv[1] + dynamic_search_range][cand_mv_x - mv[0] + dynamic_search_range])
  776.         {
  777.           mcost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  778.           mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
  779.             min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  781.           smpUMHEX_SearchState[cand_mv_y - mv[1] + dynamic_search_range][cand_mv_x - mv[0] + dynamic_search_range] = 1;
  783.           if (mcost < min_mcost)
  784.           {
  785.             min_mcost    = mcost;
  786.             currmv_x     = cand_mv_x;
  787.             currmv_y     = cand_mv_y;
  788.             abort_search = 0;
  789.           }
  790.           if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
  791.           {
  792.             mv[0] = (short) currmv_x;
  793.             mv[1] = (short) currmv_y;
  794.             return min_mcost;
  795.           }
  796.         }
  797.       }
  798.     }
  799.     // If the minimum cost point is in the center, break out the loop
  800.     if (abort_search)
  801.     {
  802.       break;
  803.     }
  804.   }
  806.   mv[0] = (short) currmv_x;
  807.   mv[1] = (short) currmv_y;
  808.   return min_mcost;
  809. }
  812. int                                                   //  ==> minimum motion cost after search
  813. smpUMHEXSubPelBlockME (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  814.                     short     ref,           // <--  reference frame (0... or -1 (backward))
  815.                     int       list,
  816.                     int       list_offset,   // <--  MBAFF list offset
  817.                     int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  818.                     int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  819.                     int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  820.                     short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  821.                     short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in sub-pel units
  822.                     int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  823.                     int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  824.                     int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  825.                     int*      lambda_factor,
  826.                     int       apply_weights
  827.                     )
  828. {  
  829.   if(blocktype > 1)
  830.   {
  831.     min_mcost =  smpUMHEXSubPelBlockMotionSearch (orig_pic, ref, list, list_offset, pic_pix_x, pic_pix_y,
  832.       blocktype, pred_mv, mv, 9, 9, min_mcost, lambda_factor[Q_PEL], apply_weights);
  833.   }
  834.   else
  835.   {
  836.     min_mcost =  smpUMHEXFullSubPelBlockMotionSearch (orig_pic, ref, list, list_offset, pic_pix_x, pic_pix_y,
  837.       blocktype, pred_mv, mv, 9, 9, min_mcost, lambda_factor[Q_PEL], apply_weights);
  838.   }
  840.   return min_mcost;
  841. }
  843. /*!
  844.  ************************************************************************
  845.  * brief
  846.  *    smpUMHEXBipredIntegerPelBlockMotionSearch: fast pixel block motion search for bipred mode
  847.  *
  848.  ************************************************************************
  849.  */
  850. int                                                           //  ==> minimum motion cost after search
  851. smpUMHEXBipredIntegerPelBlockMotionSearch (Macroblock *currMB, // <--  current Macroblock
  852.                                            imgpel* cur_pic,   // <--  original pixel values for the AxB block
  853.                                            short     ref,           // <--  reference frame (0... or -1 (backward))
  854.                                            int       list,          // <--  Current reference list
  855.                                            int       list_offset,   // <--  MBAFF list offset
  856.                                            char   ***refPic,        // <--  reference array
  857.                                            short ****tmp_mv,        // <--  mv array
  858.                                            int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  859.                                            int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  860.                                            int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  861.                                            short     pred_mv1[2],   // <--  motion vector predictor (x|y) in sub-pel units
  862.                                            short     pred_mv2[2],   // <--  motion vector predictor (x|y) in sub-pel units
  863.                                            short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  864.                                            short     s_mv[2],       // <--> in: search center (x|y) 
  865.                                            int       search_range,  // <--  1-d search range in pel units
  866.                                            int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  867.                                            int       iteration_no,  // <--  bi pred iteration number
  868.                                            int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  869.                                            int       apply_weights
  870.                                            )
  871. {
  872.   int   mvshift       = 2;                              // motion vector shift for getting sub-pel units
  874.   int   search_step, iYMinNow, iXMinNow;
  875.   int   i, m;
  876.   int   cand_x, cand_y, mcost;
  877.   int   blocksize_y   = params->blc_size[blocktype][1];  // vertical block size
  878.   int   blocksize_x   = params->blc_size[blocktype][0];  // horizontal block size
  879.   int   pred_x1       = (pic_pix_x << 2) + pred_mv1[0];  // predicted position x (in sub-pel units)
  880.   int   pred_y1       = (pic_pix_y << 2) + pred_mv1[1];  // predicted position y (in sub-pel units)
  881.   int   pred_x2       = (pic_pix_x << 2) + pred_mv2[0];  // predicted position x (in sub-pel units)
  882.   int   pred_y2       = (pic_pix_y << 2) + pred_mv2[1];  // predicted position y (in sub-pel units)
  883.   short center2_x     = pic_pix_x + mv[0];               // center position x (in pel units)
  884.   short center2_y     = pic_pix_y + mv[1];               // center position y (in pel units)
  885.   short center1_x     = pic_pix_x + s_mv[0];             // mvx of second pred (in pel units)
  886.   short center1_y     = pic_pix_y + s_mv[1];             // mvy of second pred (in pel units)
  887.   int   best_x        = center2_x;
  888.   int   best_y        = center2_y;
  890.   short offset1 = (apply_weights ? (list == 0?  wp_offset[list_offset    ][ref][0]:  wp_offset[list_offset + 1][0  ][ref]) : 0);
  891.   short offset2 = (apply_weights ? (list == 0?  wp_offset[list_offset + 1][ref][0]:  wp_offset[list_offset    ][0  ][ref]) : 0);
  893.   ref_pic1_sub.luma = listX[list + list_offset][ref]->p_curr_img_sub;
  894.   ref_pic2_sub.luma = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->p_curr_img_sub;
  896.   img_width  = listX[list + list_offset][ref]->size_x;
  897.   img_height = listX[list + list_offset][ref]->size_y;
  898.   width_pad  = listX[list + list_offset][ref]->size_x_pad;
  899.   height_pad = listX[list + list_offset][ref]->size_y_pad;
  901.   if (apply_weights)
  902.   {
  903.     weight1 = list == 0 ? wbp_weight[list_offset         ][ref][0][0] : wbp_weight[list_offset + LIST_1][0  ][ref][0];
  904.     weight2 = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][0] : wbp_weight[list_offset         ][0  ][ref][0];
  905.     offsetBi=(offset1 + offset2 + 1)>>1;
  906.     computeBiPred = computeBiPredSAD2; //ME only supports SAD computations
  907.   }
  908.   else
  909.   {
  910.     weight1 = 1<<luma_log_weight_denom;
  911.     weight2 = 1<<luma_log_weight_denom;
  912.     offsetBi = 0;
  913.     computeBiPred = computeBiPredSAD1; //ME only supports SAD computations
  914.   }
  916.   if (ChromaMEEnable )
  917.   {
  918.     ref_pic1_sub.crcb[0] = listX[list + list_offset][ref]->imgUV_sub[0];
  919.     ref_pic1_sub.crcb[1] = listX[list + list_offset][ref]->imgUV_sub[1];
  920.     ref_pic2_sub.crcb[0] = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgUV_sub[0];
  921.     ref_pic2_sub.crcb[1] = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgUV_sub[1];
  922.     width_pad_cr  = listX[list + list_offset][ref]->size_x_cr_pad;
  923.     height_pad_cr = listX[list + list_offset][ref]->size_y_cr_pad;
  924.     if (apply_weights)
  925.     {
  926.       weight1_cr[0] = list == 0 ? wbp_weight[list_offset         ][ref][0][1] : wbp_weight[list_offset + LIST_1][0  ][ref][1];
  927.       weight1_cr[1] = list == 0 ? wbp_weight[list_offset         ][ref][0][2] : wbp_weight[list_offset + LIST_1][0  ][ref][2];
  928.       weight2_cr[0] = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][1] : wbp_weight[list_offset         ][0  ][ref][1];
  929.       weight2_cr[1] = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][2] : wbp_weight[list_offset         ][0  ][ref][2];
  930.       offsetBi_cr[0] = (list == 0)
  931.         ? (wp_offset[list_offset         ][ref][1] + wp_offset[list_offset + LIST_1][ref][1] + 1) >> 1
  932.         : (wp_offset[list_offset + LIST_1][0  ][1] + wp_offset[list_offset         ][0  ][1] + 1) >> 1;
  933.       offsetBi_cr[1] = (list == 0)
  934.         ? (wp_offset[list_offset         ][ref][2] + wp_offset[list_offset + LIST_1][ref][2] + 1) >> 1
  935.         : (wp_offset[list_offset + LIST_1][0  ][2] + wp_offset[list_offset         ][0  ][2] + 1) >> 1;
  936.     }
  937.     else
  938.     {
  939.       weight1_cr[0] = 1<<chroma_log_weight_denom;
  940.       weight1_cr[1] = 1<<chroma_log_weight_denom;
  941.       weight2_cr[0] = 1<<chroma_log_weight_denom;
  942.       weight2_cr[1] = 1<<chroma_log_weight_denom;
  943.       offsetBi_cr[0] = 0;
  944.       offsetBi_cr[1] = 0;
  945.     }
  946.   }
  948.   // Set function for getting reference picture lines
  949.   if ((center2_x > search_range) && (center2_x < img_width -1-search_range-blocksize_x) &&
  950.       (center2_y > search_range) && (center2_y < img_height-1-search_range-blocksize_y))
  951.   {
  952.     bipred2_access_method = FAST_ACCESS;
  953.   }
  954.   else
  955.   {
  956.     bipred2_access_method = UMV_ACCESS;
  957.   }
  959.   // Set function for getting reference picture lines
  960.   if ((center1_y > search_range) && (center1_y < img_height-1-search_range-blocksize_y))
  961.   {
  962.     bipred1_access_method = FAST_ACCESS;
  963.   }
  964.   else
  965.   {
  966.     bipred1_access_method = UMV_ACCESS;
  967.   }
  969.   // Check the center median predictor
  970.   cand_x = center2_x ;
  971.   cand_y = center2_y ;
  972.   mcost  = MV_COST (lambda_factor, mvshift, center1_x, center1_y, pred_x1, pred_y1);
  973.   mcost += MV_COST (lambda_factor, mvshift, cand_x,    cand_y,    pred_x2, pred_y2);
  975.   mcost += computeBiPred(cur_pic,
  976.                         blocksize_y, blocksize_x, INT_MAX,
  977.                         (center1_x << 2) + IMG_PAD_SIZE_TIMES4,
  978.                         (center1_y << 2) + IMG_PAD_SIZE_TIMES4,
  979.                         (cand_x << 2) + IMG_PAD_SIZE_TIMES4,
  980.                         (cand_y << 2) + IMG_PAD_SIZE_TIMES4);
  982.   if (mcost < min_mcost)
  983.   {
  984.     min_mcost = mcost;
  985.     best_x = cand_x;
  986.     best_y = cand_y;
  987.   }
  989.   iXMinNow = best_x;
  990.   iYMinNow = best_y;
  991.   if (0 != pred_mv1[0] || 0 != pred_mv1[1] || 0 != pred_mv2[0] || 0 != pred_mv2[1])
  992.   {
  993.     cand_x = pic_pix_x;
  994.     cand_y = pic_pix_y;
  995.     SEARCH_ONE_PIXEL_BIPRED_HELPER;
  996.   }
  998.   // If the min_mcost is small enough, do a local search then terminate
  999.   // This is good for stationary or quasi-stationary areas
  1000.   if ((min_mcost<<3) < (ConvergeThreshold>>(block_type_shift_factor[blocktype])))
  1001.   {
  1002.     for (m = 0; m < 4; m++)
  1003.     {
  1004.       cand_x = iXMinNow + Diamond_X[m];
  1005.       cand_y = iYMinNow + Diamond_Y[m];
  1006.       SEARCH_ONE_PIXEL_BIPRED_HELPER;
  1007.     }
  1008.     mv[0] = best_x - pic_pix_x;
  1009.     mv[1] = best_y - pic_pix_y;
  1010.     return min_mcost;
  1011.   }
  1013.   // Small local search
  1014.   for (m = 0; m < 4; m++)
  1015.   {
  1016.     cand_x = iXMinNow + Diamond_X[m];
  1017.     cand_y = iYMinNow + Diamond_Y[m];
  1018.     SEARCH_ONE_PIXEL_BIPRED_HELPER;
  1019.   }
  1021.   // First_step: Symmetrical-cross search
  1022.   // If distortion is large, use large shapes. Otherwise, compact shapes are faster
  1023.   if ((blocktype == 1 &&
  1024.     (min_mcost<<2) > (SymmetricalCrossSearchThreshold1>>block_type_shift_factor[blocktype])) ||
  1025.     ((min_mcost<<2) > (SymmetricalCrossSearchThreshold2>>block_type_shift_factor[blocktype])))
  1026.   {
  1027.     iXMinNow = best_x;
  1028.     iYMinNow = best_y;
  1030.     for (i = 1; i <= search_range / 2; i++)
  1031.     {
  1032.       search_step = (i<<1) - 1;
  1033.       cand_x = iXMinNow + search_step;
  1034.       cand_y = iYMinNow;
  1035.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1037.       cand_x = iXMinNow - search_step;
  1038.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1040.       cand_x = iXMinNow;
  1041.       cand_y = iYMinNow + search_step;
  1042.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1044.       cand_y = iYMinNow - search_step;
  1045.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1046.     }
  1048.     // Hexagon Search
  1049.     iXMinNow = best_x;
  1050.     iYMinNow = best_y;
  1051.     for (m = 0; m < 6; m++)
  1052.     {
  1053.       cand_x = iXMinNow + Hexagon_X[m];
  1054.       cand_y = iYMinNow + Hexagon_Y[m];
  1055.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1056.     }
  1057.     // Multi Big Hexagon Search
  1058.     iXMinNow = best_x;
  1059.     iYMinNow = best_y;
  1060.     for(i = 1; i <= search_range / 4; i++)
  1061.     {
  1062.       for (m = 0; m < 16; m++)
  1063.       {
  1064.         cand_x = iXMinNow + Big_Hexagon_X[m] * i;
  1065.         cand_y = iYMinNow + Big_Hexagon_Y[m] * i;
  1066.         SEARCH_ONE_PIXEL_BIPRED_HELPER
  1067.       }
  1068.     }
  1069.   }
  1071.   // Search up_layer predictor for non 16x16 blocks
  1072.   if (blocktype > 1)
  1073.   {
  1074.     cand_x = pic_pix_x + (smpUMHEX_pred_MV_uplayer_X / 4);
  1075.     cand_y = pic_pix_y + (smpUMHEX_pred_MV_uplayer_Y / 4);
  1076.     SEARCH_ONE_PIXEL_BIPRED_HELPER
  1077.   }
  1079.   if(center2_x != pic_pix_x || center2_y != pic_pix_y)
  1080.   {
  1081.     cand_x = pic_pix_x;
  1082.     cand_y = pic_pix_y;
  1083.     SEARCH_ONE_PIXEL_BIPRED_HELPER
  1085.     iXMinNow = best_x;
  1086.     iYMinNow = best_y;
  1087.     // Local diamond search
  1088.     for (m = 0; m < 4; m++)
  1089.     {
  1090.       cand_x = iXMinNow + Diamond_X[m];
  1091.       cand_y = iYMinNow + Diamond_Y[m];
  1092.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1093.     }
  1094.   }
  1096.   // If the minimum cost is small enough, do a local search
  1097.   // and finish the search here
  1098.   if ((min_mcost<<2) < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
  1099.   {
  1100.     iXMinNow = best_x;
  1101.     iYMinNow = best_y;
  1102.     for (m = 0; m < 4; m++)
  1103.     {
  1104.       cand_x = iXMinNow + Diamond_X[m];
  1105.       cand_y = iYMinNow + Diamond_Y[m];
  1106.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1107.     }
  1108.     mv[0] = (short) (best_x - pic_pix_x);
  1109.     mv[1] = (short) (best_y - pic_pix_y);
  1110.     return min_mcost;
  1111.   }
  1113.   // Second_step:  Extended Hexagon-based Search
  1114.   for (i = 0; i < search_range; i++)
  1115.   {
  1116.     iXMinNow = best_x;
  1117.     iYMinNow = best_y;
  1118.     for (m = 0; m < 6; m++)
  1119.     {
  1120.       cand_x = iXMinNow + Hexagon_X[m];
  1121.       cand_y = iYMinNow + Hexagon_Y[m];
  1122.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1123.     }
  1124.     // The minimum cost point happens in the center
  1125.     if (best_x == iXMinNow && best_y == iYMinNow)
  1126.     {
  1127.       break;
  1128.     }
  1129.   }
  1131.   // Third_step: Small diamond search
  1132.   for (i = 0; i < search_range; i++)
  1133.   {
  1134.     iXMinNow = best_x;
  1135.     iYMinNow = best_y;
  1136.     for (m = 0; m < 4; m++)
  1137.     {
  1138.       cand_x = iXMinNow + Diamond_X[m];
  1139.       cand_y = iYMinNow + Diamond_Y[m];
  1140.       SEARCH_ONE_PIXEL_BIPRED_HELPER
  1141.     }
  1143.     // The minimum cost point happens in the center
  1144.     if (best_x == iXMinNow && best_y == iYMinNow)
  1145.     {
  1146.       break;
  1147.     }
  1148.   }
  1150.   mv[0] = (short) (best_x - pic_pix_x);
  1151.   mv[1] = (short) (best_y - pic_pix_y);
  1152.   return min_mcost;
  1153. }
  1155. /*!
  1156.  ************************************************************************
  1157.  * brief
  1158.  *    Set neighbouring block mode (intra/inter)
  1159.  *    used for fast motion estimation
  1160.  ************************************************************************
  1161.  */
  1162. void smpUMHEX_decide_intrabk_SAD()
  1163. {
  1164.   if (img->type != I_SLICE)
  1165.   {
  1166.     if (img->pix_x == 0 && img->pix_y == 0)
  1167.     {
  1168.       smpUMHEX_flag_intra_SAD = 0;
  1169.     }
  1170.     else if (img->pix_x == 0)
  1171.     {
  1172.       smpUMHEX_flag_intra_SAD = smpUMHEX_flag_intra[(img->pix_x)>>4];
  1173.     }
  1174.     else if (img->pix_y == 0)
  1175.     {
  1176.       smpUMHEX_flag_intra_SAD = smpUMHEX_flag_intra[((img->pix_x)>>4)-1];
  1177.     }
  1178.     else
  1179.     {
  1180.       smpUMHEX_flag_intra_SAD = ((smpUMHEX_flag_intra[(img->pix_x)>>4])||
  1181.         (smpUMHEX_flag_intra[((img->pix_x)>>4)-1])||
  1182.         (smpUMHEX_flag_intra[((img->pix_x)>>4)+1])) ;
  1183.     }
  1184.   }
  1185.   return;
  1186. }
  1188. /*!
  1189.  ************************************************************************
  1190.  * brief
  1191.  *    Set cost to zero if neighbouring block is intra
  1192.  *    used for fast motion estimation
  1193.  ************************************************************************
  1194.  */
  1195. void smpUMHEX_skip_intrabk_SAD(int best_mode, int ref_max)
  1196. {
  1197.   short i, j, k;
  1199.   if (img->number > 0)
  1200.   {
  1201.     smpUMHEX_flag_intra[(img->pix_x)>>4] = (best_mode == 9 || best_mode == 10) ? 1 : 0;
  1202.   }
  1204.   if (img->type != I_SLICE  && (best_mode == 9 || best_mode == 10))
  1205.   {
  1206.     for (i=0; i < 4; i++)
  1207.     {
  1208.       for (j=0; j < 4; j++)
  1209.       {
  1210.         for (k=0; k < 9;k++)
  1211.         {
  1212.           smpUMHEX_l0_cost[k][j][i] = 0;
  1213.           smpUMHEX_l1_cost[k][j][i] = 0;
  1214.         }
  1215.       }
  1216.     }
  1217.   }
  1218.   return;
  1219. }
  1221. /*!
  1222.  ************************************************************************
  1223.  * brief
  1224.  *    Set up prediction MV and prediction up layer cost
  1225.  *    used for fast motion estimation
  1226.  ************************************************************************
  1227.  */
  1228. void smpUMHEX_setup(short ref,
  1229.                           int list,
  1230.                           int block_y,
  1231.                           int block_x,
  1232.                           int blocktype,
  1233.                           short ******all_mv)
  1234. {
  1235.   if (blocktype > 6)
  1236.   {
  1237.     smpUMHEX_pred_MV_uplayer_X = all_mv[list][ref][5][block_y][block_x][0];
  1238.     smpUMHEX_pred_MV_uplayer_Y = all_mv[list][ref][5][block_y][block_x][1];
  1239.   }
  1240.   else if (blocktype > 4)
  1241.   {
  1242.     smpUMHEX_pred_MV_uplayer_X = all_mv[list][ref][4][block_y][block_x][0];
  1243.     smpUMHEX_pred_MV_uplayer_Y = all_mv[list][ref][4][block_y][block_x][1];
  1244.   }
  1245.   else if (blocktype == 4)
  1246.   {
  1247.     smpUMHEX_pred_MV_uplayer_X = all_mv[list][ref][2][block_y][block_x][0];
  1248.     smpUMHEX_pred_MV_uplayer_Y = all_mv[list][ref][2][block_y][block_x][1];
  1249.   }
  1250.   else if (blocktype > 1)
  1251.   {
  1252.     smpUMHEX_pred_MV_uplayer_X = all_mv[list][ref][1][block_y][block_x][0];
  1253.     smpUMHEX_pred_MV_uplayer_Y = all_mv[list][ref][1][block_y][block_x][1];
  1254.   }
  1256.   if (blocktype > 1)
  1257.   {
  1258.     if (blocktype > 6)
  1259.     {
  1260.       smpUMHEX_pred_SAD_uplayer = (list==1) ?
  1261.         (smpUMHEX_l1_cost[5][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
  1262.         : (smpUMHEX_l0_cost[5][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
  1263.       smpUMHEX_pred_SAD_uplayer /= 2;
  1264.     }
  1265.     else if (blocktype > 4)
  1266.     {
  1267.       smpUMHEX_pred_SAD_uplayer = (list==1) ?
  1268.         (smpUMHEX_l1_cost[4][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
  1269.         : (smpUMHEX_l0_cost[4][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
  1270.       smpUMHEX_pred_SAD_uplayer /= 2;
  1271.     }
  1272.     else if (blocktype == 4)
  1273.     {
  1274.       smpUMHEX_pred_SAD_uplayer = (list==1) ?
  1275.         (smpUMHEX_l1_cost[2][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
  1276.         : (smpUMHEX_l0_cost[2][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
  1277.       smpUMHEX_pred_SAD_uplayer /= 2;
  1278.     }
  1279.     else
  1280.     {
  1281.       smpUMHEX_pred_SAD_uplayer = (list==1) ?
  1282.         (smpUMHEX_l1_cost[1][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
  1283.         : (smpUMHEX_l0_cost[1][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
  1284.       smpUMHEX_pred_SAD_uplayer /= 2;
  1285.     }
  1287.     smpUMHEX_pred_SAD_uplayer = smpUMHEX_flag_intra_SAD ? 0 : smpUMHEX_pred_SAD_uplayer;
  1288.   }
  1289. }