
/*!
 *************************************************************************************
 *
 * \file me_umhexsmp.c
 *
 * \brief
 *   Fast integer pixel and sub pixel motion estimation
 *   Improved and simplified from the original UMHexagonS algorithms
 *   See JVT-P021 for details
 *
 * \author
 *    Main contributors: (see contributors.h for copyright, address and affiliation details)
 *    - Zhibo Chen                      <chenzhibo@tsinghua.org.cn>
 *    - JianFeng Xu                     <fenax@video.mdc.tsinghua.edu.cn>
 *    - Wenfang Fu                      <fwf@video.mdc.tsinghua.edu.cn>
 *
 *    - Xiaoquan Yi                     <xyi@engr.scu.edu>
 *    - Jun Zhang                       <jzhang2@engr.scu.edu>
 *
 * \date
 *    6. Nov. 2006
 *************************************************************************************
 */

#include <stdlib.h>
#include <string.h>
#include <limits.h>

#include "global.h"
#include "memalloc.h"
#include "me_umhexsmp.h"
#include "refbuf.h"
#include "me_distortion.h"

extern  int *byte_abs;
extern  int *mvbits;

static const short Diamond_X[4]      = {-1, 1, 0, 0};
static const short Diamond_Y[4]      = { 0, 0,-1, 1};
static const short Hexagon_X[6]      = {-2, 2,-1, 1,-1, 1};
static const short Hexagon_Y[6]      = { 0, 0,-2, 2, 2,-2};
static const short Big_Hexagon_X[16] = {-4, 4, 0, 0,-4, 4,-4, 4,-4, 4,-4, 4,-2, 2,-2, 2};
static const short Big_Hexagon_Y[16] = { 0, 0,-4, 4,-1, 1, 1,-1,-2, 2, 2,-2,-3, 3, 3,-3};

const short block_type_shift_factor[8] = {0, 0, 1, 1, 2, 3, 3, 1}; // last one relaxed to 1 instead 4

static StorablePicture *ref_pic_ptr;
static int dist_method;

extern short*  spiral_hpel_search_x;
extern short*  spiral_hpel_search_y;
extern short*  spiral_search_x;
extern short*  spiral_search_y;

// Macro for motion estimation cost computation per match
#define SEARCH_ONE_PIXEL_HELPER                                                           \
  if(iabs(cand_x - center_x) <= search_range && iabs(cand_y - center_y) <= search_range)  \
  {                                                                                       \
    mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y);             \
    mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,             \
          min_mcost - mcost, (cand_x + IMG_PAD_SIZE) << 2, (cand_y + IMG_PAD_SIZE) << 2); \
    if (mcost < min_mcost)                                                                \
    {                                                                                     \
      best_x    = cand_x;                                                                 \
      best_y    = cand_y;                                                                 \
      min_mcost = mcost;                                                                  \
    }                                                                                     \
}

#define SEARCH_ONE_PIXEL_BIPRED_HELPER                                                    \
if (iabs(cand_x - center2_x) <= search_range && iabs(cand_y - center2_y) <= search_range) \
{                                                                                         \
  mcost  = MV_COST (lambda_factor, mvshift, center1_x, center1_y, pred_x1, pred_y1);      \
  mcost += MV_COST (lambda_factor, mvshift, cand_x,    cand_y,    pred_x2, pred_y2);      \
  if (mcost < min_mcost)                                                                  \
  {                                                                                       \
    mcost  += computeBiPred(cur_pic, blocksize_y, blocksize_x,                            \
                           min_mcost - mcost,                                             \
                           (center1_x << 2) + IMG_PAD_SIZE_TIMES4,                        \
                           (center1_y << 2) + IMG_PAD_SIZE_TIMES4,                        \
                           (cand_x << 2) + IMG_PAD_SIZE_TIMES4,                           \
                           (cand_y << 2) + IMG_PAD_SIZE_TIMES4);                          \
    if (mcost < min_mcost)                                                                \
    {                                                                                     \
      best_x = cand_x;                                                                    \
      best_y = cand_y;                                                                    \
      min_mcost = mcost;                                                                  \
    }                                                                                     \
  }                                                                                       \
}

/*!
 ************************************************************************
 * \brief
 *    Set thresholds for fast motion estimation
 *    Those thresholds may be adjusted to trade off rate-distortion
 *    performance and simplified UMHEX speed
 ************************************************************************
 */
void smpUMHEX_init()
{
  SymmetricalCrossSearchThreshold1 =  800;
  SymmetricalCrossSearchThreshold2 = 7000;
  ConvergeThreshold                = 1000;
  SubPelThreshold1                 = 1000;
  SubPelThreshold3                 =  400;
}

/*!
 ************************************************************************
 * \brief
 *    Allocation of space for fast motion estimation
 ************************************************************************
 */
int smpUMHEX_get_mem()
{
  int memory_size = 0;
  if (NULL==(smpUMHEX_flag_intra = calloc((img->width>>4)+1, sizeof(byte))))
    no_mem_exit("smpUMHEX_get_mem: smpUMHEX_flag_intra");

  memory_size += get_mem3Dint(&smpUMHEX_l0_cost, 9, img->height/4, img->width/4);
  memory_size += get_mem3Dint(&smpUMHEX_l1_cost, 9, img->height/4, img->width/4);
  memory_size += get_mem2D(&smpUMHEX_SearchState, 7, 7);

  return memory_size;
}

/*!
 ************************************************************************
 * \brief
 *    Free space for fast motion estimation
 ************************************************************************
 */
void smpUMHEX_free_mem()
{
  free_mem3Dint(smpUMHEX_l0_cost, 9);
  free_mem3Dint(smpUMHEX_l1_cost, 9);
  free_mem2D(smpUMHEX_SearchState);

  free (smpUMHEX_flag_intra);
}


/*!
************************************************************************
* \brief
*    Fast integer pixel block motion estimation
************************************************************************
*/
int                                     //  ==> minimum motion cost after search
smpUMHEXIntegerPelBlockMotionSearch (
                                     imgpel   *orig_pic,      // <--  not used
                                     short     ref,           // <--  reference frame (0... or -1 (backward))
                                     int       list,          // <--  reference picture list
                                     int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
                                     int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
                                     int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
                                     short     pred_mv_x,     // <--  motion vector predictor (x) in sub-pel units
                                     short     pred_mv_y,     // <--  motion vector predictor (y) in sub-pel units
                                     short*    mv_x,          //  --> motion vector (x) - in pel units
                                     short*    mv_y,          //  --> motion vector (y) - in pel units
                                     int       search_range,  // <--  1-d search range in pel units
                                     int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
                                     int       lambda_factor) // <--  lagrangian parameter for determining motion cost
{
  int   list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))?
                         img->current_mb_nr%2 ? 4 : 2 : 0;
  int   mvshift       = 2;                                        // motion vector shift for getting sub-pel units
  int   blocksize_y   = input->blc_size[blocktype][1];            // vertical block size
  int   blocksize_x   = input->blc_size[blocktype][0];            // horizontal block size
  int   pred_x        = (pic_pix_x << mvshift) + pred_mv_x;       // predicted position x (in sub-pel units)
  int   pred_y        = (pic_pix_y << mvshift) + pred_mv_y;       // predicted position y (in sub-pel units)
  int   center_x      = pic_pix_x + *mv_x;                        // center position x (in pel units)
  int   center_y      = pic_pix_y + *mv_y;                        // center position y (in pel units)
  int   best_x        = 0, best_y = 0;
  int   search_step, iYMinNow, iXMinNow;
  int   cand_x, cand_y, mcost;

  unsigned short        i, m;


  //===== Use weighted Reference for ME ====

  int  apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
    (active_pps->weighted_bipred_idc && (img->type == B_SLICE))) && input->UseWeightedReferenceME;

  dist_method = F_PEL + 3 * apply_weights;

  ref_pic_ptr = listX[list+list_offset][ref];

  // Note that following seem to be universal for all functions and could be moved to a separate, clean public function in me_distortion.c
  ref_pic_sub.luma = ref_pic_ptr->imgY_sub;
  img_width  = ref_pic_ptr->size_x;
  img_height = ref_pic_ptr->size_y;
  width_pad  = ref_pic_ptr->size_x_pad;
  height_pad = ref_pic_ptr->size_y_pad;

  if (apply_weights)
  {
    weight_luma = wp_weight[list + list_offset][ref][0];
    offset_luma = wp_offset[list + list_offset][ref][0];
  }

  if (ChromaMEEnable)
  {
    ref_pic_sub.crcb[0] = ref_pic_ptr->imgUV_sub[0];
    ref_pic_sub.crcb[1] = ref_pic_ptr->imgUV_sub[1];
    width_pad_cr  = ref_pic_ptr->size_x_cr_pad;
    height_pad_cr = ref_pic_ptr->size_y_cr_pad;

    if (apply_weights)
    {
      weight_cr[0] = wp_weight[list + list_offset][ref][1];
      weight_cr[1] = wp_weight[list + list_offset][ref][2];
      offset_cr[0] = wp_offset[list + list_offset][ref][1];
      offset_cr[1] = wp_offset[list + list_offset][ref][2];
    }
  }

  //===== set function for getting reference picture lines =====
  if ((center_x > search_range) && (center_x < img_width - 1 - search_range - blocksize_x) &&
    (center_y > search_range) && (center_y < img_height - 1 - search_range - blocksize_y))
  {
    ref_access_method = FAST_ACCESS;
  }
  else
  {
    ref_access_method = UMV_ACCESS;
  }

  //check the center median predictor
  cand_x = center_x ;
  cand_y = center_y ;
  mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y);


  mcost += computeUniPred[dist_method](orig_pic, blocksize_y,blocksize_x, min_mcost - mcost,
    (cand_x << 2) + IMG_PAD_SIZE_TIMES4,  (cand_y << 2) + IMG_PAD_SIZE_TIMES4);

  if (mcost < min_mcost)
  {
    min_mcost = mcost;
    best_x    = cand_x;
    best_y    = cand_y;
  }

  iXMinNow = best_x;
  iYMinNow = best_y;
  if ((0 != pred_mv_x) || (0 != pred_mv_y))
  {
    cand_x = pic_pix_x;
    cand_y = pic_pix_y;
    SEARCH_ONE_PIXEL_HELPER
  }

  // If the min_mcost is small enough, do a local search then terminate
  // Ihis is good for stationary or quasi-stationary areas
  if (min_mcost < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
  {
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_HELPER
    }
    *mv_x = (short) (best_x - pic_pix_x);
    *mv_y = (short) (best_y - pic_pix_y);
    return min_mcost;
  }

  // Small local search
  for (m = 0; m < 4; m++)
  {
    cand_x = iXMinNow + Diamond_X[m];
    cand_y = iYMinNow + Diamond_Y[m];
    SEARCH_ONE_PIXEL_HELPER
  }

  // First_step: Symmetrical-cross search
  // If distortion is large, use large shapes. Otherwise, compact shapes are faster
  if ( (blocktype == 1 &&
    min_mcost > (SymmetricalCrossSearchThreshold1>>block_type_shift_factor[blocktype])) ||
    (min_mcost > (SymmetricalCrossSearchThreshold2>>block_type_shift_factor[blocktype])) )
  {
    iXMinNow = best_x;
    iYMinNow = best_y;

    for(i = 1; i <= search_range/2; i++)
    {
      search_step = (i<<1) - 1;
      cand_x = iXMinNow + search_step;
      cand_y = iYMinNow;
      SEARCH_ONE_PIXEL_HELPER

      cand_x = iXMinNow - search_step;
      SEARCH_ONE_PIXEL_HELPER

      cand_x = iXMinNow;
      cand_y = iYMinNow + search_step;
      SEARCH_ONE_PIXEL_HELPER

      cand_y = iYMinNow - search_step;
      SEARCH_ONE_PIXEL_HELPER
    }

    // Hexagon Search
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 6; m++)
    {
      cand_x = iXMinNow + Hexagon_X[m];
      cand_y = iYMinNow + Hexagon_Y[m];
      SEARCH_ONE_PIXEL_HELPER
    }
    // Multi Big Hexagon Search
    iXMinNow = best_x;
    iYMinNow = best_y;
    for(i = 1; i <= search_range/4; i++)
    {
      for (m = 0; m < 16; m++)
      {
        cand_x = iXMinNow + Big_Hexagon_X[m]*i;
        cand_y = iYMinNow + Big_Hexagon_Y[m]*i;
        SEARCH_ONE_PIXEL_HELPER
      }
    }
  }

  // Search up_layer predictor for non 16x16 blocks
  if (blocktype > 1)
  {
    cand_x = pic_pix_x + (smpUMHEX_pred_MV_uplayer_X/4);
    cand_y = pic_pix_y + (smpUMHEX_pred_MV_uplayer_Y/4);
    SEARCH_ONE_PIXEL_HELPER
  }

  if(center_x != pic_pix_x || center_y != pic_pix_y)
  {
    cand_x = pic_pix_x;
    cand_y = pic_pix_y;
    SEARCH_ONE_PIXEL_HELPER

    iXMinNow = best_x;
    iYMinNow = best_y;
    // Local diamond search
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_HELPER
    }
  }

  // If the minimum cost is small enough, do a local search
  // and finish the search here
  if (min_mcost < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
  {
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_HELPER
    }
    *mv_x = (short) (best_x - pic_pix_x);
    *mv_y = (short) (best_y - pic_pix_y);
    return min_mcost;
  }

  //second_step:  Extended Hexagon-based Search
  for(i = 0; i < search_range; i++)
  {
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 6; m++)
    {
      cand_x = iXMinNow + Hexagon_X[m];
      cand_y = iYMinNow + Hexagon_Y[m];
      SEARCH_ONE_PIXEL_HELPER
    }
    // The minimum cost point happens in the center
    if (best_x == iXMinNow && best_y == iYMinNow)
    {
      break;
    }
  }

  //third_step: Small diamond search
  for(i = 0; i < search_range; i++)
  {
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_HELPER
    }

    // The minimum cost point happens in the center
    if (best_x == iXMinNow && best_y == iYMinNow)
    {
      break;
    }
  }

  *mv_x = (short) (best_x - pic_pix_x);
  *mv_y = (short) (best_y - pic_pix_y);
  return min_mcost;
}

/*!
 ***********************************************************************
 * \brief
 *    Sub pixel block motion search enhanced
 ***********************************************************************
 */
int                                               //  ==> minimum motion cost after search
smpUMHEXFullSubPelBlockMotionSearch (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
                                     short     ref,           // <--  reference frame (0... or -1 (backward))
                                     int       list,          // <--  reference picture list
                                     int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
                                     int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
                                     int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
                                     short     pred_mv_x,     // <--  motion vector predictor (x) in sub-pel units
                                     short     pred_mv_y,     // <--  motion vector predictor (y) in sub-pel units
                                     short*    mv_x,          // <--> in: search center (x) / out: motion vector (x) - in pel units
                                     short*    mv_y,          // <--> in: search center (y) / out: motion vector (y) - in pel units
                                     int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
                                     int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
                                     int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
                                     int       lambda_factor  // <--  lagrangian parameter for determining motion cost
                                     )
{
  int   pos, best_pos, mcost;

  int   cand_mv_x, cand_mv_y;

  int   check_position0 = (!input->rdopt && img->type!=B_SLICE && ref==0 && blocktype==1 && *mv_x==0 && *mv_y==0);
  int   blocksize_x     = input->blc_size[blocktype][0];
  int   blocksize_y     = input->blc_size[blocktype][1];
  int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<< 2);
  int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<< 2);
  int   max_pos2        = ( !start_me_refinement_hp ? imax(1,search_pos2) : search_pos2);
  int   list_offset     = img->mb_data[img->current_mb_nr].list_offset;
  int  apply_weights = ( (active_pps->weighted_pred_flag  &&
    (img->type == P_SLICE || img->type == SP_SLICE)) ||
    (active_pps->weighted_bipred_idc && (img->type == B_SLICE)) )
    && input->UseWeightedReferenceME;
  int   cmv_x, cmv_y;

  StorablePicture *ref_picture = listX[list+list_offset][ref];

  int max_pos_x4 = ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  int max_pos_y4 = ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);

  dist_method = Q_PEL + 3 * apply_weights;

  ref_pic_sub.luma = ref_picture->imgY_sub;
  img_width  = ref_picture->size_x;
  img_height = ref_picture->size_y;
  width_pad  = ref_picture->size_x_pad;
  height_pad = ref_picture->size_y_pad;

  if (apply_weights)
  {
    weight_luma = wp_weight[list + list_offset][ref][0];
    offset_luma = wp_offset[list + list_offset][ref][0];
  }

  if (ChromaMEEnable)
  {
    ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
    ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
    width_pad_cr  = ref_picture->size_x_cr_pad;
    height_pad_cr = ref_picture->size_y_cr_pad;

    if (apply_weights)
    {
      weight_cr[0] = wp_weight[list + list_offset][ref][1];
      weight_cr[1] = wp_weight[list + list_offset][ref][2];
      offset_cr[0] = wp_offset[list + list_offset][ref][1];
      offset_cr[1] = wp_offset[list + list_offset][ref][2];
    }
  }

  /*********************************
   *****                       *****
   *****  HALF-PEL REFINEMENT  *****
   *****                       *****
   *********************************/

  //===== set function for getting pixel values =====
  if ((pic4_pix_x + *mv_x > 1) && (pic4_pix_x + *mv_x < max_pos_x4 - 1) &&
    (pic4_pix_y + *mv_y > 1) && (pic4_pix_y + *mv_y < max_pos_y4 - 1)   )
  {
    ref_access_method = FAST_ACCESS;
  }
  else
  {
    ref_access_method = UMV_ACCESS;
  }

  //===== loop over search positions =====
  for (best_pos = 0, pos = start_me_refinement_hp; pos < max_pos2; pos++)
  {
    cand_mv_x = *mv_x + (spiral_hpel_search_x[pos]);    // quarter-pel units
    cand_mv_y = *mv_y + (spiral_hpel_search_y[pos]);    // quarter-pel units

    //----- set motion vector cost -----
    mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);

    if (mcost >= min_mcost) continue;

    cmv_x = cand_mv_x + pic4_pix_x;
    cmv_y = cand_mv_y + pic4_pix_y;

    mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x, min_mcost - mcost, cmv_x, cmv_y);

    if (pos==0 && check_position0)
    {
      mcost -= WEIGHTED_COST (lambda_factor, 16);
    }

    if (mcost < min_mcost)
    {
      min_mcost = mcost;
      best_pos  = pos;
    }
    if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
    {
      break;
    }
  }

  if (best_pos)
  {
    *mv_x += (spiral_hpel_search_x [best_pos]);
    *mv_y += (spiral_hpel_search_y [best_pos]);
  }

  if ((*mv_x == 0) && (*mv_y == 0) && (pred_mv_x == 0 && pred_mv_y == 0) &&
    (min_mcost < (SubPelThreshold1>>block_type_shift_factor[blocktype])) )
  {
    best_pos = 0;
    return min_mcost;
  }

  if ( !start_me_refinement_qp )
    min_mcost = INT_MAX;

  /************************************
   *****                          *****
   *****  QUARTER-PEL REFINEMENT  *****
   *****                          *****
   ************************************/
  //===== set function for getting pixel values =====
  if ((pic4_pix_x + *mv_x > 0) && (pic4_pix_x + *mv_x < max_pos_x4) &&
    (pic4_pix_y + *mv_y > 0) && (pic4_pix_y + *mv_y < max_pos_y4)   )
  {
    ref_access_method = FAST_ACCESS;
  }
  else
  {
    ref_access_method = UMV_ACCESS;
  }

  //===== loop over search positions =====
  for (best_pos = 0, pos = start_me_refinement_qp; pos < search_pos4; pos++)
  {
    cand_mv_x = *mv_x + spiral_search_x[pos];    // quarter-pel units
    cand_mv_y = *mv_y + spiral_search_y[pos];    // quarter-pel units

    //----- set motion vector cost -----
    mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);

    if (mcost >= min_mcost) continue;

    cmv_x = cand_mv_x + pic4_pix_x;
    cmv_y = cand_mv_y + pic4_pix_y;

    mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x, min_mcost - mcost, cmv_x, cmv_y);

    if (mcost < min_mcost)
    {
      min_mcost = mcost;
      best_pos  = pos;
    }
    if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
    {
      break;
    }
  }

  if (best_pos)
  {
    *mv_x += spiral_search_x [best_pos];
    *mv_y += spiral_search_y [best_pos];
  }

  //===== return minimum motion cost =====
  return min_mcost;
}

/*!
 ************************************************************************
 * \brief
 *    Fast sub pixel block motion estimation
 ************************************************************************
 */
int                                     //  ==> minimum motion cost after search
smpUMHEXSubPelBlockMotionSearch  (
                                  imgpel* orig_pic,        // <--  original pixel values for the AxB block
                                  short     ref,           // <--  reference frame (0... or -1 (backward))
                                  int       list,          // <--  reference picture list
                                  int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
                                  int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
                                  int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
                                  short     pred_mv_x,     // <--  motion vector predictor (x) in sub-pel units
                                  short     pred_mv_y,     // <--  motion vector predictor (y) in sub-pel units
                                  short*    mv_x,          // <--> in: search center (x) / out: MV (x) - in pel units
                                  short*    mv_y,          // <--> in: search center (y) / out: MV (y) - in pel units
                                  int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
                                  int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
                                  int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
                                  int       lambda_factor) // <--  lagrangian parameter for determining motion cost
{
  int   mcost;
  int   cand_mv_x, cand_mv_y;

  int   list_offset     = ((img->MbaffFrameFlag) &&
    (img->mb_data[img->current_mb_nr].mb_field)) ?
    img->current_mb_nr%2 ? 4 : 2 : 0;
  StorablePicture *ref_picture = listX[list+list_offset][ref];

  short mv_shift        = 0;
  short blocksize_x     = (short) input->blc_size[blocktype][0];
  short blocksize_y     = (short) input->blc_size[blocktype][1];
  int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<<2);
  int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<<2);
  short max_pos_x4      = (short) ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  short max_pos_y4      = (short) ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);

  int   iXMinNow, iYMinNow;
  short dynamic_search_range, i, m;
  int   currmv_x = 0, currmv_y = 0;
  int   pred_frac_mv_x,pred_frac_mv_y,abort_search;
  int   pred_frac_up_mv_x, pred_frac_up_mv_y;
  int   apply_weights = ( (active_pps->weighted_pred_flag  &&
    (img->type == P_SLICE || img->type == SP_SLICE)) ||
    (active_pps->weighted_bipred_idc && (img->type == B_SLICE)) )
    && input->UseWeightedReferenceME;

  dist_method = Q_PEL + 3 * apply_weights;
  ref_pic_sub.luma = ref_pic_ptr->imgY_sub;
  img_width  = ref_pic_ptr->size_x;
  img_height = ref_pic_ptr->size_y;
  width_pad  = ref_pic_ptr->size_x_pad;
  height_pad = ref_pic_ptr->size_y_pad;

  if (apply_weights)
  {
    weight_luma = wp_weight[list + list_offset][ref][0];
    offset_luma = wp_offset[list + list_offset][ref][0];
  }

  if (ChromaMEEnable)
  {
    ref_pic_sub.crcb[0] = ref_pic_ptr->imgUV_sub[0];
    ref_pic_sub.crcb[1] = ref_pic_ptr->imgUV_sub[1];
    width_pad_cr  = ref_pic_ptr->size_x_cr_pad;
    height_pad_cr = ref_pic_ptr->size_y_cr_pad;

    if (apply_weights)
    {
      weight_cr[0] = wp_weight[list + list_offset][ref][1];
      weight_cr[1] = wp_weight[list + list_offset][ref][2];
      offset_cr[0] = wp_offset[list + list_offset][ref][1];
      offset_cr[1] = wp_offset[list + list_offset][ref][2];
    }
  }


  if ((pic4_pix_x + *mv_x > 1) && (pic4_pix_x + *mv_x < max_pos_x4 - 1) &&
    (pic4_pix_y + *mv_y > 1) && (pic4_pix_y + *mv_y < max_pos_y4 - 1))
  {
    ref_access_method = FAST_ACCESS;
  }
  else
  {
    ref_access_method = UMV_ACCESS;
  }

  dynamic_search_range = 3;
  pred_frac_mv_x = (pred_mv_x - *mv_x) % 4;
  pred_frac_mv_y = (pred_mv_y - *mv_y) % 4;

  pred_frac_up_mv_x = (smpUMHEX_pred_MV_uplayer_X - *mv_x) % 4;
  pred_frac_up_mv_y = (smpUMHEX_pred_MV_uplayer_Y - *mv_y) % 4;

  memset(smpUMHEX_SearchState[0], 0,
    (2*dynamic_search_range+1)*(2*dynamic_search_range+1));

  smpUMHEX_SearchState[dynamic_search_range][dynamic_search_range] = 1;
  if( !start_me_refinement_hp )
  {
    cand_mv_x = *mv_x;
    cand_mv_y = *mv_y;
    mcost   = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);
    mcost   += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
      min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
    if (mcost < min_mcost)
    {
      min_mcost = mcost;
      currmv_x  = cand_mv_x;
      currmv_y  = cand_mv_y;
    }
  }
  else
  {
    currmv_x = *mv_x;
    currmv_y = *mv_y;
  }

  // If the min_mcost is small enough and other statistics are positive,
  // better to stop the search now
  if ( ((*mv_x) == 0) && ((*mv_y) == 0) &&
    (pred_frac_mv_x == 0 && pred_frac_up_mv_x == 0) &&
    (pred_frac_mv_y == 0 && pred_frac_up_mv_y == 0) &&
    (min_mcost < (SubPelThreshold1>>block_type_shift_factor[blocktype])) )
  {
    *mv_x = (short) currmv_x;
    *mv_y = (short) currmv_y;
    return min_mcost;
  }

  if(pred_frac_mv_x || pred_frac_mv_y)
  {
    cand_mv_x = *mv_x + pred_frac_mv_x;
    cand_mv_y = *mv_y + pred_frac_mv_y;
    mcost   = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);
    mcost   += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
      min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);

    smpUMHEX_SearchState[cand_mv_y -*mv_y + dynamic_search_range][cand_mv_x - *mv_x + dynamic_search_range] = 1;
    if (mcost < min_mcost)
    {
      min_mcost = mcost;
      currmv_x  = cand_mv_x;
      currmv_y  = cand_mv_y;
    }
  }

  // Multiple small diamond search
  for(i = 0; i < dynamic_search_range; i++)
  {
    abort_search = 1;

    iXMinNow = currmv_x;
    iYMinNow = currmv_y;
    for (m = 0; m < 4; m++)
    {
      cand_mv_x = iXMinNow + Diamond_X[m];
      cand_mv_y = iYMinNow + Diamond_Y[m];

      if(iabs(cand_mv_x - *mv_x) <= dynamic_search_range && iabs(cand_mv_y - *mv_y) <= dynamic_search_range)
      {
        if(!smpUMHEX_SearchState[cand_mv_y - *mv_y + dynamic_search_range][cand_mv_x - *mv_x + dynamic_search_range])
        {
          mcost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);
          mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x,
            min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);

          smpUMHEX_SearchState[cand_mv_y - *mv_y + dynamic_search_range][cand_mv_x - *mv_x + dynamic_search_range] = 1;

          if (mcost < min_mcost)
          {
            min_mcost    = mcost;
            currmv_x     = cand_mv_x;
            currmv_y     = cand_mv_y;
            abort_search = 0;
          }
          if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
          {
            *mv_x = (short) currmv_x;
            *mv_y = (short) currmv_y;
            return min_mcost;
          }
        }
      }
    }
    // If the minimum cost point is in the center, break out the loop
    if (abort_search)
    {
      break;
    }
  }

  *mv_x = (short) currmv_x;
  *mv_y = (short) currmv_y;
  return min_mcost;
}

/*!
 ************************************************************************
 * \brief
 *    smpUMHEXBipredIntegerPelBlockMotionSearch: fast pixel block motion search for bipred mode
 *
 ************************************************************************
 */
int                                                           //  ==> minimum motion cost after search
smpUMHEXBipredIntegerPelBlockMotionSearch (imgpel* cur_pic,  // <--  original pixel values for the AxB block
                                     short     ref,           // <--  reference frame (0... or -1 (backward))
                                     int       list,
                                     int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
                                     int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
                                     int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
                                     short     pred_mv_x1,    // <--  motion vector predictor (x) in sub-pel units
                                     short     pred_mv_y1,    // <--  motion vector predictor (y) in sub-pel units
                                     short     pred_mv_x2,    // <--  motion vector predictor (x) in sub-pel units
                                     short     pred_mv_y2,    // <--  motion vector predictor (y) in sub-pel units
                                     short*    mv_x,          // <--> in: search center (x) / out: motion vector (x) - in pel units
                                     short*    mv_y,          // <--> in: search center (y) / out: motion vector (y) - in pel units
                                     short*    s_mv_x,        // <--> in: search center (x) / out: motion vector (x) - in pel units
                                     short*    s_mv_y,        // <--> in: search center (y) / out: motion vector (y) - in pel units
                                     int       search_range,  // <--  1-d search range in pel units
                                     int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
                                     int       lambda_factor) // <--  lagrangian parameter for determining motion cost
{
  int   mvshift       = 2;                              // motion vector shift for getting sub-pel units

  int   search_step, iYMinNow, iXMinNow;
  int   i, m;
  int   cand_x, cand_y, mcost;
  int   list_offset   = img->mb_data[img->current_mb_nr].list_offset;
  int   blocksize_y   = input->blc_size[blocktype][1];  // vertical block size
  int   blocksize_x   = input->blc_size[blocktype][0];  // horizontal block size
  int   pred_x1       = (pic_pix_x << 2) + pred_mv_x1;  // predicted position x (in sub-pel units)
  int   pred_y1       = (pic_pix_y << 2) + pred_mv_y1;  // predicted position y (in sub-pel units)
  int   pred_x2       = (pic_pix_x << 2) + pred_mv_x2;  // predicted position x (in sub-pel units)
  int   pred_y2       = (pic_pix_y << 2) + pred_mv_y2;  // predicted position y (in sub-pel units)
  short center2_x     = pic_pix_x + *mv_x;              // center position x (in pel units)
  short center2_y     = pic_pix_y + *mv_y;              // center position y (in pel units)
  short center1_x     = pic_pix_x + *s_mv_x;            // mvx of second pred (in pel units)
  short center1_y     = pic_pix_y + *s_mv_y;            // mvy of second pred (in pel units)
  int   best_x        = center2_x;
  int   best_y        = center2_y;

  short apply_weights = (active_pps->weighted_bipred_idc>0);
  short offset1 = (apply_weights ? (list == 0?  wp_offset[list_offset    ][ref][0]:  wp_offset[list_offset + 1][0  ][ref]) : 0);
  short offset2 = (apply_weights ? (list == 0?  wp_offset[list_offset + 1][ref][0]:  wp_offset[list_offset    ][0  ][ref]) : 0);

  ref_pic1_sub.luma = listX[list + list_offset][ref]->imgY_sub;
  ref_pic2_sub.luma = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgY_sub;
  img_width  = listX[list + list_offset][ref]->size_x;
  img_height = listX[list + list_offset][ref]->size_y;
  width_pad  = listX[list + list_offset][ref]->size_x_pad;
  height_pad = listX[list + list_offset][ref]->size_y_pad;

  if (apply_weights)
  {
    weight1 = list == 0 ? wbp_weight[list_offset         ][ref][0][0] : wbp_weight[list_offset + LIST_1][0  ][ref][0];
    weight2 = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][0] : wbp_weight[list_offset         ][0  ][ref][0];
    offsetBi=(offset1 + offset2 + 1)>>1;
    computeBiPred = computeBiPredSAD2; //ME only supports SAD computations
  }
  else
  {
    weight1 = 1<<luma_log_weight_denom;
    weight2 = 1<<luma_log_weight_denom;
    offsetBi = 0;
    computeBiPred = computeBiPredSAD1; //ME only supports SAD computations
  }

  if (ChromaMEEnable )
  {
    ref_pic1_sub.crcb[0] = listX[list + list_offset][ref]->imgUV_sub[0];
    ref_pic1_sub.crcb[1] = listX[list + list_offset][ref]->imgUV_sub[1];
    ref_pic2_sub.crcb[0] = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgUV_sub[0];
    ref_pic2_sub.crcb[1] = listX[list == 0 ? 1 + list_offset: list_offset][ 0 ]->imgUV_sub[1];
    width_pad_cr  = listX[list + list_offset][ref]->size_x_cr_pad;
    height_pad_cr = listX[list + list_offset][ref]->size_y_cr_pad;
    if (apply_weights)
    {
      weight1_cr[0] = list == 0 ? wbp_weight[list_offset         ][ref][0][1] : wbp_weight[list_offset + LIST_1][0  ][ref][1];
      weight1_cr[1] = list == 0 ? wbp_weight[list_offset         ][ref][0][2] : wbp_weight[list_offset + LIST_1][0  ][ref][2];
      weight2_cr[0] = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][1] : wbp_weight[list_offset         ][0  ][ref][1];
      weight2_cr[1] = list == 0 ? wbp_weight[list_offset + LIST_1][ref][0][2] : wbp_weight[list_offset         ][0  ][ref][2];
      offsetBi_cr[0] = (list == 0)
        ? (wp_offset[list_offset         ][ref][1] + wp_offset[list_offset + LIST_1][ref][1] + 1) >> 1
        : (wp_offset[list_offset + LIST_1][0  ][1] + wp_offset[list_offset         ][0  ][1] + 1) >> 1;
      offsetBi_cr[1] = (list == 0)
        ? (wp_offset[list_offset         ][ref][2] + wp_offset[list_offset + LIST_1][ref][2] + 1) >> 1
        : (wp_offset[list_offset + LIST_1][0  ][2] + wp_offset[list_offset         ][0  ][2] + 1) >> 1;
    }
    else
    {
      weight1_cr[0] = 1<<chroma_log_weight_denom;
      weight1_cr[1] = 1<<chroma_log_weight_denom;
      weight2_cr[0] = 1<<chroma_log_weight_denom;
      weight2_cr[1] = 1<<chroma_log_weight_denom;
      offsetBi_cr[0] = 0;
      offsetBi_cr[1] = 0;
    }
  }

  // Set function for getting reference picture lines
  if ((center2_x > search_range) && (center2_x < img_width -1-search_range-blocksize_x) &&
      (center2_y > search_range) && (center2_y < img_height-1-search_range-blocksize_y))
  {
    bipred2_access_method = FAST_ACCESS;
  }
  else
  {
    bipred2_access_method = UMV_ACCESS;
  }

  // Set function for getting reference picture lines
  if ((center1_y > search_range) && (center1_y < img_height-1-search_range-blocksize_y))
  {
    bipred1_access_method = FAST_ACCESS;
  }
  else
  {
    bipred1_access_method = UMV_ACCESS;
  }

  // Check the center median predictor
  cand_x = center2_x ;
  cand_y = center2_y ;
  mcost  = MV_COST (lambda_factor, mvshift, center1_x, center1_y, pred_x1, pred_y1);
  mcost += MV_COST (lambda_factor, mvshift, cand_x,    cand_y,    pred_x2, pred_y2);

  mcost += computeBiPred(cur_pic,
                        blocksize_y, blocksize_x, INT_MAX,
                        (center1_x << 2) + IMG_PAD_SIZE_TIMES4,
                        (center1_y << 2) + IMG_PAD_SIZE_TIMES4,
                        (cand_x << 2) + IMG_PAD_SIZE_TIMES4,
                        (cand_y << 2) + IMG_PAD_SIZE_TIMES4);

  if (mcost < min_mcost)
  {
    min_mcost = mcost;
    best_x = cand_x;
    best_y = cand_y;
  }

  iXMinNow = best_x;
  iYMinNow = best_y;
  if (0 != pred_mv_x1 || 0 != pred_mv_y1 || 0 != pred_mv_x2 || 0 != pred_mv_y2)
  {
    cand_x = pic_pix_x;
    cand_y = pic_pix_y;
    SEARCH_ONE_PIXEL_BIPRED_HELPER;
  }

  // If the min_mcost is small enough, do a local search then terminate
  // This is good for stationary or quasi-stationary areas
  if ((min_mcost<<3) < (ConvergeThreshold>>(block_type_shift_factor[blocktype])))
  {
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_BIPRED_HELPER;
    }
    *mv_x = best_x - pic_pix_x;
    *mv_y = best_y - pic_pix_y;
    return min_mcost;
  }

  // Small local search
  for (m = 0; m < 4; m++)
  {
    cand_x = iXMinNow + Diamond_X[m];
    cand_y = iYMinNow + Diamond_Y[m];
    SEARCH_ONE_PIXEL_BIPRED_HELPER;
  }

  // First_step: Symmetrical-cross search
  // If distortion is large, use large shapes. Otherwise, compact shapes are faster
  if ((blocktype == 1 &&
    (min_mcost<<2) > (SymmetricalCrossSearchThreshold1>>block_type_shift_factor[blocktype])) ||
    ((min_mcost<<2) > (SymmetricalCrossSearchThreshold2>>block_type_shift_factor[blocktype])))
  {
    iXMinNow = best_x;
    iYMinNow = best_y;

    for (i = 1; i <= search_range / 2; i++)
    {
      search_step = (i<<1) - 1;
      cand_x = iXMinNow + search_step;
      cand_y = iYMinNow;
      SEARCH_ONE_PIXEL_BIPRED_HELPER

      cand_x = iXMinNow - search_step;
      SEARCH_ONE_PIXEL_BIPRED_HELPER

      cand_x = iXMinNow;
      cand_y = iYMinNow + search_step;
      SEARCH_ONE_PIXEL_BIPRED_HELPER

      cand_y = iYMinNow - search_step;
      SEARCH_ONE_PIXEL_BIPRED_HELPER
    }

    // Hexagon Search
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 6; m++)
    {
      cand_x = iXMinNow + Hexagon_X[m];
      cand_y = iYMinNow + Hexagon_Y[m];
      SEARCH_ONE_PIXEL_BIPRED_HELPER
    }
    // Multi Big Hexagon Search
    iXMinNow = best_x;
    iYMinNow = best_y;
    for(i = 1; i <= search_range / 4; i++)
    {
      for (m = 0; m < 16; m++)
      {
        cand_x = iXMinNow + Big_Hexagon_X[m] * i;
        cand_y = iYMinNow + Big_Hexagon_Y[m] * i;
        SEARCH_ONE_PIXEL_BIPRED_HELPER
      }
    }
  }

  // Search up_layer predictor for non 16x16 blocks
  if (blocktype > 1)
  {
    cand_x = pic_pix_x + (smpUMHEX_pred_MV_uplayer_X / 4);
    cand_y = pic_pix_y + (smpUMHEX_pred_MV_uplayer_Y / 4);
    SEARCH_ONE_PIXEL_BIPRED_HELPER
  }

  if(center2_x != pic_pix_x || center2_y != pic_pix_y)
  {
    cand_x = pic_pix_x;
    cand_y = pic_pix_y;
    SEARCH_ONE_PIXEL_BIPRED_HELPER

    iXMinNow = best_x;
    iYMinNow = best_y;
    // Local diamond search
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_BIPRED_HELPER
    }
  }

  // If the minimum cost is small enough, do a local search
  // and finish the search here
  if ((min_mcost<<2) < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
  {
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_BIPRED_HELPER
    }
    *mv_x = (short) (best_x - pic_pix_x);
    *mv_y = (short) (best_y - pic_pix_y);
    return min_mcost;
  }

  // Second_step:  Extended Hexagon-based Search
  for (i = 0; i < search_range; i++)
  {
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 6; m++)
    {
      cand_x = iXMinNow + Hexagon_X[m];
      cand_y = iYMinNow + Hexagon_Y[m];
      SEARCH_ONE_PIXEL_BIPRED_HELPER
    }
    // The minimum cost point happens in the center
    if (best_x == iXMinNow && best_y == iYMinNow)
    {
      break;
    }
  }

  // Third_step: Small diamond search
  for (i = 0; i < search_range; i++)
  {
    iXMinNow = best_x;
    iYMinNow = best_y;
    for (m = 0; m < 4; m++)
    {
      cand_x = iXMinNow + Diamond_X[m];
      cand_y = iYMinNow + Diamond_Y[m];
      SEARCH_ONE_PIXEL_BIPRED_HELPER
    }

    // The minimum cost point happens in the center
    if (best_x == iXMinNow && best_y == iYMinNow)
    {
      break;
    }
  }

  *mv_x = (short) (best_x - pic_pix_x);
  *mv_y = (short) (best_y - pic_pix_y);
  return min_mcost;
}

/*!
 ************************************************************************
 * \brief
 *    Set neighbouring block mode (intra/inter)
 *    used for fast motion estimation
 ************************************************************************
 */
void smpUMHEX_decide_intrabk_SAD()
{
  if (img->type != I_SLICE)
  {
    if (img->pix_x == 0 && img->pix_y == 0)
    {
      smpUMHEX_flag_intra_SAD = 0;
    }
    else if (img->pix_x == 0)
    {
      smpUMHEX_flag_intra_SAD = smpUMHEX_flag_intra[(img->pix_x)>>4];
    }
    else if (img->pix_y == 0)
    {
      smpUMHEX_flag_intra_SAD = smpUMHEX_flag_intra[((img->pix_x)>>4)-1];
    }
    else
    {
      smpUMHEX_flag_intra_SAD = ((smpUMHEX_flag_intra[(img->pix_x)>>4])||
        (smpUMHEX_flag_intra[((img->pix_x)>>4)-1])||
        (smpUMHEX_flag_intra[((img->pix_x)>>4)+1])) ;
    }
  }
  return;
}

/*!
 ************************************************************************
 * \brief
 *    Set cost to zero if neighbouring block is intra
 *    used for fast motion estimation
 ************************************************************************
 */
void smpUMHEX_skip_intrabk_SAD(int best_mode, int ref_max)
{
  short i, j, k;

  if (img->number > 0)
  {
    smpUMHEX_flag_intra[(img->pix_x)>>4] = (best_mode == 9 || best_mode == 10) ? 1 : 0;
  }

  if (img->type != I_SLICE  && (best_mode == 9 || best_mode == 10))
  {
    for (i=0; i < 4; i++)
    {
      for (j=0; j < 4; j++)
      {
        for (k=0; k < 9;k++)
        {
          smpUMHEX_l0_cost[k][j][i] = 0;
          smpUMHEX_l1_cost[k][j][i] = 0;
        }
      }
    }
  }
  return;
}

/*!
 ************************************************************************
 * \brief
 *    Set up prediction MV and prediction up layer cost
 *    used for fast motion estimation
 ************************************************************************
 */
void smpUMHEX_setup(short ref,
                          int list,
                          int block_y,
                          int block_x,
                          int blocktype,
                          short ******all_mv)
{
  if (blocktype > 6)
  {
    smpUMHEX_pred_MV_uplayer_X = all_mv[block_y][block_x][list][ref][5][0];
    smpUMHEX_pred_MV_uplayer_Y = all_mv[block_y][block_x][list][ref][5][1];
  }
  else if (blocktype > 4)
  {
    smpUMHEX_pred_MV_uplayer_X = all_mv[block_y][block_x][list][ref][4][0];
    smpUMHEX_pred_MV_uplayer_Y = all_mv[block_y][block_x][list][ref][4][1];
  }
  else if (blocktype == 4)
  {
    smpUMHEX_pred_MV_uplayer_X = all_mv[block_y][block_x][list][ref][2][0];
    smpUMHEX_pred_MV_uplayer_Y = all_mv[block_y][block_x][list][ref][2][1];
  }
  else if (blocktype > 1)
  {
    smpUMHEX_pred_MV_uplayer_X = all_mv[block_y][block_x][list][ref][1][0];
    smpUMHEX_pred_MV_uplayer_Y = all_mv[block_y][block_x][list][ref][1][1];
  }

  if (blocktype > 1)
  {
    if (blocktype > 6)
    {
      smpUMHEX_pred_SAD_uplayer = (list==1) ?
        (smpUMHEX_l1_cost[5][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
        : (smpUMHEX_l0_cost[5][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
      smpUMHEX_pred_SAD_uplayer /= 2;
    }
    else if (blocktype > 4)
    {
      smpUMHEX_pred_SAD_uplayer = (list==1) ?
        (smpUMHEX_l1_cost[4][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
        : (smpUMHEX_l0_cost[4][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
      smpUMHEX_pred_SAD_uplayer /= 2;
    }
    else if (blocktype == 4)
    {
      smpUMHEX_pred_SAD_uplayer = (list==1) ?
        (smpUMHEX_l1_cost[2][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
        : (smpUMHEX_l0_cost[2][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
      smpUMHEX_pred_SAD_uplayer /= 2;
    }
    else
    {
      smpUMHEX_pred_SAD_uplayer = (list==1) ?
        (smpUMHEX_l1_cost[1][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x])
        : (smpUMHEX_l0_cost[1][(img->pix_y>>2)+block_y][(img->pix_x>>2)+block_x]);
      smpUMHEX_pred_SAD_uplayer /= 2;
    }

    smpUMHEX_pred_SAD_uplayer = smpUMHEX_flag_intra_SAD ? 0 : smpUMHEX_pred_SAD_uplayer;
  }
}