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

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

Audio

开发平台：

Visual C++

me_epzs.c：源码内容
  2. /*!
  3. *************************************************************************************
  4. * file me_epzs.c
  5. *
  6. * brief
  7. *    Motion Estimation using EPZS
  8. *
  9. * author
  10. *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11. *      - Alexis Michael Tourapis <alexismt@ieee.org>
  12. *      - Athanasios Leontaris    <aleon@dolby.com>
  13. *
  14. *************************************************************************************
  15. */
  17. #include "contributors.h"
  19. #include <limits.h>
  21. #include "global.h"
  22. #include "image.h"
  23. #include "memalloc.h"
  24. #include "mb_access.h"
  25. #include "refbuf.h"
  27. #include "me_distortion.h"
  28. #include "me_epzs.h"
  29. #include "mv-search.h"
  31. #define EPZSREF 1
  33. // Define Global Parameters
  34. static const short blk_parent[8] = {1, 1, 1, 1, 2, 4, 4, 5}; //!< {skip, 16x16, 16x8, 8x16, 8x8, 8x4, 4x8, 4x4}
  35. //static const short blk_child[8]  = {1, 2, 4, 4, 5, 7, 7, 7}; //!< {skip, 16x16, 16x8, 8x16, 8x8, 8x4, 4x8, 4x4}
  36. static const int   minthres_base[8] = {0,  64,  32,  32,  16,  8,  8,  4};
  37. static const int   medthres_base[8] = {0, 256, 128, 128,  64, 32, 32, 16};
  38. static const int   maxthres_base[8] = {0, 768, 384, 384, 192, 96, 96, 48};
  39. static const short search_point_hp[10][2] = {{0,0},{-2,0}, {0,2}, {2,0},  {0,-2}, {-2,2},  {2,2},  {2,-2}, {-2,-2}, {-2,2}};
  40. static const short search_point_qp[10][2] = {{0,0},{-1,0}, {0,1}, {1,0},  {0,-1}, {-1,1},  {1,1},  {1,-1}, {-1,-1}, {-1,1}};
  41. //static const int   next_subpel_pos_start[5][5] = {};
  42. //static const int   next_subpel_pos_end  [5][5] = {};
  43. static int (*computePred)(imgpel* , int , int , int , int , int );
  45. static short EPZSBlkCount;
  46. static int   searcharray;
  47. static int   mv_rescale;
  49. //! Define EPZS Refinement patterns
  50. static int pattern_data[5][12][4] =
  51. {
  52.   { // Small Diamond pattern
  53.     {  0,  4,  3, 3 }, {  4,  0,  0, 3 }, {  0, -4,  1, 3 }, { -4,  0, 2, 3 }
  54.   },
  55.   { // Square pattern
  56.     {  0,  4,  7, 3 }, {  4,  4,  7, 5 }, {  4,  0,  1, 3 }, {  4, -4, 1, 5 },
  57.     {  0, -4,  3, 3 }, { -4, -4,  3, 5 }, { -4,  0,  5, 3 }, { -4,  4, 5, 5 }
  58.   },
  59.   { // Enhanced Diamond pattern
  60.     { -4,  4, 10, 5 }, {  0,  8, 10, 8 }, {  0,  4, 10, 7 }, {  4,  4, 1, 5 },
  61.     {  8,  0, 1,  8 }, {  4,  0,  1, 7 }, {  4, -4,  4, 5 }, {  0, -8, 4, 8 },
  62.     {  0, -4, 4,  7 }, { -4, -4, 7,  5 }, { -8,  0,  7, 8 }, { -4,  0, 7, 7 }
  64.   },
  65.   { // Large Diamond pattern
  66.     {  0,  8, 6,  5 }, {  4,  4, 0,  3 }, {  8,  0, 0,  5 }, {  4, -4, 2, 3 },
  67.     {  0, -8, 2,  5 }, { -4, -4, 4,  3 }, { -8,  0, 4,  5 }, { -4,  4, 6, 3 }
  68.   },
  69.   { // Extended Subpixel pattern
  70.     {  0,  8, 6, 12 }, {  4,  4, 0, 12 }, {  8,  0, 0, 12 }, {  4, -4, 2, 12 },
  71.     {  0, -8, 2, 12 }, { -4, -4, 4, 12 }, { -8,  0, 4, 12 }, { -4,  4, 6, 12 },
  72.     {  0,  2, 6, 12 }, {  2,  0, 0, 12 }, {  0, -2, 2, 12 }, { -2,  0, 4, 12 }
  73.   }
  74. };
  76. // Other definitions
  77. static const char c_EPZSPattern[6][20]     = { "Diamond", "Square", "Extended Diamond", "Large Diamond", "SBP Large Diamond", "PMVFAST"};
  78. static const char c_EPZSDualPattern[7][20] = { "Disabled","Diamond", "Square", "Extended Diamond", "Large Diamond", "SBP Large Diamond", "PMVFAST"};
  79. static const char c_EPZSFixed[3][20]       = { "Disabled","All P", "All P + B"};
  80. static const char c_EPZSOther[2][20]       = { "Disabled","Enabled"};
  82. static int medthres[8];
  83. static int maxthres[8];
  84. static int minthres[8];
  85. static int subthres[8];
  86. static int mv_scale[6][MAX_REFERENCE_PICTURES][MAX_REFERENCE_PICTURES];
  88. static short **EPZSMap;  //!< Memory Map definition
  89. int ***EPZSDistortion;  //!< Array for storing SAD Values
  90. int ***EPZSBiDistortion;  //!< Array for storing SAD Values
  91. #if EPZSREF
  92. MotionVector *****EPZS_Motion;  //!< Array for storing Motion Vectors
  93. short ******EPZSMotion;  //!< Array for storing Motion Vectors
  94. #else
  95. MotionVector ****EPZS_Motion;  //!< Array for storing Motion Vectors
  96. short *****EPZSMotion;  //!< Array for storing Motion Vectors
  97. #endif
  99. //
  100. EPZSStructure *searchPattern,*searchPatternD, *predictor;
  101. EPZSStructure *window_predictor, *window_predictor_extended;
  102. EPZSStructure *sdiamond,*square,*ediamond,*ldiamond, *sbdiamond, *pmvfast;
  103. EPZSColocParams *EPZSCo_located;
  105. // Functions
  107. /*!
  108. *************************************************************************************
  109. * brief
  110. *    Determine stop criterion for EPZS
  111. *************************************************************************************
  112. */
  113. static int EPZSDetermineStopCriterion(int* prevSad, PixelPos *block_a, PixelPos *block_b, PixelPos *block_c, int pic_pix_x2, int blocktype, int blockshape_x)
  114. {
  115.   int sadA, sadB, sadC, stopCriterion;
  117.   sadA = block_a->available ? prevSad[pic_pix_x2 - blockshape_x] : INT_MAX;
  118.   sadB = block_b->available ? prevSad[pic_pix_x2] : INT_MAX;
  119.   sadC = block_c->available ? prevSad[pic_pix_x2 + blockshape_x] : INT_MAX;
  121.   stopCriterion = imin(sadA,imin(sadB,sadC));
  122.   stopCriterion = imax(stopCriterion,minthres[blocktype]);
  123.   stopCriterion = imin(stopCriterion,maxthres[blocktype]);
  125.   stopCriterion = (9 * imax (medthres[blocktype], stopCriterion) + 2 * medthres[blocktype]) >> 3;
  126.   return stopCriterion;
  127. }
  129. /*!
  130. ************************************************************************
  131. * brief
  132. *    Allocate co-located memory
  133. *
  134. * param size_x
  135. *    horizontal luma size
  136. * param size_y
  137. *    vertical luma size
  138. * param mb_adaptive_frame_field_flag
  139. *    flag that indicates macroblock adaptive frame/field coding
  140. *
  141. * return
  142. *    the allocated EPZSColocParams structure
  143. ************************************************************************
  144. */
  145. static EPZSColocParams* allocEPZScolocated(int size_x, int size_y, int mb_adaptive_frame_field_flag)
  146. {
  147.   EPZSColocParams *s;
  149.   s = calloc(1, sizeof(EPZSColocParams));
  150.   if (NULL == s)
  151.     no_mem_exit("alloc_EPZScolocated: s");
  153.   s->size_x = size_x;
  154.   s->size_y = size_y;
  155.   get_mem3Dmv(&(s->frame), 2, size_y / BLOCK_SIZE, size_x / BLOCK_SIZE);
  157.   if (mb_adaptive_frame_field_flag)
  158.   {
  159.     get_mem3Dmv(&(s->top), 2, size_y / (BLOCK_SIZE * 2), size_x / BLOCK_SIZE);
  160.     get_mem3Dmv(&(s->bot), 2, size_y / (BLOCK_SIZE * 2), size_x / BLOCK_SIZE);
  161.   }
  163.   s->mb_adaptive_frame_field_flag  = mb_adaptive_frame_field_flag;
  165.   return s;
  166. }
  168. /*!
  169. ************************************************************************
  170. * brief
  171. *    Free co-located memory.
  172. *
  173. * param p
  174. *    structure to be freed
  175. *
  176. ************************************************************************
  177. */
  178. static void freeEPZScolocated(EPZSColocParams* p)
  179. {
  180.   if (p)
  181.   {
  182.     free_mem3Dmv (p->frame);
  184.     if (p->mb_adaptive_frame_field_flag)
  185.     {
  186.       free_mem3Dmv (p->top);
  187.       free_mem3Dmv (p->bot);
  188.     }
  190.     free(p);
  192.     p=NULL;
  193.   }
  194. }
  196. /*!
  197. ************************************************************************
  198. * brief
  199. *    Allocate EPZS pattern memory
  200. *
  201. * param searchpoints
  202. *    number of searchpoints to allocate
  203. *
  204. * return
  205. *    the allocated EPZSStructure structure
  206. ************************************************************************
  207. */
  208. static EPZSStructure* allocEPZSpattern(int searchpoints)
  209. {
  210.   EPZSStructure *s;
  212.   s = calloc(1, sizeof(EPZSStructure));
  213.   if (NULL == s)
  214.     no_mem_exit("alloc_EPZSpattern: s");
  216.   s->searchPoints = searchpoints;
  217.   s->point = (SPoint*) calloc(searchpoints, sizeof(SPoint));
  219.   return s;
  220. }
  222. /*!
  223. ************************************************************************
  224. * brief
  225. *    Free EPZS pattern memory.
  226. *
  227. * param p
  228. *    structure to be freed
  229. *
  230. ************************************************************************
  231. */
  232. static void freeEPZSpattern(EPZSStructure* p)
  233. {
  234.   if (p)
  235.   {
  236.     free ( (SPoint*) p->point);
  237.     free(p);
  238.     p=NULL;
  239.   }
  240. }
  242. static void assignEPZSpattern(EPZSStructure *pattern,int type, int stopSearch, int nextLast, EPZSStructure *nextpattern)
  243. {
  244.   int i;
  246.   for (i = 0; i < pattern->searchPoints; i++)
  247.   {
  248.     pattern->point[i].motion.mv_x = pattern_data[type][i][0] >> mv_rescale;
  249.     pattern->point[i].motion.mv_y = pattern_data[type][i][1] >> mv_rescale;
  250.     pattern->point[i].start_nmbr  = pattern_data[type][i][2];
  251.     pattern->point[i].next_points = pattern_data[type][i][3];
  252.   }
  253.   pattern->stopSearch = stopSearch;
  254.   pattern->nextLast = nextLast;
  255.   pattern->nextpattern = nextpattern;
  256. }
  258. /*!
  259. ************************************************************************
  260. * brief
  261. *    calculate RoundLog2(uiVal)
  262. ************************************************************************
  263. */
  264. static int RoundLog2 (int iValue)
  265. {
  266.   int iRet = 0;
  267.   int iValue_square = iValue * iValue;
  269.   while ((1 << (iRet + 1)) <= iValue_square)
  270.     iRet++;
  272.   iRet = (iRet + 1) >> 1;
  274.   return iRet;
  275. }
  277. /*!
  278. ***********************************************************************
  279. * brief
  280. *    Add Predictor function
  281. *    
  282. ***********************************************************************
  283. */
  284. static inline int add_predictor(MotionVector *cur_mv, MotionVector prd_mv, int mvScale, int shift_mv)
  285. {
  286.   *cur_mv = prd_mv;
  287.   cur_mv->mv_x = rshift_rnd_sf((mvScale * cur_mv->mv_x), shift_mv);
  288.   cur_mv->mv_y = rshift_rnd_sf((mvScale * cur_mv->mv_y), shift_mv);
  289.   return (*((int*) cur_mv) != 0);
  290. }
  292. /*!
  293. ************************************************************************
  294. * brief
  295. *    EPZS Search Window Predictor Initialization
  296. ************************************************************************
  297. */
  298. static void EPZSWindowPredictorInit (short search_range, EPZSStructure * predictor, short mode)
  299. {
  300.   int pos;
  301.   int searchpos, fieldsearchpos;
  302.   int prednum = 0;
  303.   int i;
  304.   int search_range_qpel = params->EPZSSubPelGrid ? 2 : 0;
  305.   if (mode == 0)
  306.   {
  307.     for (pos = RoundLog2 (search_range) - 2; pos > -1; pos--)
  308.     {
  309.       searchpos = ((search_range << search_range_qpel)>> pos);
  311.       for (i=1; i>=-1; i-=2)
  312.       {
  313.         predictor->point[prednum  ].motion.mv_x =  i * searchpos;
  314.         predictor->point[prednum++].motion.mv_y =  0;
  315.         predictor->point[prednum  ].motion.mv_x =  i * searchpos;
  316.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  317.         predictor->point[prednum  ].motion.mv_x =  0;
  318.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  319.         predictor->point[prednum  ].motion.mv_x = -i * searchpos;
  320.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  321.       }
  322.     }
  323.   }
  324.   else // if (mode == 0)
  325.   {
  326.     for (pos = RoundLog2 (search_range) - 2; pos > -1; pos--)
  327.     {
  328.       searchpos = ((search_range << search_range_qpel) >> pos);
  329.       fieldsearchpos = ((3 * searchpos + 1) << search_range_qpel) >> 1;
  331.       for (i=1; i>=-1; i-=2)
  332.       {
  333.         predictor->point[prednum  ].motion.mv_x =  i * searchpos;
  334.         predictor->point[prednum++].motion.mv_y =  0;
  335.         predictor->point[prednum  ].motion.mv_x =  i * searchpos;
  336.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  337.         predictor->point[prednum  ].motion.mv_x =  0;
  338.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  339.         predictor->point[prednum  ].motion.mv_x = -i * searchpos;
  340.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  341.       }
  343.       for (i=1; i>=-1; i-=2)
  344.       {
  345.         predictor->point[prednum  ].motion.mv_x =  i * fieldsearchpos;
  346.         predictor->point[prednum++].motion.mv_y = -i * searchpos;
  347.         predictor->point[prednum  ].motion.mv_x =  i * fieldsearchpos;
  348.         predictor->point[prednum++].motion.mv_y =  0;
  349.         predictor->point[prednum  ].motion.mv_x =  i * fieldsearchpos;
  350.         predictor->point[prednum++].motion.mv_y =  i * searchpos;
  351.         predictor->point[prednum  ].motion.mv_x =  i * searchpos;
  352.         predictor->point[prednum++].motion.mv_y =  i * fieldsearchpos;
  353.         predictor->point[prednum  ].motion.mv_x =  0;
  354.         predictor->point[prednum++].motion.mv_y =  i * fieldsearchpos;
  355.         predictor->point[prednum  ].motion.mv_x = -i * searchpos;
  356.         predictor->point[prednum++].motion.mv_y =  i * fieldsearchpos;
  357.       }
  358.     }
  359.   }
  360.   predictor->searchPoints = prednum;
  361. }
  363. /*!
  364. ************************************************************************
  365. * brief
  366. *    EPZS Global Initialization
  367. ************************************************************************
  368. */
  369. int EPZSInit (InputParameters *params, ImageParameters *img)
  370. {
  371.   int pel_error_me = 1 << (img->bitdepth_luma - 8);
  372.   int pel_error_me_cr = 1 << (img->bitdepth_chroma - 8);
  373.   int i, memory_size = 0;
  374.   double chroma_weight = params->ChromaMEEnable ? pel_error_me_cr * params->ChromaMEWeight * (double) (img->width_cr * img->height_cr) / (double) (img->width * img->height) : 0;
  375.   int searchlevels = RoundLog2 (params->search_range) - 1;
  376.   
  377.   searcharray = params->BiPredMotionEstimation? (2 * imax (params->search_range, params->BiPredMESearchRange) + 1) << (params->EPZSGrid) : (2 * params->search_range + 1)<< (params->EPZSGrid);
  379.   mv_rescale = params->EPZSSubPelGrid ? 0 : 2;
  380.   
  381.   //! In this implementation we keep threshold limits fixed.
  382.   //! However one could adapt these limits based on lagrangian
  383.   //! optimization considerations (i.e. qp), while also allow
  384.   //! adaptation of the limits themselves based on content or complexity.
  385.   for (i=0;i<8;i++)
  386.   {
  387.     medthres[i] = params->EPZSMedThresScale * (medthres_base[i] * pel_error_me + (int) (medthres_base[i] * chroma_weight + 0.5));
  388.     maxthres[i] = params->EPZSMaxThresScale * (maxthres_base[i] * pel_error_me + (int) (maxthres_base[i] * chroma_weight + 0.5));
  389.     minthres[i] = params->EPZSMinThresScale * (minthres_base[i] * pel_error_me + (int) (minthres_base[i] * chroma_weight + 0.5));
  390.     subthres[i] = params->EPZSSubPelThresScale * (medthres_base[i] * pel_error_me + (int) (medthres_base[i] * chroma_weight + 0.5));
  391.   }
  393.   //! Definition of pottential EPZS patterns.
  394.   //! It is possible to also define other patterns, or even use
  395.   //! resizing patterns (such as the PMVFAST scheme. These patterns
  396.   //! are only shown here as reference, while the same also holds
  397.   //! for this implementation (i.e. new conditions could be added
  398.   //! on adapting predictors, or thresholds etc. Note that search
  399.   //! could also be performed on subpel positions directly while
  400.   //! pattern needs not be restricted on integer positions only.
  402.   //! Allocate memory and assign search patterns
  403.   sdiamond = allocEPZSpattern(4);
  404.   assignEPZSpattern(sdiamond, SDIAMOND, TRUE, TRUE, sdiamond);
  405.   square = allocEPZSpattern(8);
  406.   assignEPZSpattern(square, SQUARE, TRUE, TRUE, square);
  407.   ediamond = allocEPZSpattern(12);
  408.   assignEPZSpattern(ediamond, EDIAMOND, TRUE, TRUE, ediamond);
  409.   ldiamond = allocEPZSpattern(8);
  410.   assignEPZSpattern(ldiamond, LDIAMOND, TRUE, TRUE, ldiamond);
  411.   sbdiamond = allocEPZSpattern(12);
  412.   assignEPZSpattern(sbdiamond, SBDIAMOND, FALSE, TRUE, sdiamond);
  413.   pmvfast = allocEPZSpattern(8);
  414.   assignEPZSpattern(pmvfast, LDIAMOND, FALSE, TRUE, sdiamond);
  416.   //! Allocate and assign window based predictors.
  417.   //! Other window types could also be used, while method could be
  418.   //! made a bit more adaptive (i.e. patterns could be assigned
  419.   //! based on neighborhood
  420.   window_predictor = allocEPZSpattern(searchlevels * 8);
  421.   window_predictor_extended = allocEPZSpattern(searchlevels * 20);
  422.   EPZSWindowPredictorInit ((short) params->search_range, window_predictor, 0);
  423.   EPZSWindowPredictorInit ((short) params->search_range, window_predictor_extended, 1);
  424.   //! Also assing search predictor memory
  425.   // maxwindow + spatial + blocktype + temporal + memspatial
  426.   predictor = allocEPZSpattern(searchlevels * 20 + 5 + 5 + 9 * (params->EPZSTemporal) + 3 * (params->EPZSSpatialMem));
  428.   //! Finally assign memory for all other elements
  429.   //! (distortion, EPZSMap, and temporal predictors)
  431.   //memory_size += get_offset_mem2Dshort(&EPZSMap, searcharray, searcharray, (searcharray>>1), (searcharray>>1));
  432.   memory_size += get_mem3Dint (&EPZSDistortion, 6, 7, img->width/BLOCK_SIZE);
  433.   if (params->BiPredMotionEstimation)
  434.     memory_size += get_mem3Dint (&EPZSBiDistortion, 6, 7, img->width/BLOCK_SIZE);
  435.   memory_size += get_mem2Dshort (&EPZSMap, searcharray, searcharray );
  437.   if (params->EPZSSpatialMem)
  438.   {
  439. #if EPZSREF
  440.     memory_size += get_mem5Dmv (&EPZS_Motion, 6, img->max_num_references, 7, 4, img->width/BLOCK_SIZE);
  441.     memory_size += get_mem6Dshort (&EPZSMotion, 6, img->max_num_references, 7, 4, img->width/BLOCK_SIZE, 2);
  442. #else
  443.     memory_size += get_mem4Dmv (&EPZS_Motion, 6, 7, 4, img->width/BLOCK_SIZE);
  444.     memory_size += get_mem5Dshort (&EPZSMotion, 6, 7, 4, img->width/BLOCK_SIZE, 2);
  445. #endif
  446.   }
  448.   if (params->EPZSTemporal)
  449.     EPZSCo_located = allocEPZScolocated (img->width, img->height, active_sps->mb_adaptive_frame_field_flag);
  451.   switch (params->EPZSPattern)
  452.   {
  453.   case 5:
  454.     searchPattern = pmvfast;
  455.     break;
  456.   case 4:
  457.     searchPattern = sbdiamond;
  458.     break;
  459.   case 3:
  460.     searchPattern = ldiamond;
  461.     break;
  462.   case 2:
  463.     searchPattern = ediamond;
  464.     break;
  465.   case 1:
  466.     searchPattern = square;
  467.     break;
  468.   case 0:
  469.   default:
  470.     searchPattern = sdiamond;
  471.     break;
  472.   }
  474.   switch (params->EPZSDual)
  475.   {
  476.   case 6:
  477.     searchPatternD = pmvfast;
  478.     break;
  479.   case 5:
  480.     searchPatternD = sbdiamond;
  481.     break;
  482.   case 4:
  483.     searchPatternD = ldiamond;
  484.     break;
  485.   case 3:
  486.     searchPatternD = ediamond;
  487.     break;
  488.   case 2:
  489.     searchPatternD = square;
  490.     break;
  491.   case 1:
  492.   default:
  493.     searchPatternD = sdiamond;
  494.     break;
  495.   }
  497.   return memory_size;
  498. }
  500. /*!
  501. ************************************************************************
  502. * brief
  503. *    Delete EPZS Alocated memory
  504. ************************************************************************
  505. */
  506. void EPZSDelete (InputParameters *params)
  507. {
  508.   if (params->EPZSTemporal)
  509.     freeEPZScolocated (EPZSCo_located);
  511.   //free_offset_mem2Dshort(EPZSMap, searcharray, (searcharray>>1), (searcharray>>1));
  512.   free_mem2Dshort(EPZSMap);
  513.   free_mem3Dint  (EPZSDistortion);
  514.   if (params->BiPredMotionEstimation)
  515.     free_mem3Dint  (EPZSBiDistortion);
  516.   freeEPZSpattern(window_predictor_extended);
  517.   freeEPZSpattern(window_predictor);
  518.   freeEPZSpattern(predictor);
  519.   // Free search patterns
  520.   freeEPZSpattern(pmvfast);
  521.   freeEPZSpattern(sbdiamond);
  522.   freeEPZSpattern(ldiamond);
  523.   freeEPZSpattern(ediamond);
  524.   freeEPZSpattern(sdiamond);
  525.   freeEPZSpattern(square);
  526.   if (params->EPZSSpatialMem)
  527.   {
  528. #if EPZSREF
  529.     free_mem5Dmv (EPZS_Motion);
  530.     free_mem6Dshort (EPZSMotion);
  531. #else
  532.     free_mem4Dmv (EPZS_Motion);
  533.     free_mem5Dshort (EPZSMotion);
  534. #endif
  535.   }
  537. }
  539. //! For ME purposes restricting the co-located partition is not necessary.
  540. /*!
  541. ************************************************************************
  542. * brief
  543. *    EPZS Slice Level Initialization
  544. ************************************************************************
  545. */
  546. void EPZSSliceInit (InputParameters *params, ImageParameters *img, EPZSColocParams * p, StorablePicture ** listX[6])
  547. {
  548.   StorablePicture *fs, *fs_top, *fs_bottom;
  549.   StorablePicture *fs1, *fs_top1, *fs_bottom1, *fsx;
  550.   int i, j, k, jj, jdiv, loffset;
  551.   int prescale, iTRb, iTRp;
  552.   int list = img->type == B_SLICE ? LIST_1 : LIST_0;
  553.   int tempmv_scale[2];
  554.   int epzs_scale[2][6][MAX_LIST_SIZE];
  555.   int iref;
  556.   int invmv_precision = 8;
  558.   // Lets compute scaling factoes between all references in lists.
  559.   // Needed to scale spatial predictors.
  560.   for (j = LIST_0; j < 2 + (img->MbaffFrameFlag * 4); j ++)
  561.   {
  562.     for (k = 0; k < listXsize[j]; k++)
  563.     {
  564.       for (i = 0; i < listXsize[j]; i++)
  565.       {
  566.         if ((j >> 1) == 0)
  567.         {
  568.           iTRb = iClip3 (-128, 127, enc_picture->poc - listX[j][i]->poc);
  569.           iTRp = iClip3 (-128, 127, enc_picture->poc - listX[j][k]->poc);
  570.         }
  571.         else if ((j >> 1) == 1)
  572.         {
  573.           iTRb = iClip3 (-128, 127, enc_picture->top_poc - listX[j][i]->poc);
  574.           iTRp = iClip3 (-128, 127, enc_picture->top_poc - listX[j][k]->poc);
  575.         }
  576.         else
  577.         {
  578.           iTRb = iClip3 (-128, 127, enc_picture->bottom_poc - listX[j][i]->poc);
  579.           iTRp = iClip3 (-128, 127, enc_picture->bottom_poc - listX[j][k]->poc);
  580.         }
  582.         if (iTRp != 0)
  583.         {
  584.           prescale = (16384 + iabs (iTRp / 2)) / iTRp;
  585.           mv_scale[j][i][k] = iClip3 (-2048, 2047, rshift_rnd_sf((iTRb * prescale), 6));
  586.         }
  587.         else
  588.           mv_scale[j][i][k] = 256;
  589.       }
  590.     }
  591.   }
  593.   if (params->EPZSTemporal)
  594.   {
  595.     fs_top = fs_bottom = fs = listX[list][0];
  596.     if (listXsize[list]> 1)
  597.       fs_top1 = fs_bottom1 = fs1 = listX[list][1];
  598.     else
  599.       fs_top1 = fs_bottom1 = fs1 = listX[list][0];
  601.     for (j = 0; j < 6; j++)
  602.     {
  603.       for (i = 0; i < 6; i++)
  604.       {
  605.         epzs_scale[0][j][i] = 256;
  606.         epzs_scale[1][j][i] = 256;
  607.       }
  608.     }
  610.     for (j = 0; j < 2 + (img->MbaffFrameFlag * 4); j += 2)
  611.     {
  612.       for (i = 0; i < listXsize[j]; i++)
  613.       {
  614.         if (j == 0)
  615.           iTRb = iClip3 (-128, 127, enc_picture->poc - listX[LIST_0 + j][i]->poc);
  616.         else if (j == 2)
  617.           iTRb = iClip3 (-128, 127, enc_picture->top_poc - listX[LIST_0 + j][i]->poc);
  618.         else
  619.           iTRb = iClip3 (-128, 127, enc_picture->bottom_poc - listX[LIST_0 + j][i]->poc);
  620.         iTRp = iClip3 (-128, 127, listX[list + j][0]->poc - listX[LIST_0 + j][i]->poc);
  621.         if (iTRp != 0)
  622.         {
  623.           prescale = (16384 + iabs (iTRp / 2)) / iTRp;
  624.           prescale = iClip3 (-2048, 2047, rshift_rnd_sf((iTRb * prescale), 6));
  625.           //prescale = (iTRb * prescale + 32) >> 6;
  626.         }
  627.         else      // This could not happen but lets use it in case that reference is removed.
  628.           prescale = 256;
  629.         epzs_scale[0][j][i] = rshift_rnd_sf((mv_scale[j][0][i] * prescale), 8);
  630.         epzs_scale[0][j + 1][i] = prescale - 256;
  631.         
  632.         if (listXsize[list + j]>1)
  633.         {
  634.           iTRp = iClip3 (-128, 127, listX[list + j][1]->poc - listX[LIST_0 + j][i]->poc);
  635.           if (iTRp != 0)
  636.           {
  637.             prescale = (16384 + iabs (iTRp / 2)) / iTRp;
  638.             prescale = iClip3 (-2048, 2047, rshift_rnd_sf((iTRb * prescale), 6));
  639.             //prescale = (iTRb * prescale + 32) >> 6;
  640.           }
  641.           else      // This could not happen but lets use it for case that reference is removed.
  642.             prescale = 256;
  643.           epzs_scale[1][j][i] = rshift_rnd_sf((mv_scale[j][1][i] * prescale), 8);
  644.           epzs_scale[1][j + 1][i] = prescale - 256;
  645.         }
  646.         else
  647.         {
  648.           epzs_scale[1][j][i] = epzs_scale[0][j][i];
  649.           epzs_scale[1][j + 1][i] = epzs_scale[0][j + 1][i];
  650.         }
  651.       }
  652.     }
  653.     if (img->MbaffFrameFlag)
  654.     {
  655.       fs_top = listX[list + 2][0];
  656.       fs_bottom = listX[list + 4][0];
  657.       if (listXsize[0]> 1)
  658.       {
  659.         fs_top1 = listX[list + 2][1];
  660.         fs_bottom = listX[list + 4][1];
  661.       }
  662.     }
  663.     else
  664.     {
  665.       if (img->structure != FRAME)
  666.       {
  667.         if ((img->structure != fs->structure) && (fs->coded_frame))
  668.         {
  669.           if (img->structure == TOP_FIELD)
  670.           {
  671.             fs_top = fs_bottom = fs = listX[list][0]->top_field;
  672.             fs_top1 = fs_bottom1 = fs1 = listX[list][0]->bottom_field;
  673.           }
  674.           else
  675.           {
  676.             fs_top = fs_bottom = fs = listX[list][0]->bottom_field;
  677.             fs_top1 = fs_bottom1 = fs1 = listX[list][0]->top_field;
  678.           }
  679.         }
  680.       }
  681.     }
  683.     if (!active_sps->frame_mbs_only_flag)
  684.     {
  685.       if (img->MbaffFrameFlag)
  686.       {
  687.         for (j = 0; j < fs->size_y >> 2; j++)
  688.         {
  689.           jj = j >> 1;
  690.           jdiv = jj + 4 * (j >> 3);
  692.           for (i = 0; i < fs->size_x >> 2; i++)
  693.           {
  694.             if (fs->motion.field_frame[j][i])
  695.             {
  696.               //! Assign frame buffers for field MBs
  697.               //! Check whether we should use top or bottom field mvs.
  698.               //! Depending on the assigned poc values.
  699.               if (iabs (enc_picture->poc - fs_bottom->poc) > iabs (enc_picture->poc - fs_top->poc))
  700.               {
  701.                 tempmv_scale[LIST_0] = 256;
  702.                 tempmv_scale[LIST_1] = 0;
  704.                 if (fs->motion.ref_id [LIST_0][jdiv][i] < 0 && listXsize[LIST_0] > 1)
  705.                 {
  706.                   fsx = fs_top1;
  707.                   loffset = 1;
  708.                 }
  709.                 else
  710.                 {
  711.                   fsx = fs_top;
  712.                   loffset = 0;
  713.                 }
  715.                 if (fs->motion.ref_id [LIST_0][jdiv][i] != -1)
  716.                 {
  717.                   for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  718.                   {
  719.                     if (enc_picture->ref_pic_num[LIST_0][iref]==fs->motion.ref_id [LIST_0][jdiv][i])
  720.                     {
  721.                       tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  722.                       tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  723.                       break;
  724.                     }
  725.                   }
  726.                   p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  727.                   p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  728.                   p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  729.                   p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  730.                 }
  731.                 else
  732.                 {
  733.                   p->frame[LIST_0][j][i].mv_x = 0;
  734.                   p->frame[LIST_0][j][i].mv_y = 0;
  735.                   p->frame[LIST_1][j][i].mv_x = 0;
  736.                   p->frame[LIST_1][j][i].mv_y = 0;
  737.                 }
  738.               }
  739.               else
  740.               {
  741.                 tempmv_scale[LIST_0] = 256;
  742.                 tempmv_scale[LIST_1] = 0;
  744.                 if (fs->motion.ref_id [LIST_0][jdiv + 4][i] < 0 && listXsize[LIST_0] > 1)
  745.                 {
  746.                   fsx = fs_bottom1;
  747.                   loffset = 1;
  748.                 }
  749.                 else
  750.                 {
  751.                   fsx = fs_bottom;
  752.                   loffset = 0;
  753.                 }
  755.                 if (fs->motion.ref_id [LIST_0][jdiv + 4][i] != -1)
  756.                 {
  757.                   for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  758.                   {
  759.                     if (enc_picture->ref_pic_num[LIST_0][iref]==fs->motion.ref_id [LIST_0][jdiv + 4][i])
  760.                     {
  761.                       tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  762.                       tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  763.                       break;
  764.                     }
  765.                   }
  766.                   p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  767.                   p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  768.                   p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  769.                   p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  770.                 }
  771.                 else
  772.                 {
  773.                   p->frame[LIST_0][j][i].mv_x = 0;
  774.                   p->frame[LIST_0][j][i].mv_y = 0;
  775.                   p->frame[LIST_1][j][i].mv_x = 0;
  776.                   p->frame[LIST_1][j][i].mv_y = 0;
  777.                 }
  778.               }
  779.             }
  780.             else
  781.             {
  782.               tempmv_scale[LIST_0] = 256;
  783.               tempmv_scale[LIST_1] = 0;
  784.               if (fs->motion.ref_id [LIST_0][j][i] < 0 && listXsize[LIST_0] > 1)
  785.               {
  786.                 fsx = fs1;
  787.                 loffset = 1;
  788.               }
  789.               else
  790.               {
  791.                 fsx = fs;
  792.                 loffset = 0;
  793.               }
  795.               if (fsx->motion.ref_id [LIST_0][j][i] != -1)
  796.               {
  797.                 for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  798.                 {
  799.                   if (enc_picture->ref_pic_num[LIST_0][iref]==fsx->motion.ref_id [LIST_0][j][i])
  800.                   {
  801.                     tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  802.                     tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  803.                     break;
  804.                   }
  805.                 }
  806.                 p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  807.                 p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  808.                 p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  809.                 p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  810.               }
  811.               else
  812.               {
  813.                 p->frame[LIST_0][j][i].mv_x = 0;
  814.                 p->frame[LIST_0][j][i].mv_y = 0;
  815.                 p->frame[LIST_1][j][i].mv_x = 0;
  816.                 p->frame[LIST_1][j][i].mv_y = 0;
  817.               }
  818.             }
  819.           }
  820.         }
  821.       }
  822.       else
  823.       {
  824.         for (j = 0; j < fs->size_y >> 2; j++)
  825.         {
  826.           jj = j >> 1;
  827.           jdiv = jj + 4 * (j >> 3);
  829.           for (i = 0; i < fs->size_x >> 2; i++)
  830.           {
  831.             tempmv_scale[LIST_0] = 256;
  832.             tempmv_scale[LIST_1] = 0;
  833.             if (fs->motion.ref_id [LIST_0][j][i] < 0 && listXsize[LIST_0] > 1)
  834.             {
  835.               fsx = fs1;
  836.               loffset = 1;
  837.             }
  838.             else
  839.             {
  840.               fsx = fs;
  841.               loffset = 0;
  842.             }
  844.             if (fsx->motion.ref_id [LIST_0][j][i] != -1)
  845.             {
  846.               for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  847.               {
  848.                 if (enc_picture->ref_pic_num[LIST_0][iref]==fsx->motion.ref_id [LIST_0][j][i])
  849.                 {
  850.                   tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  851.                   tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  852.                   break;
  853.                 }
  854.               }
  855.               p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  856.               p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  857.               p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  858.               p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  859.             }
  860.             else
  861.             {
  862.               p->frame[LIST_0][j][i].mv_x = 0;
  863.               p->frame[LIST_0][j][i].mv_y = 0;
  864.               p->frame[LIST_1][j][i].mv_x = 0;
  865.               p->frame[LIST_1][j][i].mv_y = 0;
  866.             }
  867.           }
  868.         }
  869.       }
  870.       
  871.       //! Generate field MVs from Frame MVs
  872.       if (img->structure || img->MbaffFrameFlag)
  873.       {
  874.         for (j = 0; j < fs->size_y / 8; j++)
  875.         {
  876.           for (i = 0; i < fs->size_x / 4; i++)
  877.           {
  878.             if (!img->MbaffFrameFlag)
  879.             {
  880.               tempmv_scale[LIST_0] = 256;
  881.               tempmv_scale[LIST_1] = 0;
  883.               if (fs->motion.ref_id [LIST_0][j][i] < 0 && listXsize[LIST_0] > 1)
  884.               {
  885.                 fsx = fs1;
  886.                 loffset = 1;
  887.               }
  888.               else
  889.               {
  890.                 fsx = fs;
  891.                 loffset = 0;
  892.               }
  894.               if (fsx->motion.ref_id [LIST_0][j][i] != -1)
  895.               {
  896.                 for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  897.                 {
  898.                   if (enc_picture->ref_pic_num[LIST_0][iref]==fsx->motion.ref_id [LIST_0][j][i])
  899.                   {
  900.                     tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  901.                     tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  902.                     break;
  903.                   }
  904.                 }
  905.                 p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  906.                 p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  907.                 p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  908.                 p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  909.               }
  910.               else
  911.               {
  912.                 p->frame[LIST_0][j][i].mv_x = 0;
  913.                 p->frame[LIST_0][j][i].mv_y = 0;
  914.                 p->frame[LIST_1][j][i].mv_x = 0;
  915.                 p->frame[LIST_1][j][i].mv_y = 0;
  916.               }
  917.             }
  918.             else
  919.             {
  920.               tempmv_scale[LIST_0] = 256;
  921.               tempmv_scale[LIST_1] = 0;
  923.               if (fs_bottom->motion.ref_id [LIST_0][j][i] < 0 && listXsize[LIST_0] > 1)
  924.               {
  925.                 fsx = fs_bottom1;
  926.                 loffset = 1;
  927.               }
  928.               else
  929.               {
  930.                 fsx = fs_bottom;
  931.                 loffset = 0;
  932.               }
  934.               if (fsx->motion.ref_id [LIST_0][j][i] != -1)
  935.               {
  936.                 for (iref = 0; iref < imin(2*img->num_ref_idx_l0_active,listXsize[LIST_0 + 4]); iref++)
  937.                 {
  938.                   if (enc_picture->ref_pic_num[LIST_0 + 4][iref]==fsx->motion.ref_id [LIST_0][j][i])
  939.                   {
  940.                     tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0 + 4][iref];
  941.                     tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1 + 4][iref];
  942.                     break;
  943.                   }
  944.                 }
  945.                 p->bot[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  946.                 p->bot[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  947.                 p->bot[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  948.                 p->bot[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  949.               }
  950.               else
  951.               {
  952.                 p->bot[LIST_0][j][i].mv_x = 0;
  953.                 p->bot[LIST_0][j][i].mv_y = 0;
  954.                 p->bot[LIST_1][j][i].mv_x = 0;
  955.                 p->bot[LIST_1][j][i].mv_y = 0;
  956.               }
  958.               if (!fs->motion.field_frame[2 * j][i])
  959.               {
  960.                 p->bot[LIST_0][j][i].mv_y  = (p->bot[LIST_0][j][i].mv_y + 1) >> 1;
  961.                 p->bot[LIST_1][j][i].mv_y  = (p->bot[LIST_1][j][i].mv_y + 1) >> 1;
  962.               }
  964.               tempmv_scale[LIST_0] = 256;
  965.               tempmv_scale[LIST_1] = 0;
  967.               if (fs_top->motion.ref_id [LIST_0][j][i] < 0 && listXsize[LIST_0] > 1)
  968.               {
  969.                 fsx = fs_top1;
  970.                 loffset = 1;
  971.               }
  972.               else
  973.               {
  974.                 fsx = fs_top;
  975.                 loffset = 0;
  976.               }
  978.               if (fsx->motion.ref_id [LIST_0][j][i] != -1)
  979.               {
  980.                 for (iref = 0; iref < imin(2*img->num_ref_idx_l0_active,listXsize[LIST_0 + 2]); iref++)
  981.                 {
  982.                   if (enc_picture->ref_pic_num[LIST_0 + 2][iref]==fsx->motion.ref_id [LIST_0][j][i])
  983.                   {
  984.                     tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0 + 2][iref];
  985.                     tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1 + 2][iref];
  986.                     break;
  987.                   }
  988.                 }
  989.                 p->top[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  990.                 p->top[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  991.                 p->top[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  992.                 p->top[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  993.               }
  994.               else
  995.               {
  996.                 p->top[LIST_0][j][i].mv_x = 0;
  997.                 p->top[LIST_0][j][i].mv_y = 0;
  998.                 p->top[LIST_1][j][i].mv_x = 0;
  999.                 p->top[LIST_1][j][i].mv_y = 0;
  1000.               }
  1002.               if (!fs->motion.field_frame[2 * j][i])
  1003.               {
  1004.                 p->top[LIST_0][j][i].mv_y  = (p->top[LIST_0][j][i].mv_y + 1) >> 1;
  1005.                 p->top[LIST_1][j][i].mv_y  = (p->top[LIST_1][j][i].mv_y + 1) >> 1;
  1006.               }
  1007.             }
  1008.           }
  1009.         }
  1010.       }
  1011.     }
  1013.     //if (!active_sps->frame_mbs_only_flag || active_sps->direct_8x8_inference_flag)
  1014.     if (!active_sps->frame_mbs_only_flag )
  1015.     {
  1016.       //! Use inference flag to remap mvs/references
  1017.       //! Frame with field co-located
  1018.       if (!img->structure)
  1019.       {
  1020.         for (j = 0; j < fs->size_y >> 2; j++)
  1021.         {
  1022.           jj = j>>1;
  1023.           jdiv = (j>>1) + ((j>>3) << 2);
  1024.           for (i = 0; i < fs->size_x >> 2; i++)
  1025.           {
  1026.             if (fs->motion.field_frame[j][i])
  1027.             {
  1028.               tempmv_scale[LIST_0] = 256;
  1029.               tempmv_scale[LIST_1] = 0;
  1031.               if (fs->motion.ref_id [LIST_0][jdiv][i] < 0 && listXsize[LIST_0] > 1)
  1032.               {
  1033.                 fsx = fs1;
  1034.                 loffset = 1;
  1035.               }
  1036.               else
  1037.               {
  1038.                 fsx = fs;
  1039.                 loffset = 0;
  1040.               }
  1041.               if (fsx->motion.ref_id [LIST_0][jdiv][i] != -1)
  1042.               {
  1043.                 for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  1044.                 {
  1045.                   if (enc_picture->ref_pic_num[LIST_0][iref]==fsx->motion.ref_id [LIST_0][jdiv][i])
  1046.                   {
  1047.                     tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  1048.                     tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  1049.                     break;
  1050.                   }
  1051.                 }
  1053.                 if (iabs (enc_picture->poc - fsx->bottom_field->poc) > iabs (enc_picture->poc - fsx->top_field->poc))
  1054.                 {
  1055.                   p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->top_field->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  1056.                   p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->top_field->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  1057.                   p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->top_field->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  1058.                   p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->top_field->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  1059.                 }
  1060.                 else
  1061.                 {
  1062.                   p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->bottom_field->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  1063.                   p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->bottom_field->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  1064.                   p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->bottom_field->motion.mv[LIST_0][jj][i][0]), invmv_precision));
  1065.                   p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->bottom_field->motion.mv[LIST_0][jj][i][1]), invmv_precision));
  1066.                 }
  1067.               }
  1068.               else
  1069.               {
  1070.                 p->frame[LIST_0][j][i].mv_x = 0;
  1071.                 p->frame[LIST_0][j][i].mv_y = 0;
  1072.                 p->frame[LIST_1][j][i].mv_x = 0;
  1073.                 p->frame[LIST_1][j][i].mv_y = 0;
  1074.               }
  1075.             }
  1076.           }
  1077.         }
  1078.       }
  1079.     }
  1081.     if (active_sps->frame_mbs_only_flag)
  1082.     {
  1083.       for (j = 0; j < fs->size_y >> 2; j++)
  1084.       {
  1085.         for (i = 0; i < fs->size_x >> 2; i++)
  1086.         {
  1087.           tempmv_scale[LIST_0] = 256;
  1088.           tempmv_scale[LIST_1] = 0;
  1089.           if (fs->motion.ref_id [LIST_0][j][i] < 0 && listXsize[LIST_0] > 1)
  1090.           {
  1091.             fsx = fs1;
  1092.             loffset = 1;
  1093.           }
  1094.           else
  1095.           {
  1096.             fsx = fs;
  1097.             loffset = 0;
  1098.           }
  1099.          
  1100.           if (fsx->motion.ref_id [LIST_0][j][i] != -1)
  1101.           {
  1102.             for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0]); iref++)
  1103.             {
  1104.               if (enc_picture->ref_pic_num[LIST_0][iref]==fsx->motion.ref_id [LIST_0][j][i])
  1105.               {
  1106.                 tempmv_scale[LIST_0] = epzs_scale[loffset][LIST_0][iref];
  1107.                 tempmv_scale[LIST_1] = epzs_scale[loffset][LIST_1][iref];
  1108.                 break;
  1109.               }
  1110.             }
  1112.             p->frame[LIST_0][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  1113.             p->frame[LIST_0][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_0] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  1114.             p->frame[LIST_1][j][i].mv_x = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][0]), invmv_precision));
  1115.             p->frame[LIST_1][j][i].mv_y = iClip3 (-32768, 32767, rshift_rnd_sf((tempmv_scale[LIST_1] * fsx->motion.mv[LIST_0][j][i][1]), invmv_precision));
  1116.           }
  1117.           else
  1118.           {
  1119.             p->frame[LIST_0][j][i].mv_x = 0;
  1120.             p->frame[LIST_0][j][i].mv_y = 0;
  1121.             p->frame[LIST_1][j][i].mv_x = 0;
  1122.             p->frame[LIST_1][j][i].mv_y = 0;
  1123.           }
  1124.         }
  1125.       }
  1126.     }
  1128.     if (!active_sps->frame_mbs_only_flag)
  1129.     {
  1130.       for (j = 0; j < fs->size_y >> 2; j++)
  1131.       {
  1132.         for (i = 0; i < fs->size_x >> 2; i++)
  1133.         {
  1134.           if ((!img->MbaffFrameFlag && !img->structure && fs->motion.field_frame[j][i]) || (img->MbaffFrameFlag && fs->motion.field_frame[j][i]))
  1135.           {
  1136.             p->frame[LIST_0][j][i].mv_y *= 2; 
  1137.             p->frame[LIST_1][j][i].mv_y *= 2;
  1138.           }
  1139.           else if (img->structure && !fs->motion.field_frame[j][i])
  1140.           {
  1141.             p->frame[LIST_0][j][i].mv_y = rshift_rnd_sf(p->frame[LIST_0][j][i].mv_y, 1);
  1142.             p->frame[LIST_1][j][i].mv_y = rshift_rnd_sf(p->frame[LIST_1][j][i].mv_y, 1);
  1143.           }
  1144.         }
  1145.       }
  1146.     }
  1147.   }
  1148. }
  1150. /*!
  1151. ***********************************************************************
  1152. * brief
  1153. *    Spatial Predictors
  1154. *    AMT/HYC
  1155. ***********************************************************************
  1156. */
  1157. static short EPZSSpatialPredictors (PixelPos block_a,
  1158.                                     PixelPos block_b,
  1159.                                     PixelPos block_c,
  1160.                                     PixelPos block_d,
  1161.                                     int list,
  1162.                                     int list_offset,
  1163.                                     short ref,
  1164.                                     char **refPic,
  1165.                                     short ***tmp_mv,
  1166.                                     EPZSStructure * predictor)
  1167. {
  1168.   int refA, refB, refC, refD;
  1169.   int *mot_scale = mv_scale[list + list_offset][ref];
  1170.   short sp_shift_mv = 8 + mv_rescale;
  1171.   int   fixed_mv = (12 >> mv_rescale);
  1173.   // zero predictor
  1174.   predictor->point[0].motion.mv_x = 0;
  1175.   predictor->point[0].motion.mv_y = 0;
  1177.   // Non MB-AFF mode
  1178.   if (!img->MbaffFrameFlag)
  1179.   {
  1180.     refA = block_a.available ? (int) refPic[block_a.pos_y][block_a.pos_x] : -1;
  1181.     refB = block_b.available ? (int) refPic[block_b.pos_y][block_b.pos_x] : -1;
  1182.     refC = block_c.available ? (int) refPic[block_c.pos_y][block_c.pos_x] : -1;
  1183.     refD = block_d.available ? (int) refPic[block_d.pos_y][block_d.pos_x] : -1;
  1185.     // Left Predictor
  1186.     if (block_a.available)
  1187.     {
  1188.       predictor->point[1].motion.mv_x = rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][0]), sp_shift_mv);
  1189.       predictor->point[1].motion.mv_y = rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][1]), sp_shift_mv);
  1190.     }
  1191.     else
  1192.     {
  1193.       predictor->point[1].motion.mv_x = fixed_mv;
  1194.       predictor->point[1].motion.mv_y = 0;
  1195.     }
  1196.     // Up predictor
  1197.     if (block_b.available)
  1198.     {
  1199.       predictor->point[2].motion.mv_x = rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][0]), sp_shift_mv);
  1200.       predictor->point[2].motion.mv_y = rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][1]), sp_shift_mv);
  1201.     }
  1202.     else
  1203.     {
  1204.       predictor->point[2].motion.mv_x = 0;
  1205.       predictor->point[2].motion.mv_y = fixed_mv;
  1206.     }
  1208.     // Up-Right predictor
  1209.     if (block_c.available)
  1210.     {
  1211.       predictor->point[3].motion.mv_x = rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][0]), sp_shift_mv);
  1212.       predictor->point[3].motion.mv_y = rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][1]), sp_shift_mv);
  1213.     }
  1214.     else
  1215.     {
  1216.       predictor->point[3].motion.mv_x = -fixed_mv;
  1217.       predictor->point[3].motion.mv_y = 0;
  1218.     }
  1220.     //Up-Left predictor
  1221.     if (block_d.available)
  1222.     {
  1223.       predictor->point[4].motion.mv_x = rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][0]), sp_shift_mv);
  1224.       predictor->point[4].motion.mv_y = rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][1]), sp_shift_mv);
  1225.     }
  1226.     else
  1227.     {
  1228.       predictor->point[4].motion.mv_x = 0;
  1229.       predictor->point[4].motion.mv_y = -fixed_mv;
  1230.     }
  1231.   }
  1232.   else  // MB-AFF mode
  1233.   {
  1234.     // Field Macroblock
  1235.     if (list_offset)
  1236.     {
  1237.       refA = block_a.available
  1238.         ? img->mb_data[block_a.mb_addr].mb_field
  1239.         ? (int) refPic[block_a.pos_y][block_a.pos_x]
  1240.         : (int) refPic[block_a.pos_y][block_a.pos_x] * 2 : -1;
  1241.       refB =block_b.available
  1242.         ? img->mb_data[block_b.mb_addr].mb_field
  1243.         ? (int) refPic[block_b.pos_y][block_b.pos_x]
  1244.         : (int) refPic[block_b.pos_y][block_b.pos_x] * 2 : -1;
  1245.       refC = block_c.available
  1246.         ? img->mb_data[block_c.mb_addr].mb_field
  1247.         ? (int) refPic[block_c.pos_y][block_c.pos_x]
  1248.         : (int) refPic[block_c.pos_y][block_c.pos_x] * 2 : -1;
  1249.       refD = block_d.available
  1250.         ? img->mb_data[block_d.mb_addr].mb_field
  1251.         ? (int) refPic[block_d.pos_y][block_d.pos_x]
  1252.         : (int) refPic[block_d.pos_y][block_d.pos_x] * 2 : -1;
  1254.       // Left Predictor
  1255.       predictor->point[1].motion.mv_x = (block_a.available)
  1256.         ? rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][0]), sp_shift_mv) :  fixed_mv;
  1257.       predictor->point[1].motion.mv_y = (block_a.available)
  1258.         ? img->mb_data[block_a.mb_addr].mb_field
  1259.         ? rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][1]), sp_shift_mv)
  1260.         : rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][1]), sp_shift_mv + 1) :  0;
  1262.       // Up predictor
  1263.       predictor->point[2].motion.mv_x = (block_b.available)
  1264.         ? rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][0]), sp_shift_mv) : 0;
  1265.       predictor->point[2].motion.mv_y = (block_b.available)
  1266.         ? img->mb_data[block_b.mb_addr].mb_field
  1267.         ? rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][1]), sp_shift_mv)
  1268.         : rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][1]), sp_shift_mv + 1) : fixed_mv;
  1270.       // Up-Right predictor
  1271.       predictor->point[3].motion.mv_x = (block_c.available)
  1272.         ? rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][0]), sp_shift_mv) : -fixed_mv;
  1273.       predictor->point[3].motion.mv_y = (block_c.available)
  1274.         ? img->mb_data[block_c.mb_addr].mb_field
  1275.         ? rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][1]), sp_shift_mv)
  1276.         : rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][1]), sp_shift_mv + 1) : 0;
  1278.       //Up-Left predictor
  1279.       predictor->point[4].motion.mv_x = (block_d.available)
  1280.         ? rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][0]), sp_shift_mv) : 0;
  1281.       predictor->point[4].motion.mv_y = (block_d.available)
  1282.         ? img->mb_data[block_d.mb_addr].mb_field
  1283.         ? rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][1]), sp_shift_mv)
  1284.         : rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][1]), sp_shift_mv + 1) : -fixed_mv;
  1285.     }
  1286.     else // Frame macroblock
  1287.     {
  1288.       refA = block_a.available
  1289.         ? img->mb_data[block_a.mb_addr].mb_field
  1290.         ? (int) refPic[block_a.pos_y][block_a.pos_x] >> 1
  1291.         : (int) refPic[block_a.pos_y][block_a.pos_x] : -1;
  1292.       refB = block_b.available
  1293.         ? img->mb_data[block_b.mb_addr].mb_field
  1294.         ? (int) refPic[block_b.pos_y][block_b.pos_x] >> 1
  1295.         : (int) refPic[block_b.pos_y][block_b.pos_x] : -1;
  1296.       refC = block_c.available
  1297.         ? img->mb_data[block_c.mb_addr].mb_field
  1298.         ? (int) refPic[block_c.pos_y][block_c.pos_x] >> 1
  1299.         : (int) refPic[block_c.pos_y][block_c.pos_x] : -1;
  1300.       refD = block_d.available
  1301.         ? img->mb_data[block_d.mb_addr].mb_field
  1302.         ? (int) refPic[block_d.pos_y][block_d.pos_x] >> 1
  1303.         : (int) refPic[block_d.pos_y][block_d.pos_x] : -1;
  1305.       // Left Predictor
  1306.       predictor->point[1].motion.mv_x = (block_a.available)
  1307.         ? rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][0]), sp_shift_mv) : fixed_mv;
  1308.       predictor->point[1].motion.mv_y = (block_a.available)
  1309.         ? img->mb_data[block_a.mb_addr].mb_field
  1310.         ? rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][1]), sp_shift_mv - 1)
  1311.         : rshift_rnd_sf((mot_scale[refA] * tmp_mv[block_a.pos_y][block_a.pos_x][1]), sp_shift_mv) : 0;
  1313.       // Up predictor
  1314.       predictor->point[2].motion.mv_x = (block_b.available)
  1315.         ? rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][0]), sp_shift_mv) : 0;
  1316.       predictor->point[2].motion.mv_y = (block_b.available)
  1317.         ? img->mb_data[block_b.mb_addr].mb_field
  1318.         ? rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][1]), sp_shift_mv - 1)
  1319.         : rshift_rnd_sf((mot_scale[refB] * tmp_mv[block_b.pos_y][block_b.pos_x][1]), sp_shift_mv) :  fixed_mv;
  1321.       // Up-Right predictor
  1322.       predictor->point[3].motion.mv_x = (block_c.available)
  1323.         ? rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][0]), sp_shift_mv) : -fixed_mv;
  1324.       predictor->point[3].motion.mv_y = (block_c.available)
  1325.         ? img->mb_data[block_c.mb_addr].mb_field
  1326.         ? rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][1]), sp_shift_mv - 1)
  1327.         : rshift_rnd_sf((mot_scale[refC] * tmp_mv[block_c.pos_y][block_c.pos_x][1]), sp_shift_mv) : 0;
  1329.       //Up-Left predictor
  1330.       predictor->point[4].motion.mv_x = (block_d.available)
  1331.         ? rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][0]), sp_shift_mv) : 0;
  1332.       predictor->point[4].motion.mv_y = (block_d.available)
  1333.         ? img->mb_data[block_d.mb_addr].mb_field
  1334.         ? rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][1]), sp_shift_mv - 1)
  1335.         : rshift_rnd_sf((mot_scale[refD] * tmp_mv[block_d.pos_y][block_d.pos_x][1]), sp_shift_mv) : -fixed_mv;
  1336.     }
  1337.   }
  1339.   return ((refA == -1) + (refB == -1) + (refC == -1 && refD == -1));
  1340. }
  1342. /*!
  1343. ***********************************************************************
  1344. * brief
  1345. *    Spatial Predictors
  1346. *    AMT/HYC
  1347. ***********************************************************************
  1348. */
  1350. static void EPZSSpatialMemPredictors (int list,
  1351.                                       short ref,
  1352.                                       int blocktype,
  1353.                                       int pic_x,
  1354.                                       int bs_x,
  1355.                                       int bs_y,
  1356.                                       int by,
  1357.                                       int *prednum,
  1358.                                       int img_width,
  1359.                                       EPZSStructure * predictor)
  1360. {
  1361. #if EPZSREF
  1362.   short ***mv = EPZSMotion[list][ref][blocktype];
  1363.   //MotionVector ***prd_mv = &EPZS_Motion[list][ref][blocktype];
  1364.   MotionVector *cur_mv = &predictor->point[*prednum].motion;
  1366.   // Left Predictor
  1367.   if (pic_x > 0)
  1368.   {
  1369.     cur_mv->mv_x = mv[by][pic_x - bs_x][0];
  1370.     cur_mv->mv_y = mv[by][pic_x - bs_x][1];
  1371.     *prednum += (*((int*) cur_mv) != 0);
  1372.     cur_mv = &predictor->point[*prednum].motion;
  1373.   }
  1374.   
  1375.   by = (by > 0) ? by - bs_y: 4 - bs_y;
  1376.   // Up predictor  
  1377.   cur_mv->mv_x = mv[by][pic_x][0];
  1378.   cur_mv->mv_y = mv[by][pic_x][1];
  1379.   *prednum += (*((int*) cur_mv) != 0);
  1381.   // Up-Right predictor
  1382.   if (pic_x + bs_x < img_width)
  1383.   {
  1384.     cur_mv = &predictor->point[*prednum].motion;
  1385.     cur_mv->mv_x = mv[by][pic_x + bs_x][0];
  1386.     cur_mv->mv_y = mv[by][pic_x + bs_x][1];
  1387.     *prednum += (*((int*) cur_mv) != 0);
  1388.   }
  1390. #else
  1391.   int mot_scale = mv_scale[list][ref][0];
  1392.   short **mv = EPZSMotion[list][blocktype];
  1393.   MotionVector **predictor = &EPZS_Motion[list][blocktype];
  1395.   // Left Predictor
  1396.   predictor->point[*prednum].motion.mv_x = (pic_x > 0)
  1397.     ? rshift_rnd_sf((mot_scale * mv[by][pic_x - bs_x][0]), 8)
  1398.     : 0;
  1399.   predictor->point[*prednum].motion.mv_y = (pic_x > 0)
  1400.     ? rshift_rnd_sf((mot_scale * mv[by][pic_x - bs_x][1]), 8)
  1401.     : 0;
  1402.   *prednum += ((predictor->point[*prednum].motion.mv_x != 0) || (predictor->point[*prednum].motion.mv_y != 0));
  1404.   // Up predictor
  1405.   predictor->point[*prednum].motion.mv_x = (by > 0)
  1406.     ? rshift_rnd_sf((mot_scale * mv[by - bs_y][pic_x][0]), 8)
  1407.     : rshift_rnd_sf((mot_scale * mv[4  - bs_y][pic_x][0]), 8);
  1408.   predictor->point[*prednum].motion.mv_y = (by > 0)
  1409.     ? rshift_rnd_sf((mot_scale * mv[by - bs_y][pic_x][1]), 8)
  1410.     : rshift_rnd_sf((mot_scale * mv[4  - bs_y][pic_x][1]), 8);
  1411.   *prednum += ((predictor->point[*prednum].motion.mv_x != 0) || (predictor->point[*prednum].motion.mv_y != 0));
  1413.   // Up-Right predictor
  1414.   predictor->point[*prednum].motion.mv_x = (pic_x + bs_x < img_width)
  1415.     ? (by > 0)
  1416.     ? rshift_rnd_sf((mot_scale * mv[by - bs_y][pic_x + bs_x][0]), 8)
  1417.     : rshift_rnd_sf((mot_scale * mv[4  - bs_y][pic_x + bs_x][0]), 8)
  1418.     : 0;
  1419.   predictor->point[*prednum].motion.mv_y = (pic_x + bs_x < img_width)
  1420.     ? (by > 0)
  1421.     ? rshift_rnd_sf((mot_scale * mv[by - bs_y][pic_x + bs_x][1]), 8)
  1422.     : rshift_rnd_sf((mot_scale * mv[4  - bs_y][pic_x + bs_x][1]), 8)
  1423.     : 0;
  1424.   *prednum += ((predictor->point[*prednum].motion.mv_x != 0) || (predictor->point[*prednum].motion.mv_y != 0));
  1425. #endif
  1426. }
  1429. /*!
  1430. ***********************************************************************
  1431. * brief
  1432. *    Temporal Predictors
  1433. *    AMT/HYC
  1434. ***********************************************************************
  1435. */
  1436. static void
  1437. EPZSTemporalPredictors (int list,         // <--  current list
  1438.                         int list_offset,  // <--  list offset for MBAFF
  1439.                         short ref,        // <--  current reference frame
  1440.                         int o_block_x,    // <--  absolute x-coordinate of regarded AxB block
  1441.                         int o_block_y,    // <--  absolute y-coordinate of regarded AxB block
  1442.                         EPZSStructure * predictor,
  1443.                         int *prednum,
  1444.                         int block_available_left,
  1445.                         int block_available_up,
  1446.                         int block_available_right,
  1447.                         int block_available_below,
  1448.                         int blockshape_x,
  1449.                         int blockshape_y,
  1450.                         int stopCriterion,
  1451.                         int min_mcost)
  1452. {
  1453.   int mvScale = mv_scale[list + list_offset][ref][0];
  1454.   MotionVector **col_mv = (list_offset == 0) ? EPZSCo_located->frame[list]  
  1455.     : (list_offset == 2) ? EPZSCo_located->top[list] : EPZSCo_located->bot[list];
  1456.   short temp_shift_mv = 8 + mv_rescale; // 16 - invmv_precision + mv_rescale
  1457.   MotionVector *cur_mv = &predictor->point[*prednum].motion;
  1459.   *prednum += add_predictor(cur_mv, col_mv[o_block_y][o_block_x], mvScale, temp_shift_mv);
  1461.   if (min_mcost > stopCriterion && ref < 2)
  1462.   {
  1463.     if (block_available_left)
  1464.     {
  1465.       *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y][o_block_x - 1], mvScale, temp_shift_mv);
  1467.       //Up_Left
  1468.       if (block_available_up)
  1469.       {
  1470.         *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y - 1][o_block_x - 1], mvScale, temp_shift_mv);
  1471.       }
  1472.       //Down_Left
  1473.       if (block_available_below)
  1474.       {
  1475.         *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y + blockshape_y][o_block_x - 1], mvScale, temp_shift_mv);
  1476.       }
  1477.     }
  1478.     // Up
  1479.     if (block_available_up)
  1480.     {
  1481.       *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y - 1][o_block_x], mvScale, temp_shift_mv);
  1482.     }
  1484.     // Up - Right
  1485.     if (block_available_right)
  1486.     {
  1487.       *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y][o_block_x + blockshape_x], mvScale, temp_shift_mv);
  1489.       if (block_available_up)
  1490.       {
  1491.         *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y - 1][o_block_x + blockshape_x], mvScale, temp_shift_mv);
  1492.       }
  1493.       if (block_available_below)
  1494.       {
  1495.         *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y + blockshape_y][o_block_x + blockshape_x], mvScale, temp_shift_mv);
  1496.       }
  1497.     }
  1499.     if (block_available_below)
  1500.     {
  1501.       *prednum += add_predictor( &predictor->point[*prednum].motion, col_mv[o_block_y + blockshape_y][o_block_x], mvScale, temp_shift_mv);
  1502.     }
  1503.   }
  1504. }
  1506. /*!
  1507. ************************************************************************
  1508. * brief
  1509. *    EPZS Block Type Predictors
  1510. ************************************************************************
  1511. */
  1512. static void EPZSBlockTypePredictors (int block_x, int block_y, int blocktype, int ref, int list,
  1513.                                      EPZSStructure * predictor, int *prednum)
  1514. {
  1515.   short *****all_mv = img->all_mv[list];
  1516.   short block_shift_mv = 8 + mv_rescale;
  1517.   MotionVector *cur_mv = &predictor->point[*prednum].motion;
  1519.   cur_mv->mv_x = rshift_rnd((all_mv[ref][blk_parent[blocktype]][block_y][block_x][0]), mv_rescale);
  1520.   cur_mv->mv_y = rshift_rnd((all_mv[ref][blk_parent[blocktype]][block_y][block_x][1]), mv_rescale);
  1521.   //*prednum += ((cur_mv->mv_x | cur_mv->mv_y) != 0);
  1522.   *prednum += (*((int*) cur_mv) != 0);
  1524.   if ((ref > 0) && (blocktype < 5 || img->structure != FRAME))
  1525.   {
  1526.     cur_mv = &predictor->point[*prednum].motion;
  1527.     cur_mv->mv_x = rshift_rnd_sf((mv_scale[list][ref][ref-1] * all_mv[ref-1][blocktype][block_y][block_x][0]), block_shift_mv );
  1528.     cur_mv->mv_y = rshift_rnd_sf((mv_scale[list][ref][ref-1] * all_mv[ref-1][blocktype][block_y][block_x][1]), block_shift_mv );
  1529.     //*prednum += ((cur_mv->mv_x | cur_mv->mv_y) != 0);
  1530.     *prednum += (*((int*) cur_mv) != 0);
  1533.     cur_mv = &predictor->point[*prednum].motion;
  1534.     cur_mv->mv_x = rshift_rnd_sf((mv_scale[list][ref][0] * all_mv[0][blocktype][block_y][block_x][0]), block_shift_mv );
  1535.     cur_mv->mv_y = rshift_rnd_sf((mv_scale[list][ref][0] * all_mv[0][blocktype][block_y][block_x][1]), block_shift_mv );
  1536.     //*prednum += ((cur_mv->mv_x | cur_mv->mv_y) != 0);
  1537.     *prednum += (*((int*) cur_mv) != 0);
  1538.   }
  1540.   if (blocktype != 1)
  1541.   {
  1542.     cur_mv = &predictor->point[*prednum].motion;
  1543.     cur_mv->mv_x = rshift_rnd((all_mv[ref][1][block_y][block_x][0]), mv_rescale);
  1544.     cur_mv->mv_y = rshift_rnd((all_mv[ref][1][block_y][block_x][1]), mv_rescale);
  1545.     //*prednum += ((cur_mv->mv_x | cur_mv->mv_y) != 0);
  1546.     *prednum += (*((int*) cur_mv) != 0);
  1547.   }
  1549.   if (blocktype != 4)
  1550.   {
  1551.     cur_mv = &predictor->point[*prednum].motion;
  1552.     cur_mv->mv_x = rshift_rnd((all_mv[ref][4][block_y][block_x][0]), mv_rescale);
  1553.     cur_mv->mv_y = rshift_rnd((all_mv[ref][4][block_y][block_x][1]), mv_rescale);
  1554.     //*prednum += ((cur_mv->mv_x | cur_mv->mv_y) != 0);
  1555.     *prednum += (*((int*) cur_mv) != 0);
  1556.   }
  1557. }
  1559. /*!
  1560. ************************************************************************
  1561. * brief
  1562. *    EPZS Window Based Predictors
  1563. ************************************************************************
  1564. */
  1565. static void EPZSWindowPredictors (short mv[2], EPZSStructure *predictor, int *prednum, int extended)
  1566. {
  1567.   int pos;
  1568.   EPZSStructure *windowPred = (extended) ? window_predictor_extended : window_predictor;
  1569.   SPoint *wPoint = &windowPred->point[0];
  1570.   SPoint *pPoint = &predictor->point[(*prednum)];
  1572.   for (pos = 0; pos < windowPred->searchPoints; pos++)
  1573.   {
  1574.     (pPoint  )->motion.mv_x = mv[0] + (wPoint  )->motion.mv_x;
  1575.     (pPoint++)->motion.mv_y = mv[1] + (wPoint++)->motion.mv_y;    
  1576.   }
  1577.   *prednum += windowPred->searchPoints;
  1578. }
  1580. /*!
  1581. ***********************************************************************
  1582. * brief
  1583. *    FAST Motion Estimation using EPZS
  1584. *    AMT/HYC
  1585. ***********************************************************************
  1586. */
  1587. int                                           //  ==> minimum motion cost after search
  1588. EPZSPelBlockMotionSearch (Macroblock *currMB, // <--  current Macroblock
  1589.                           imgpel * cur_pic,   // <--  original pixel values for the AxB block
  1590.                           short ref,          // <--  reference picture
  1591.                           int list,           // <--  reference list
  1592.                           int list_offset,    // <--  offset for Mbaff
  1593.                           char ***refPic,     // <--  reference array
  1594.                           short ****tmp_mv,   // <--  mv array
  1595.                           int pic_pix_x,      // <--  absolute x-coordinate of regarded AxB block
  1596.                           int pic_pix_y,      // <--  absolute y-coordinate of regarded AxB block
  1597.                           int blocktype,      // <--  block type (1-16x16 ... 7-4x4)
  1598.                           short pred_mv[2],   // <--  motion vector predictor in sub-pel units
  1599.                           short mv[2],        // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  1600.                           int search_range,   // <--  1-d search range in pel units
  1601.                           int min_mcost,      // <--  minimum motion cost (cost for center or huge value)
  1602.                           int lambda_factor,  // <--  lagrangian parameter for determining motion cost
  1603.                           int apply_weights)  // <--  perform weight based ME
  1604. {
  1605.   StorablePicture *ref_picture = listX[list+list_offset][ref];
  1606.   short blocksize_y = params->blc_size[blocktype][1];  // vertical block size
  1607.   short blocksize_x = params->blc_size[blocktype][0];  // horizontal block size
  1608.   short blockshape_x = (blocksize_x >> 2);  // horizontal block size in 4-pel units
  1609.   short blockshape_y = (blocksize_y >> 2);  // vertical block size in 4-pel units
  1611.   short mb_x = pic_pix_x - img->opix_x;
  1612.   short mb_y = pic_pix_y - img->opix_y;
  1613.   short pic_pix_x2 = pic_pix_x >> 2;
  1614.   short pic_pix_y2 = pic_pix_y >> 2;
  1615.   short block_x = (mb_x >> 2);
  1616.   short block_y = (mb_y >> 2);
  1618.   int   stopCriterion = medthres[blocktype];
  1619.   int   mapCenter_x = search_range - mv[0];
  1620.   int   mapCenter_y = search_range - mv[1];
  1621.   int   second_mcost = INT_MAX;  
  1622.   int   *prevSad = EPZSDistortion[list + list_offset][blocktype - 1];
  1623.   short *motion=NULL;  
  1624.   MotionVector *p_motion = NULL;
  1626.   short invalid_refs = 0;
  1627.   byte  checkMedian = FALSE;
  1628.   EPZSStructure *searchPatternF = searchPattern;
  1629.   MotionVector center, tmp, tmp2, cand, pred;
  1630.   pred.mv_x = (pic_pix_x << 2) + pred_mv[0];  // predicted position x (in sub-pel units)
  1631.   pred.mv_y = (pic_pix_y << 2) + pred_mv[1];  // predicted position x (in sub-pel units)
  1632.   center.mv_x = (pic_pix_x << (params->EPZSGrid))+ mv[0];
  1633.   center.mv_y = (pic_pix_y << (params->EPZSGrid))+ mv[1];
  1634.   cand.mv_x = center.mv_x << mv_rescale;
  1635.   cand.mv_y = center.mv_y << mv_rescale;
  1636.   tmp.mv_x = mv[0];
  1637.   tmp.mv_y = mv[1];
  1638.   tmp2.mv_x = 0;
  1639.   tmp2.mv_y = 0;
  1641.   computePred = computeUniPred[F_PEL + 3 * apply_weights];
  1643.   EPZSBlkCount ++;
  1644.   if (EPZSBlkCount == 0)
  1645.     EPZSBlkCount ++;
  1647.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  1649.   img_width  = ref_picture->size_x;
  1650.   img_height = ref_picture->size_y;
  1651.   width_pad  = ref_picture->size_x_pad;
  1652.   height_pad = ref_picture->size_y_pad;
  1654.   if (ChromaMEEnable)
  1655.   {
  1656.     ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
  1657.     ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
  1658.     width_pad_cr  = ref_picture->size_x_cr_pad;
  1659.     height_pad_cr = ref_picture->size_y_cr_pad;
  1660.   }
  1662.   pic_pix_x = (pic_pix_x << (params->EPZSGrid));
  1663.   pic_pix_y = (pic_pix_y << (params->EPZSGrid));
  1665.   if (params->EPZSSpatialMem)
  1666.   {
  1667. #if EPZSREF
  1668.     motion   =  EPZSMotion [list + list_offset][ref][blocktype - 1][block_y][pic_pix_x2];
  1669.     p_motion = &EPZS_Motion[list + list_offset][ref][blocktype - 1][block_y][pic_pix_x2];
  1670. #else
  1671.     motion   =  EPZSMotion [list + list_offset][blocktype - 1][block_y][pic_pix_x2];
  1672.     p_motion = &EPZS_Motion[list + list_offset][blocktype - 1][block_y][pic_pix_x2];
  1673. #endif
  1674.   }
  1676.   //===== set function for getting reference picture lines =====
  1677.   ref_access_method = CHECK_RANGE ? FAST_ACCESS : UMV_ACCESS;
  1679.   // Clear EPZSMap
  1680.   // memset(EPZSMap[0],FALSE,searcharray*searcharray);
  1681.   // Check median candidate;
  1682.   //EPZSMap[0][0] = EPZSBlkCount;
  1683.   EPZSMap[search_range][search_range] = EPZSBlkCount;
  1685.   //--- initialize motion cost (cost for motion vector) and check ---
  1686.   min_mcost = MV_COST_SMP (lambda_factor, cand.mv_x, cand.mv_y, pred.mv_x, pred.mv_y);
  1688.   //--- add residual cost to motion cost ---
  1689.   min_mcost += computePred(cur_pic, blocksize_y, blocksize_x,
  1690.     INT_MAX, cand.mv_x + IMG_PAD_SIZE_TIMES4, cand.mv_y + IMG_PAD_SIZE_TIMES4);
  1692.   // Additional threshold for ref>0
  1693.   if ((ref>0 && img->structure == FRAME)
  1694.     && (prevSad[pic_pix_x2] < imin(medthres[blocktype],min_mcost)))
  1695.   {
  1696. #if EPZSREF
  1697.     if (params->EPZSSpatialMem)
  1698. #else
  1699.     if (params->EPZSSpatialMem && ref == 0)
  1700. #endif
  1701.     {
  1702.       motion[0]  = tmp.mv_x;
  1703.       motion[1]  = tmp.mv_y;
  1704.       *p_motion = tmp;
  1705.     }
  1706.     return min_mcost;
  1707.   }
  1709.   //  if ((center.mv_x > search_range) && (center.mv_x < img_width  - search_range - blocksize_x) &&
  1710.   //(center.mv_y > search_range) && (center.mv_y < img_height - search_range - blocksize_y)   )
  1711.   if ( (center.mv_x > search_range) && (center.mv_x < ((img_width  - blocksize_x) << (params->EPZSGrid)) - search_range)
  1712.     && (center.mv_y > search_range) && (center.mv_y < ((img_height - blocksize_y) << (params->EPZSGrid)) - search_range))
  1713.   {
  1714.     ref_access_method = FAST_ACCESS;
  1715.   }
  1716.   else
  1717.   {
  1718.     ref_access_method = UMV_ACCESS;
  1719.   }
  1721.   //! If medthres satisfied, then terminate, otherwise generate Predictors
  1722.   //! Condition could be strengthened by consideration distortion of adjacent partitions.
  1723.   if (min_mcost > stopCriterion)
  1724.   {
  1725.     int mb_available_right   = (img->mb_x < (img_width  >> 4) - 1);
  1726.     int mb_available_below   = (img->mb_y < (img_height >> 4) - 1);
  1728.     int block_available_right;
  1729.     int block_available_below;
  1730.     int prednum = 5;
  1731.     int patternStop = 0, pointNumber = 0, checkPts, nextLast = 0;
  1732.     int totalCheckPts = 0, motionDirection = 0;
  1733.     int conditionEPZS;
  1734.     MotionVector tmv;
  1735.     int pos, mcost;
  1736.     PixelPos block_a, block_b, block_c, block_d;
  1737.     int *mb_size = img->mb_size[IS_LUMA];
  1739.     get4x4Neighbour (currMB, mb_x - 1          , mb_y    , mb_size, &block_a);
  1740.     get4x4Neighbour (currMB, mb_x              , mb_y - 1, mb_size, &block_b);
  1741.     get4x4Neighbour (currMB, mb_x + blocksize_x, mb_y - 1, mb_size, &block_c);
  1742.     get4x4Neighbour (currMB, mb_x - 1          , mb_y - 1, mb_size, &block_d);
  1744.     if (mb_y > 0)
  1745.     {
  1746.       if (mb_x < 8)   // first column of 8x8 blocks
  1747.       {
  1748.         if (mb_y == 8)
  1749.         {
  1750.           block_available_right = (blocksize_x != MB_BLOCK_SIZE) || mb_available_right;
  1751.           if (blocksize_x == MB_BLOCK_SIZE)
  1752.             block_c.available = 0;
  1753.         }
  1754.         else
  1755.         {
  1756.           block_available_right = (mb_x + blocksize_x != 8) || mb_available_right;
  1757.           if (mb_x + blocksize_x == 8)
  1758.             block_c.available = 0;
  1759.         }
  1760.       }
  1761.       else
  1762.       {
  1763.         block_available_right = (mb_x + blocksize_x != MB_BLOCK_SIZE) || mb_available_right;
  1764.         if (mb_x + blocksize_x == MB_BLOCK_SIZE)
  1765.           block_c.available = 0;
  1766.       }
  1767.     }
  1768.     else
  1769.     {
  1770.       block_available_right = (mb_x + blocksize_x != MB_BLOCK_SIZE) || mb_available_right;
  1771.     }
  1772.     block_available_below = (mb_y + blocksize_y != MB_BLOCK_SIZE) || (mb_available_below);
  1774.     stopCriterion = EPZSDetermineStopCriterion(prevSad, &block_a, &block_b, &block_c, pic_pix_x2, blocktype, blockshape_x);
  1776.     //! Add Spatial Predictors in predictor list.
  1777.     //! Scheme adds zero, left, top-left, top, top-right. Note that top-left adds very little
  1778.     //! in terms of performance and could be removed with little penalty if any.
  1779.     invalid_refs = EPZSSpatialPredictors (block_a, block_b, block_c, block_d,
  1780.       list, list_offset, ref, refPic[list], tmp_mv[list], predictor);
  1781.     if (params->EPZSSpatialMem)
  1782.       EPZSSpatialMemPredictors (list + list_offset, ref, blocktype - 1, pic_pix_x2,
  1783.       blockshape_x, blockshape_y, block_y, &prednum, img_width>>2, predictor);
  1785.     // Temporal predictors
  1786.     if (params->EPZSTemporal)
  1787.       EPZSTemporalPredictors (list, list_offset, ref, pic_pix_x2, pic_pix_y2, predictor, &prednum,
  1788.       block_a.available, block_b.available, block_available_right,
  1789.       block_available_below, blockshape_x, blockshape_y, stopCriterion, min_mcost);
  1791.     //! Window Size Based Predictors
  1792.     //! Basically replaces a Hierarchical ME concept and helps escaping local minima, or
  1793.     //! determining large motion variations.
  1794.     //! Following predictors can be adjusted further (i.e. removed, conditioned etc)
  1795.     //! based on distortion, correlation of adjacent MVs, complexity etc. These predictors
  1796.     //! and their conditioning could also be moved after all other predictors have been
  1797.     //! tested. Adaptation could also be based on type of material and coding mode (i.e.
  1798.     //! field/frame coding,MBAFF etc considering the higher dependency with opposite parity field
  1799.     //conditionEPZS = ((min_mcost > stopCriterion)
  1800.     // && (params->EPZSFixed > 1 || (params->EPZSFixed && img->type == P_SLICE)));
  1801.     //conditionEPZS = ((ref == 0) && (blocktype < 5) && (min_mcost > stopCriterion)
  1802.     //&& (params->EPZSFixed > 1 || (params->EPZSFixed && img->type == P_SLICE)));
  1803.     conditionEPZS = ((min_mcost > stopCriterion) && ((ref < 2 && blocktype < 5)
  1804.       || ((img->structure!=FRAME || list_offset) && ref < 3))
  1805.       && (params->EPZSFixed > 1 || (params->EPZSFixed && img->type == P_SLICE)));
  1807.     if (conditionEPZS)
  1808.       EPZSWindowPredictors (mv, predictor, &prednum,
  1809.       (blocktype < 5) && (invalid_refs > 2) && (ref < 1 + (img->structure!=FRAME || list_offset)));
  1811.     //! Blocktype/Reference dependent predictors.
  1812.     //! Since already mvs for other blocktypes/references have been computed, we can reuse
  1813.     //! them in order to easier determine the optimal point. Use of predictors could depend
  1814.     //! on cost,
  1815.     //conditionEPZS = (ref == 0 || (ref > 0 && min_mcost > stopCriterion) || img->structure != FRAME || list_offset);
  1816.     conditionEPZS = (ref == 0 || (ref > 0 && min_mcost > stopCriterion));
  1817.     // above seems to result in memory leak issues which need to be resolved
  1819.     if (conditionEPZS && img->current_mb_nr != 0 && params->EPZSBlockType)
  1820.       EPZSBlockTypePredictors (block_x, block_y, blocktype, ref, list, predictor, &prednum);
  1822.     //! Check all predictors
  1823.     for (pos = 0; pos < prednum; pos++)
  1824.     {
  1825.       tmv = predictor->point[pos].motion;
  1826.       //if (((iabs (tmv.mv_x - mv[0]) > search_range || iabs (tmv.mv_y - mv[1]) > search_range)) && (tmv.mv_x || tmv.mv_y))
  1827.       if (iabs (tmv.mv_x - mv[0]) > search_range || iabs (tmv.mv_y - mv[1]) > search_range)
  1828.         continue;
  1830.       if ((iabs (tmv.mv_x - mv[0]) <= search_range) && (iabs (tmv.mv_y - mv[1]) <= search_range))
  1831.       {
  1832.         if (EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] == EPZSBlkCount)
  1833.           continue;
  1834.         else
  1835.           EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] = EPZSBlkCount;
  1836.       }
  1838.       cand.mv_x = (pic_pix_x + tmv.mv_x)<<mv_rescale;
  1839.       cand.mv_y = (pic_pix_y + tmv.mv_y)<<mv_rescale;
  1841.       //--- set motion cost (cost for motion vector) and check ---
  1842.       mcost = MV_COST_SMP (lambda_factor, cand.mv_x, cand.mv_y, pred.mv_x, pred.mv_y);
  1844.       if (mcost >= second_mcost) continue;
  1846.       //ref_access_method = CHECK_RANGE ? FAST_ACCESS : UMV_ACCESS;
  1848.       mcost += computePred(cur_pic, blocksize_y,blocksize_x,
  1849.         second_mcost - mcost, cand.mv_x + IMG_PAD_SIZE_TIMES4,cand.mv_y + IMG_PAD_SIZE_TIMES4);
  1851.       //--- check if motion cost is less than minimum cost ---
  1852.       if (mcost < min_mcost)
  1853.       {
  1854.         tmp2 = tmp;
  1855.         tmp  = tmv;
  1856.         second_mcost = min_mcost;
  1857.         min_mcost = mcost;
  1858.         checkMedian = TRUE;
  1859.       }
  1860.       //else if (mcost < second_mcost && (tmp.mv_x != tmv.mv_x || tmp.mv_y != tmv.mv_y))
  1861.       else if (mcost < second_mcost)
  1862.       {
  1863.         tmp2 = tmv;
  1864.         second_mcost = mcost;
  1865.         checkMedian = TRUE;
  1866.       }
  1867.     }
  1869.     //! Refine using EPZS pattern if needed
  1870.     //! Note that we are using a conservative threshold method. Threshold
  1871.     //! could be tested after checking only a certain number of predictors
  1872.     //! instead of the full set. Code could be easily modified for this task.
  1873.     if (min_mcost > stopCriterion)
  1874.     {
  1875.       //! Adapt pattern based on different conditions.
  1876.       if (params->EPZSPattern != 0)
  1877.       {
  1878.         if ((min_mcost < stopCriterion + ((3 * medthres[blocktype]) >> 1)))
  1879.         {
  1880.           if ((tmp.mv_x == 0 && tmp.mv_y == 0)
  1881.             || (iabs (tmp.mv_x - mv[0]) < (2<<(2-mv_rescale)) && iabs (tmp.mv_y - mv[1]) < (2<<(2-mv_rescale))))
  1882.             searchPatternF = sdiamond;
  1883.           else
  1884.             searchPatternF = square;
  1885.         }
  1886.         else if (blocktype > 5 || (ref > 0 && blocktype != 1))
  1887.           searchPatternF = square;
  1888.         else
  1889.           searchPatternF = searchPattern;
  1890.       }
  1892.       totalCheckPts = searchPatternF->searchPoints;
  1894.       //! center on best predictor
  1895.       center = tmp;
  1896.       while(1)
  1897.       {
  1898.         do
  1899.         {
  1900.           checkPts = totalCheckPts;
  1901.           do
  1902.           {
  1903.             tmv.mv_x = center.mv_x + searchPatternF->point[pointNumber].motion.mv_x;
  1904.             tmv.mv_y = center.mv_y + searchPatternF->point[pointNumber].motion.mv_y;
  1905.             cand.mv_x = (pic_pix_x + tmv.mv_x)<<mv_rescale;
  1906.             cand.mv_y = (pic_pix_y + tmv.mv_y)<<mv_rescale;
  1908.             if ((iabs (tmv.mv_x - mv[0]) <= search_range) && (iabs (tmv.mv_y - mv[1]) <= search_range))
  1909.             {
  1910.               if (EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] != EPZSBlkCount)
  1911.                 EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] = EPZSBlkCount;
  1912.               else
  1913.               {
  1914.                 pointNumber += 1;
  1915.                 if (pointNumber >= searchPatternF->searchPoints)
  1916.                   pointNumber -= searchPatternF->searchPoints;
  1917.                 checkPts -= 1;
  1918.                 continue;
  1919.               }
  1920.               mcost = MV_COST_SMP (lambda_factor, cand.mv_x, cand.mv_y, pred.mv_x, pred.mv_y);
  1922.               if (mcost < min_mcost)
  1923.               {
  1924.                 ref_access_method = CHECK_RANGE ? FAST_ACCESS : UMV_ACCESS;
  1926.                 mcost += computePred(cur_pic, blocksize_y,blocksize_x,
  1927.                   min_mcost - mcost, cand.mv_x + IMG_PAD_SIZE_TIMES4, cand.mv_y + IMG_PAD_SIZE_TIMES4);
  1929.                 if (mcost < min_mcost)
  1930.                 {
  1931.                   tmp = tmv;
  1932.                   min_mcost = mcost;
  1933.                   motionDirection = pointNumber;
  1934.                 }
  1935.               }
  1936.             }
  1937.             pointNumber += 1;
  1938.             if (pointNumber >= searchPatternF->searchPoints)
  1939.               pointNumber -= searchPatternF->searchPoints;
  1940.             checkPts -= 1;
  1941.           }
  1942.           while (checkPts > 0);
  1944.           if (nextLast || ((tmp.mv_x == center.mv_x) && (tmp.mv_y == center.mv_y)))
  1945.           {
  1946.             patternStop     = searchPatternF->stopSearch;
  1947.             searchPatternF  = searchPatternF->nextpattern;
  1948.             totalCheckPts   = searchPatternF->searchPoints;
  1949.             nextLast        = searchPatternF->nextLast;
  1950.             motionDirection = 0;
  1951.             pointNumber = 0;
  1952.           }
  1953.           else
  1954.           {
  1955.             totalCheckPts = searchPatternF->point[motionDirection].next_points;
  1956.             pointNumber = searchPatternF->point[motionDirection].start_nmbr;
  1957.             center = tmp;
  1958.           }
  1959.         }
  1960.         while (patternStop != 1);
  1962.         if ((ref>0) && (img->structure == FRAME) && (( 4 * prevSad[pic_pix_x2] < min_mcost) ||
  1963.           ((3 * prevSad[pic_pix_x2] < min_mcost) && (prevSad[pic_pix_x2] <= stopCriterion))))
  1964.         {
  1965.           mv[0] = tmp.mv_x;
  1966.           mv[1] = tmp.mv_y;
  1967. #if EPZSREF
  1968.           if (params->EPZSSpatialMem)
  1969. #else
  1970.           if (params->EPZSSpatialMem && ref == 0)
  1971. #endif
  1972.           {
  1973.             motion[0] = tmp.mv_x;
  1974.             motion[1] = tmp.mv_y;
  1975.             *p_motion  = tmp;
  1976.           }
  1978.           return min_mcost;
  1979.         }
  1981.         //! Check Second best predictor with EPZS pattern
  1982.         conditionEPZS = (checkMedian == TRUE)
  1983.           && ((img->type == P_SLICE) || (blocktype < 5))
  1984.           && (min_mcost > stopCriterion) && (params->EPZSDual > 0);
  1986.         if (!conditionEPZS) break;
  1988.         pointNumber = 0;
  1989.         patternStop = 0;
  1990.         motionDirection = 0;
  1991.         nextLast = 0;
  1993.         if ((tmp.mv_x == 0 && tmp.mv_y == 0)  || (tmp.mv_x == mv[0] && tmp.mv_y == mv[1]))
  1994.         {
  1995.           if (iabs (tmp.mv_x - mv[0]) < (2<<(2-mv_rescale)) && iabs (tmp.mv_y - mv[1]) < (2<<(2-mv_rescale)))
  1996.             searchPatternF = sdiamond;
  1997.           else
  1998.             searchPatternF = square;
  1999.         }
  2000.         else
  2001.           searchPatternF = searchPatternD;
  2002.         totalCheckPts = searchPatternF->searchPoints;
  2004.         //! Second best. Note that following code is identical as for best predictor.
  2005.         center = tmp2;
  2006.         checkMedian = FALSE;
  2007.       }
  2008.     }
  2009.   }
  2011.   if ((ref==0) || (prevSad[pic_pix_x2] > min_mcost))
  2012.     prevSad[pic_pix_x2] = min_mcost;
  2013. #if EPZSREF
  2014.   if (params->EPZSSpatialMem)
  2015. #else
  2016.   if (params->EPZSSpatialMem && ref == 0)
  2017. #endif
  2018.   {
  2019.     motion[0] = tmp.mv_x;
  2020.     motion[1] = tmp.mv_y;
  2021.     *p_motion = tmp;
  2022.     //printf("value %d %d %d %dn", p_motion->mv_x, p_motion->mv_y, EPZS_Motion[list + list_offset][ref][0][0][0].mv_x, EPZS_Motion[list + list_offset][ref][0][0][0].mv_y);
  2023.     //printf("xxxxx %d %d %d %dn", p_motion->mv_x, p_motion->mv_y, EPZS_Motion[list + list_offset][ref][blocktype - 1][block_y][pic_pix_x2].mv_x, EPZS_Motion[list + list_offset][ref][blocktype - 1][block_y][pic_pix_x2].mv_y);
  2024.   }
  2026.   mv[0] = tmp.mv_x;
  2027.   mv[1] = tmp.mv_y;
  2028.   return min_mcost;
  2029. }
  2032. /*!
  2033. ***********************************************************************
  2034. * brief
  2035. *    FAST Motion Estimation using EPZS
  2036. *    AMT/HYC
  2037. ***********************************************************************
  2038. */
  2039. int                                                //  ==> minimum motion cost after search
  2040. EPZSBiPredBlockMotionSearch (Macroblock *currMB,   // <--  Current Macroblock
  2041.                              imgpel * cur_pic,     // <--  original pixel values for the AxB block
  2042.                              short  ref,           // <--  reference picture
  2043.                              int    list,          // <--  reference list
  2044.                              int    list_offset,   // <--  offset for Mbaff
  2045.                              char  ***refPic,      // <--  reference array
  2046.                              short  ****tmp_mv,    // <--  mv array
  2047.                              int    pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  2048.                              int    pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  2049.                              int    blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  2050.                              short  pred_mv1[2],   // <--  motion vector predictor in sub-pel units
  2051.                              short  pred_mv2[2],   // <--  motion vector predictor in sub-pel units
  2052.                              short  mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  2053.                              short  static_mv[2],       // <--> in: search center (x|y) 
  2054.                              int    search_range,  // <--  1-d search range in pel units
  2055.                              int    min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  2056.                              int    iteration_no,  // <--  bi pred iteration number
  2057.                              int    lambda_factor, // <--  lagrangian parameter for determining motion cost
  2058.                              int    apply_weights  // <--  perform weight based ME
  2059.                              )
  2060. {
  2061.   StorablePicture *ref_picture1 = listX[list       + list_offset][ref];
  2062.   StorablePicture *ref_picture2 = listX[(list ^ 1) + list_offset][0];
  2063.   short blocksize_y  = params->blc_size[blocktype][1];        // vertical block size
  2064.   short blocksize_x  = params->blc_size[blocktype][0];        // horizontal block size
  2065.   short blockshape_x = (blocksize_x >> 2);  // horizontal block size in 4-pel units
  2066. //  short blockshape_y = (blocksize_y >> 2);  // vertical block size in 4-pel units
  2068.   short mb_x = pic_pix_x - img->opix_x;
  2069.   short mb_y = pic_pix_y - img->opix_y;
  2070.   short pic_pix_x2 = pic_pix_x >> 2;
  2071.   //short pic_pix_y2 = pic_pix_y >> 2;
  2073.   int   stopCriterion = medthres[blocktype];
  2074.   int   mapCenter_x = search_range - mv[0];
  2075.   int   mapCenter_y = search_range - mv[1];
  2076.   int   second_mcost = INT_MAX;
  2077.   int   *prevSad = EPZSBiDistortion[list + list_offset][blocktype - 1];
  2078.   short invalid_refs = 0;
  2079.   byte  checkMedian = FALSE;
  2080.   EPZSStructure *searchPatternF = searchPattern;
  2082.   static MotionVector center1, center2, tmp, tmp2, cand, cand1, cand2, pred1, pred2;
  2083.   pred1.mv_x   = (pic_pix_x << 2) + pred_mv1[0]; // predicted position x (in sub-pel units)
  2084.   pred1.mv_y   = (pic_pix_y << 2) + pred_mv1[1]; // predicted position y (in sub-pel units)
  2085.   pred2.mv_x   = (pic_pix_x << 2) + pred_mv2[0]; // predicted position x (in sub-pel units)
  2086.   pred2.mv_y   = (pic_pix_y << 2) + pred_mv2[1]; // predicted position y (in sub-pel units)
  2087.   center1.mv_x = (pic_pix_x << (params->EPZSGrid))+ mv[0];
  2088.   center1.mv_y = (pic_pix_y << (params->EPZSGrid))+ mv[1];
  2089.   center2.mv_x = (pic_pix_x << (params->EPZSGrid))+ static_mv[0];
  2090.   center2.mv_y = (pic_pix_y << (params->EPZSGrid))+ static_mv[1];
  2091.   cand1.mv_x   = center1.mv_x << mv_rescale;
  2092.   cand1.mv_y   = center1.mv_y << mv_rescale;
  2093.   cand2.mv_x   = center2.mv_x << mv_rescale;
  2094.   cand2.mv_y   = center2.mv_y << mv_rescale;
  2097.   tmp.mv_x = mv[0];
  2098.   tmp.mv_y = mv[1];
  2099.   tmp2.mv_x = 0;
  2100.   tmp2.mv_y = 0;
  2101.   EPZSBlkCount ++;
  2102.   if (EPZSBlkCount == 0)
  2103.     EPZSBlkCount ++;
  2105.   ref_pic1_sub.luma = ref_picture1->p_curr_img_sub;
  2106.   ref_pic2_sub.luma = ref_picture2->p_curr_img_sub;
  2108.   img_width  = ref_picture1->size_x;
  2109.   img_height = ref_picture1->size_y;
  2110.   width_pad  = ref_picture1->size_x_pad;
  2111.   height_pad = ref_picture1->size_y_pad;
  2113.   if (apply_weights)
  2114.   {
  2115.     computeBiPred = computeBiPred2[F_PEL];
  2116.   }
  2117.   else
  2118.   {
  2119.     computeBiPred = computeBiPred1[F_PEL];
  2120.   }
  2122.   if ( ChromaMEEnable )
  2123.   {
  2124.     ref_pic1_sub.crcb[0] = ref_picture1->imgUV_sub[0];
  2125.     ref_pic1_sub.crcb[1] = ref_picture1->imgUV_sub[1];
  2126.     ref_pic2_sub.crcb[0] = ref_picture2->imgUV_sub[0];
  2127.     ref_pic2_sub.crcb[1] = ref_picture2->imgUV_sub[1];
  2128.     width_pad_cr  = ref_picture1->size_x_cr_pad;
  2129.     height_pad_cr = ref_picture1->size_y_cr_pad;
  2130.   }
  2132.   pic_pix_x = (pic_pix_x << (params->EPZSGrid));
  2133.   pic_pix_y = (pic_pix_y << (params->EPZSGrid));
  2135.   //===== set function for getting reference picture lines from reference 1 =====
  2136.   if ((cand1.mv_x >= 0) && (cand1.mv_x < img_width  - blocksize_x) &&(cand.mv_y >= 0) && (cand1.mv_y < img_height - blocksize_y))
  2137.   {
  2138.     bipred1_access_method = FAST_ACCESS;
  2139.   }
  2140.   else
  2141.   {
  2142.     bipred1_access_method = UMV_ACCESS;
  2143.   }
  2145.   //===== set function for getting reference picture lines from reference 2 =====
  2146.   if ((cand2.mv_x >= 0) && (cand2.mv_x < img_width  - blocksize_x) &&(cand.mv_y >= 0) && (cand2.mv_y < img_height - blocksize_y))
  2147.   {
  2148.     bipred2_access_method = FAST_ACCESS;
  2149.   }
  2150.   else
  2151.   {
  2152.     bipred2_access_method = UMV_ACCESS;
  2153.   }
  2155.   // Clear EPZSMap
  2156.   //memset(EPZSMap[0],FALSE,searcharray*searcharray);
  2157.   // Check median candidate;
  2158.   //EPZSMap[0][0] = EPZSBlkCount;
  2159.   EPZSMap[search_range][search_range] = EPZSBlkCount;
  2161.   //--- initialize motion cost (cost for motion vector) and check ---
  2162.   min_mcost  = MV_COST_SMP (lambda_factor, cand1.mv_x, cand1.mv_y, pred1.mv_x, pred1.mv_y);
  2163.   min_mcost += MV_COST_SMP (lambda_factor, cand2.mv_x, cand2.mv_y, pred2.mv_x, pred2.mv_y);
  2165.   //--- add residual cost to motion cost ---
  2166.   min_mcost += computeBiPred(cur_pic, blocksize_y, blocksize_x, INT_MAX,
  2167.     cand1.mv_x + IMG_PAD_SIZE_TIMES4,
  2168.     cand1.mv_y + IMG_PAD_SIZE_TIMES4,
  2169.     cand2.mv_x + IMG_PAD_SIZE_TIMES4,
  2170.     cand2.mv_y + IMG_PAD_SIZE_TIMES4);
  2172.   //! If medthres satisfied, then terminate, otherwise generate Predictors
  2173.   if (min_mcost > stopCriterion)
  2174.   {
  2175.     int mb_available_right   = (img->mb_x < (img_width  >> 4) - 1);
  2176.     int mb_available_below   = (img->mb_y < (img_height >> 4) - 1);
  2178.     int block_available_right;
  2179.     int block_available_below;
  2180.     int prednum = 5;
  2181.     int patternStop = 0, pointNumber = 0, checkPts, nextLast = 0;
  2182.     int totalCheckPts = 0, motionDirection = 0;
  2183.     int conditionEPZS;
  2184.     MotionVector tmv;
  2185.     int pos, mcost;
  2186.     PixelPos block_a, block_b, block_c, block_d;
  2187.     int *mb_size = img->mb_size[IS_LUMA];
  2189.     get4x4Neighbour (currMB, mb_x - 1          , mb_y    , mb_size, &block_a);
  2190.     get4x4Neighbour (currMB, mb_x              , mb_y - 1, mb_size, &block_b);
  2191.     get4x4Neighbour (currMB, mb_x + blocksize_x, mb_y - 1, mb_size, &block_c);
  2192.     get4x4Neighbour (currMB, mb_x - 1          , mb_y - 1, mb_size, &block_d);
  2194.     if (mb_y > 0)
  2195.     {
  2196.       if (mb_x < 8)   // first column of 8x8 blocks
  2197.       {
  2198.         if (mb_y == 8)
  2199.         {
  2200.           block_available_right = (blocksize_x != MB_BLOCK_SIZE) || mb_available_right;
  2201.           if (blocksize_x == MB_BLOCK_SIZE)
  2202.             block_c.available = 0;
  2203.         }
  2204.         else
  2205.         {
  2206.           block_available_right = (mb_x + blocksize_x != 8) || mb_available_right;
  2207.           if (mb_x + blocksize_x == 8)
  2208.             block_c.available = 0;
  2209.         }
  2210.       }
  2211.       else
  2212.       {
  2213.         block_available_right = (mb_x + blocksize_x != MB_BLOCK_SIZE) || mb_available_right;
  2214.         if (mb_x + blocksize_x == MB_BLOCK_SIZE)
  2215.           block_c.available = 0;
  2216.       }
  2217.     }
  2218.     else
  2219.     {
  2220.       block_available_right = (mb_x + blocksize_x != MB_BLOCK_SIZE) || mb_available_right;
  2221.     }
  2222.     block_available_below = (mb_y + blocksize_y != MB_BLOCK_SIZE) || (mb_available_below);
  2224.     stopCriterion = EPZSDetermineStopCriterion(prevSad, &block_a, &block_b, &block_c, pic_pix_x2, blocktype, blockshape_x);
  2225.     // stopCriterion = (11 * medthres[blocktype]) >> 3;
  2228.     //! Add Spatial Predictors in predictor list.
  2229.     //! Scheme adds zero, left, top-left, top, top-right. Note that top-left adds very little
  2230.     //! in terms of performance and could be removed with little penalty if any.
  2231.     invalid_refs = EPZSSpatialPredictors (block_a, block_b, block_c, block_d,
  2232.       list, list_offset, ref, refPic[list], tmp_mv[list], predictor);
  2234.     //! Check all predictors
  2235.     for (pos = 0; pos < prednum; pos++)
  2236.     {
  2237.       tmv = predictor->point[pos].motion;
  2238.       //if ((iabs (tmv.mv_x - mv[0]) > search_range || iabs (tmv.mv_y - mv[1]) > search_range) && (tmv.mv_x || tmv.mv_y))
  2239.       if (iabs (tmv.mv_x - mv[0]) > search_range || iabs (tmv.mv_y - mv[1]) > search_range)
  2240.         continue;
  2242.       if ((iabs (tmv.mv_x - mv[0]) <= search_range) && (iabs (tmv.mv_y - mv[1]) <= search_range))
  2243.       {
  2244.         if (EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] == EPZSBlkCount)
  2245.           continue;
  2246.         else
  2247.           EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] = EPZSBlkCount;
  2248.       }
  2250.       cand.mv_x = (pic_pix_x + tmv.mv_x)<<mv_rescale;
  2251.       cand.mv_y = (pic_pix_y + tmv.mv_y)<<mv_rescale;
  2253.       //--- set motion cost (cost for motion vector) and check ---
  2254.       mcost  = MV_COST_SMP (lambda_factor, cand.mv_x, cand.mv_y, pred1.mv_x, pred1.mv_y);
  2255.       mcost += MV_COST_SMP (lambda_factor, cand2.mv_x, cand2.mv_y, pred2.mv_x, pred2.mv_y);
  2257.       if (mcost >= second_mcost) continue;
  2259.       mcost += computeBiPred(cur_pic, blocksize_y, blocksize_x, 
  2260.         second_mcost - mcost,
  2261.         cand.mv_x + IMG_PAD_SIZE_TIMES4 , cand.mv_y + IMG_PAD_SIZE_TIMES4,
  2262.         cand2.mv_x + IMG_PAD_SIZE_TIMES4, cand2.mv_y + IMG_PAD_SIZE_TIMES4);
  2264.       //--- check if motion cost is less than minimum cost ---
  2265.       if (mcost < min_mcost)
  2266.       {
  2267.         tmp2 = tmp;
  2268.         tmp  = tmv;
  2269.         second_mcost = min_mcost;
  2270.         min_mcost = mcost;
  2271.         checkMedian = TRUE;
  2272.       }
  2273.       //else if (mcost < second_mcost && (tmp.mv_x != tmv.mv_x || tmp.mv_y != tmv.mv_y))
  2274.       else if (mcost < second_mcost)
  2275.       {
  2276.         tmp2 = tmv;
  2277.         second_mcost = mcost;
  2278.         checkMedian = TRUE;
  2279.       }
  2280.     }
  2282.     //! Refine using EPZS pattern if needed
  2283.     //! Note that we are using a conservative threshold method. Threshold
  2284.     //! could be tested after checking only a certain number of predictors
  2285.     //! instead of the full set. Code could be easily modified for this task.
  2286.     if (min_mcost > stopCriterion)
  2287.     {
  2288.       //! Adapt pattern based on different conditions.
  2289.       if (params->EPZSPattern != 0)
  2290.       {
  2291.         if ((min_mcost < stopCriterion + ((3 * medthres[blocktype]) >> 1)))
  2292.         {
  2293.           if ((tmp.mv_x == 0 && tmp.mv_y == 0)
  2294.             || (iabs (tmp.mv_x - mv[0]) < (2<<(2-mv_rescale)) && iabs (tmp.mv_y - mv[1]) < (2<<(2-mv_rescale))))
  2295.             searchPatternF = sdiamond;
  2296.           else
  2297.             searchPatternF = square;
  2298.         }
  2299.         else if (blocktype > 5 || (ref > 0 && blocktype != 1))
  2300.           searchPatternF = square;
  2301.         else
  2302.           searchPatternF = searchPattern;
  2303.       }
  2305.       totalCheckPts = searchPatternF->searchPoints;
  2307.       //! center on best predictor
  2308.       center1 = tmp;
  2309.       while (1)
  2310.       {
  2311.         do
  2312.         {
  2313.           checkPts = totalCheckPts;
  2314.           do
  2315.           {
  2316.             tmv.mv_x = center1.mv_x + searchPatternF->point[pointNumber].motion.mv_x;
  2317.             tmv.mv_y = center1.mv_y + searchPatternF->point[pointNumber].motion.mv_y;
  2318.             cand.mv_x = (pic_pix_x + tmv.mv_x)<<mv_rescale;
  2319.             cand.mv_y = (pic_pix_y + tmv.mv_y)<<mv_rescale;
  2321.             if ((iabs (tmv.mv_x - mv[0]) <= search_range) && (iabs (tmv.mv_y - mv[1]) <= search_range))
  2322.             {
  2323.               if (EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] != EPZSBlkCount)
  2324.                 EPZSMap[mapCenter_y + tmv.mv_y][mapCenter_x + tmv.mv_x] = EPZSBlkCount;
  2325.               else
  2326.               {
  2327.                 pointNumber += 1;
  2328.                 if (pointNumber >= searchPatternF->searchPoints)
  2329.                   pointNumber -= searchPatternF->searchPoints;
  2330.                 checkPts -= 1;
  2331.                 continue;
  2332.               }
  2334.               mcost  = MV_COST_SMP (lambda_factor, cand.mv_x, cand.mv_y, pred2.mv_x, pred2.mv_y);
  2335.               mcost += MV_COST_SMP (lambda_factor, cand2.mv_x, cand2.mv_y, pred2.mv_x, pred2.mv_y);              
  2337.               if (mcost < min_mcost)
  2338.               {
  2339.                 mcost += computeBiPred(cur_pic,
  2340.                   blocksize_y, blocksize_x, min_mcost - mcost,
  2341.                   cand.mv_x + IMG_PAD_SIZE_TIMES4, cand.mv_y + IMG_PAD_SIZE_TIMES4,
  2342.                   cand2.mv_x + IMG_PAD_SIZE_TIMES4,
  2343.                   cand2.mv_y + IMG_PAD_SIZE_TIMES4);
  2345.                 if (mcost < min_mcost)
  2346.                 {
  2347.                   tmp = tmv;
  2348.                   min_mcost = mcost;
  2349.                   motionDirection = pointNumber;
  2350.                 }
  2351.               }
  2352.             }
  2353.             pointNumber += 1;
  2354.             if (pointNumber >= searchPatternF->searchPoints)
  2355.               pointNumber -= searchPatternF->searchPoints;
  2356.             checkPts -= 1;
  2357.           }
  2358.           while (checkPts > 0);
  2360.           if (nextLast || ((tmp.mv_x == center1.mv_x) && (tmp.mv_y == center1.mv_y)))
  2361.           {
  2362.             patternStop     = searchPatternF->stopSearch;
  2363.             searchPatternF  = searchPatternF->nextpattern;
  2364.             totalCheckPts   = searchPatternF->searchPoints;
  2365.             nextLast        = searchPatternF->nextLast;
  2366.             motionDirection = 0;
  2367.             pointNumber = 0;
  2368.           }
  2369.           else
  2370.           {
  2371.             totalCheckPts = searchPatternF->point[motionDirection].next_points;
  2372.             pointNumber = searchPatternF->point[motionDirection].start_nmbr;
  2373.             center1 = tmp;
  2374.           }
  2375.         }
  2376.         while (patternStop != 1);
  2378.         //! Check Second best predictor with EPZS pattern
  2379.         conditionEPZS = (checkMedian == TRUE)
  2380.           && (blocktype < 5) 
  2381.           && (min_mcost > stopCriterion) && (params->EPZSDual > 0);
  2383.         if (!conditionEPZS) break;
  2385.         pointNumber = 0;
  2386.         patternStop = 0;
  2387.         motionDirection = 0;
  2388.         nextLast = 0;
  2390.         if ((tmp.mv_x == 0 && tmp.mv_y == 0) || (tmp.mv_x == mv[0] && tmp.mv_y == mv[1]))
  2391.         {
  2392.           if (iabs (tmp.mv_x - mv[0]) < (2<<(2-mv_rescale)) && iabs (tmp.mv_y - mv[1]) < (2<<(2-mv_rescale)))
  2393.             searchPatternF = sdiamond;
  2394.           else
  2395.             searchPatternF = square;
  2396.         }
  2397.         else
  2398.           searchPatternF = searchPatternD;
  2399.         totalCheckPts = searchPatternF->searchPoints;
  2401.         //! Second best. Note that following code is identical as for best predictor.
  2402.         center1 = tmp2;
  2403.         checkMedian = FALSE;
  2404.       }
  2405.     }
  2406.   }
  2407.   if (iteration_no == 0)
  2408.   {
  2409.     prevSad[pic_pix_x2] = min_mcost;
  2410.   }
  2412.   mv[0] = tmp.mv_x;
  2413.   mv[1] = tmp.mv_y;
  2415.   return min_mcost;
  2416. }
  2419. /*!
  2420. ***********************************************************************
  2421. * brief
  2422. *    Report function for EPZS Fast ME
  2423. *    AMT/HYC
  2424. ***********************************************************************
  2425. */
  2426. void EPZSOutputStats (InputParameters *params, FILE * stat, short stats_file)
  2427. {
  2428.   if (stats_file == 1)
  2429.   {
  2430.     fprintf (stat, " EPZS Pattern                 : %sn",c_EPZSPattern[params->EPZSPattern]);
  2431.     fprintf (stat, " EPZS Dual Pattern            : %sn",c_EPZSDualPattern[params->EPZSDual]);
  2432.     fprintf (stat, " EPZS Fixed Predictors        : %sn",c_EPZSFixed[params->EPZSFixed]);
  2433.     fprintf (stat, " EPZS Temporal Predictors     : %sn",c_EPZSOther[params->EPZSTemporal]);
  2434.     fprintf (stat, " EPZS Spatial Predictors      : %sn",c_EPZSOther[params->EPZSSpatialMem]);
  2435.     fprintf (stat, " EPZS Thresholds (16x16)      : (%d %d %d)n",medthres[1], minthres[1], maxthres[1]);
  2436.     fprintf (stat, " EPZS Subpel ME               : %sn",c_EPZSOther[params->EPZSSubPelME]);
  2437.     fprintf (stat, " EPZS Subpel ME BiPred        : %sn",c_EPZSOther[params->EPZSSubPelMEBiPred]);
  2438.   }
  2439.   else
  2440.   {
  2441.     fprintf (stat, " EPZS Pattern                      : %sn",c_EPZSPattern[params->EPZSPattern]);
  2442.     fprintf (stat, " EPZS Dual Pattern                 : %sn",c_EPZSDualPattern[params->EPZSDual]);
  2443.     fprintf (stat, " EPZS Fixed Predictors             : %sn",c_EPZSFixed[params->EPZSFixed]);
  2444.     fprintf (stat, " EPZS Temporal Predictors          : %sn",c_EPZSOther[params->EPZSTemporal]);
  2445.     fprintf (stat, " EPZS Spatial Predictors           : %sn",c_EPZSOther[params->EPZSSpatialMem]);
  2446.     fprintf (stat, " EPZS Thresholds (16x16)           : (%d %d %d)n",medthres[1], minthres[1], maxthres[1]);
  2447.     fprintf (stat, " EPZS Subpel ME                    : %sn",c_EPZSOther[params->EPZSSubPelME]);
  2448.     fprintf (stat, " EPZS Subpel ME BiPred             : %sn",c_EPZSOther[params->EPZSSubPelMEBiPred]);
  2449.   }
  2450. }
  2453. /*!
  2454.  ***********************************************************************
  2455.  * brief
  2456.  *    Fast sub pixel block motion search to support EPZS
  2457.  ***********************************************************************
  2458.  */
  2459. int                                                   //  ==> minimum motion cost after search
  2460. EPZSSubPelBlockMotionSearch (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  2461.                              short     ref,           // <--  reference frame (0... or -1 (backward))
  2462.                              int       list,          // <--  reference picture list
  2463.                              int       list_offset,   // <--  MBAFF list offset
  2464.                              int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  2465.                              int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  2466.                              int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  2467.                              short     pred_mv[2],    // <--  motion vector predictor in sub-pel units
  2468.                              short     mv[2],         // <--> in: search center / out: motion vector - in pel units
  2469.                              int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  2470.                              int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  2471.                              int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  2472.                              int*      lambda,        // <--  lagrangian parameter for determining motion cost
  2473.                              int       apply_weights  // <--  use weight based ME
  2474.                              )
  2475. {
  2477.   int   pos, best_pos = 0, second_pos = 0, mcost;
  2478.   int   second_mcost = INT_MAX;
  2480.   int   cand_mv_x, cand_mv_y;
  2482.   int   blocksize_x     = params->blc_size[blocktype][0];
  2483.   int   blocksize_y     = params->blc_size[blocktype][1];
  2484.   int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<< 2);
  2485.   int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<< 2);
  2487.   int   max_pos2        = ( (!start_me_refinement_hp || !start_me_refinement_qp) ? imax(1,search_pos2) : search_pos2);
  2489.   StorablePicture *ref_picture = listX[list+list_offset][ref];
  2491.   int max_pos_x4 = ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  2492.   int max_pos_y4 = ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);
  2493.   int start_pos = 5, end_pos = max_pos2;  
  2494.   int lambda_factor = lambda[H_PEL];
  2495.   computePred = computeUniPred[H_PEL + 3 * apply_weights];
  2497.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  2498.   width_pad  = ref_picture->size_x_pad;
  2499.   height_pad = ref_picture->size_y_pad;
  2501.   if ( ChromaMEEnable )
  2502.   {
  2503.     ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
  2504.     ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
  2505.     width_pad_cr  = ref_picture->size_x_cr_pad;
  2506.     height_pad_cr = ref_picture->size_y_cr_pad;
  2507.   }
  2509.   /*********************************
  2510.    *****                       *****
  2511.    *****  HALF-PEL REFINEMENT  *****
  2512.    *****                       *****
  2513.    *********************************/
  2515.   //===== set function for getting pixel values =====
  2516.   if ((pic4_pix_x + mv[0] > 1) && (pic4_pix_x + mv[0] < max_pos_x4 - 1) &&
  2517.     (pic4_pix_y + mv[1] > 1) && (pic4_pix_y + mv[1] < max_pos_y4 - 1))
  2518.   {
  2519.     ref_access_method = FAST_ACCESS;
  2520.   }
  2521.   else
  2522.   {
  2523.     ref_access_method = UMV_ACCESS;
  2524.   }
  2526.   //===== loop over search positions =====
  2527.   for (best_pos = 0, pos = start_me_refinement_hp; pos < 5; pos++)
  2528.   {
  2529.     cand_mv_x = mv[0] + search_point_hp[pos][0];    // quarter-pel units
  2530.     cand_mv_y = mv[1] + search_point_hp[pos][1];    // quarter-pel units
  2532.     //----- set motion vector cost -----
  2533.     mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  2534.     mcost += computePred( orig_pic, blocksize_y, blocksize_x,
  2535.       INT_MAX, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  2537.     if (mcost < min_mcost)
  2538.     {
  2539.       second_mcost = min_mcost;
  2540.       second_pos  = best_pos;
  2541.       min_mcost = mcost;
  2542.       best_pos  = pos;
  2543.     }
  2544.     else if (mcost < second_mcost)
  2545.     {
  2546.       second_mcost = mcost;
  2547.       second_pos  = pos;
  2548.     }
  2549.   }
  2551.   if (best_pos ==0 && (pred_mv[0] == mv[0]) && (pred_mv[1] - mv[1])== 0 && min_mcost < subthres[blocktype])
  2552.       return min_mcost;
  2554.   if (best_pos != 0 && second_pos != 0)
  2555.   {
  2556.     switch (best_pos ^ second_pos)
  2557.     {
  2558.     case 1:
  2559.       start_pos = 6;
  2560.       end_pos   = 7;
  2561.       break;
  2562.     case 3:
  2563.       start_pos = 5;
  2564.       end_pos   = 6;
  2565.       break;
  2566.     case 5:
  2567.       start_pos = 8;
  2568.       end_pos   = 9;
  2569.       break;
  2570.     case 7:
  2571.       start_pos = 7;
  2572.       end_pos   = 8;
  2573.       break;
  2574.     default:
  2575.       break;
  2576.     }
  2577.   }
  2578.   else
  2579.   {
  2580.     switch (best_pos + second_pos)
  2581.     {
  2582.     case 0:
  2583.       start_pos = 5;
  2584.       end_pos   = 5;
  2585.       break;
  2586.     case 1:
  2587.       start_pos = 8;
  2588.       end_pos   = 10;
  2589.       break;
  2590.     case 2:
  2591.       start_pos = 5;
  2592.       end_pos   = 7;
  2593.       break;
  2594.     case 5:
  2595.       start_pos = 6;
  2596.       end_pos   = 8;
  2597.       break;
  2598.     case 7:
  2599.       start_pos = 7;
  2600.       end_pos   = 9;
  2601.       break;
  2602.     default:
  2603.       break;
  2604.     }
  2605.   }
  2607.   if (best_pos !=0 || (iabs(pred_mv[0] - mv[0]) + iabs(pred_mv[1] - mv[1])))
  2608.   {
  2609.     for (pos = start_pos; pos < end_pos; pos++)
  2610.     {
  2611.       cand_mv_x = mv[0] + search_point_hp[pos][0];    // quarter-pel units
  2612.       cand_mv_y = mv[1] + search_point_hp[pos][1];    // quarter-pel units
  2614.       //----- set motion vector cost -----
  2615.       mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  2617.       if (mcost >= min_mcost) continue;
  2619.       mcost += computePred( orig_pic, blocksize_y, blocksize_x,
  2620.         min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  2622.       if (mcost < min_mcost)
  2623.       {
  2624.         min_mcost = mcost;
  2625.         best_pos  = pos;
  2626.       }
  2627.     }
  2628.   }
  2630.   if (best_pos)
  2631.   {
  2632.     mv[0] += search_point_hp[best_pos][0];
  2633.     mv[1] += search_point_hp[best_pos][1];
  2634.   }
  2636.   if ( !start_me_refinement_qp )
  2637.     min_mcost = INT_MAX;
  2639.   /************************************
  2640.   *****                          *****
  2641.   *****  QUARTER-PEL REFINEMENT  *****
  2642.   *****                          *****
  2643.   ************************************/
  2645.   //===== set function for getting pixel values =====
  2646.   if ((pic4_pix_x + mv[0] > 0) && (pic4_pix_x + mv[0] < max_pos_x4) &&
  2647.     (pic4_pix_y + mv[1] > 0) && (pic4_pix_y + mv[1] < max_pos_y4)   )
  2648.   {
  2649.     ref_access_method = FAST_ACCESS;
  2650.   }
  2651.   else
  2652.   {
  2653.     ref_access_method = UMV_ACCESS;
  2654.   }
  2656.   computePred = computeUniPred[Q_PEL + 3 * apply_weights];
  2657.   lambda_factor = lambda[Q_PEL];
  2658.   second_pos = 0;
  2659.   second_mcost = INT_MAX;
  2660.   //===== loop over search positions =====
  2661.   for (best_pos = 0, pos = start_me_refinement_qp; pos < 5; pos++)
  2662.   {
  2663.     cand_mv_x = mv[0] + search_point_qp[pos][0];    // quarter-pel units
  2664.     cand_mv_y = mv[1] + search_point_qp[pos][1];    // quarter-pel units
  2666.     //----- set motion vector cost -----
  2667.     mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  2668.     mcost += computePred( orig_pic, blocksize_y, blocksize_x,
  2669.       INT_MAX, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  2671.     if (mcost < min_mcost)
  2672.     {
  2673.       second_mcost = min_mcost;
  2674.       second_pos  = best_pos;
  2675.       min_mcost = mcost;
  2676.       best_pos  = pos;
  2677.     }
  2678.     else if (mcost < second_mcost)
  2679.     {
  2680.       second_mcost = mcost;
  2681.       second_pos  = pos;
  2682.     }
  2683.   }
  2685.   if (best_pos ==0 && (pred_mv[0] == mv[0]) && (pred_mv[1] - mv[1])== 0 && min_mcost < subthres[blocktype])
  2686.   {
  2687.     return min_mcost;
  2688.   }
  2690.   start_pos = 5;
  2691.   end_pos = search_pos4;
  2693.   if (best_pos != 0 && second_pos != 0)
  2694.   {
  2695.     switch (best_pos ^ second_pos)
  2696.     {
  2697.     case 1:
  2698.       start_pos = 6;
  2699.       end_pos   = 7;
  2700.       break;
  2701.     case 3:
  2702.       start_pos = 5;
  2703.       end_pos   = 6;
  2704.       break;
  2705.     case 5:
  2706.       start_pos = 8;
  2707.       end_pos   = 9;
  2708.       break;
  2709.     case 7:
  2710.       start_pos = 7;
  2711.       end_pos   = 8;
  2712.       break;
  2713.     default:
  2714.       break;
  2715.     }
  2716.   }
  2717.   else
  2718.   {
  2719.     switch (best_pos + second_pos)
  2720.     {
  2721.       //case 0:
  2722.       //start_pos = 5;
  2723.       //end_pos   = 5;
  2724.       //break;
  2725.     case 1:
  2726.       start_pos = 8;
  2727.       end_pos   = 10;
  2728.       break;
  2729.     case 2:
  2730.       start_pos = 5;
  2731.       end_pos   = 7;
  2732.       break;
  2733.     case 5:
  2734.       start_pos = 6;
  2735.       end_pos   = 8;
  2736.       break;
  2737.     case 7:
  2738.       start_pos = 7;
  2739.       end_pos   = 9;
  2740.       break;
  2741.     default:
  2742.       break;
  2743.     }
  2744.   }
  2746.   if (best_pos !=0 || (iabs(pred_mv[0] - mv[0]) + iabs(pred_mv[1] - mv[1])))
  2747.   {
  2748.     for (pos = start_pos; pos < end_pos; pos++)
  2749.     {
  2750.       cand_mv_x = mv[0] + search_point_qp[pos][0];    // quarter-pel units
  2751.       cand_mv_y = mv[1] + search_point_qp[pos][1];    // quarter-pel units
  2753.       //----- set motion vector cost -----
  2754.       mcost = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv[0], pred_mv[1]);
  2756.       if (mcost >= min_mcost) continue;
  2757.       mcost += computePred( orig_pic, blocksize_y, blocksize_x,
  2758.         min_mcost - mcost, cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y);
  2760.       if (mcost < min_mcost)
  2761.       {
  2762.         min_mcost = mcost;
  2763.         best_pos  = pos;
  2764.       }
  2765.     }
  2766.   }
  2767.   if (best_pos)
  2768.   {
  2769.     mv[0] += search_point_qp [best_pos][0];
  2770.     mv[1] += search_point_qp [best_pos][1];
  2771.   }
  2773.   //===== return minimum motion cost =====
  2774.   return min_mcost;
  2775. }
  2777. /*!
  2778.  ***********************************************************************
  2779.  * brief
  2780.  *    Fast bipred sub pixel block motion search to support EPZS
  2781.  ***********************************************************************
  2782.  */
  2783. int                                                   //  ==> minimum motion cost after search
  2784. EPZSSubPelBlockSearchBiPred (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  2785.                              short     ref,           // <--  reference frame (0... or -1 (backward))
  2786.                              int       list,          // <--  reference picture list
  2787.                              int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  2788.                              int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  2789.                              int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  2790.                              short     pred_mv1[2],   // <--  motion vector predictor (x) in sub-pel units
  2791.                              short     pred_mv2[2],   // <--  motion vector predictor (x) in sub-pel units
  2792.                              short     mv[2],         // <--> in: search center (x) / out: motion vector (x) - in pel units
  2793.                              short     static_mv[2],  // <--> in: search center (x) / out: motion vector (x) - in pel units
  2794.                              int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  2795.                              int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  2796.                              int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  2797.                              int       *lambda,       // <--  lagrangian parameter for determining motion cost
  2798.                              int       apply_weights  // <--  perform weight based ME
  2799.                              )
  2800. {
  2801.   int   list_offset   = img->mb_data[img->current_mb_nr].list_offset;
  2803.   int   pos, best_pos = 0, second_pos = 0, mcost;
  2804.   int   second_mcost = INT_MAX;
  2806.   int   cand_mv_x, cand_mv_y;
  2808.   int   blocksize_x     = params->blc_size[blocktype][0];
  2809.   int   blocksize_y     = params->blc_size[blocktype][1];
  2811.   int   pic4_pix_x      = ((pic_pix_x + IMG_PAD_SIZE)<< 2);
  2812.   int   pic4_pix_y      = ((pic_pix_y + IMG_PAD_SIZE)<< 2);
  2814.   int   start_hp        = (min_mcost == INT_MAX) ? 0 : start_me_refinement_hp;
  2815.   int   max_pos2        = ( (!start_me_refinement_hp || !start_me_refinement_qp) ? imax(1,search_pos2) : search_pos2);
  2817.   int   smv_x = static_mv[0] + pic4_pix_x;
  2818.   int   smv_y = static_mv[1] + pic4_pix_y;
  2820.   StorablePicture *ref_picture1 = listX[list       + list_offset][ref];
  2821.   StorablePicture *ref_picture2 = listX[(list ^ 1) + list_offset][0];
  2823.   int max_pos_x4 = ((ref_picture1->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
  2824.   int max_pos_y4 = ((ref_picture1->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);
  2825.   int start_pos = 5, end_pos = max_pos2;
  2826.   int lambda_factor = lambda[H_PEL];
  2828.   ref_pic1_sub.luma = ref_picture1->p_curr_img_sub;
  2829.   ref_pic2_sub.luma = ref_picture2->p_curr_img_sub;
  2830.   img_width     = ref_picture1->size_x;
  2831.   img_height    = ref_picture1->size_y;
  2832.   width_pad    = ref_picture1->size_x_pad;
  2833.   height_pad   = ref_picture1->size_y_pad;
  2835.   if (apply_weights)
  2836.   {    
  2837.     computeBiPred = computeBiPred2[H_PEL];
  2838.   }
  2839.   else
  2840.   {
  2841.     computeBiPred = computeBiPred1[H_PEL];
  2842.   }
  2845.   if ( ChromaMEEnable )
  2846.   {
  2847.     ref_pic1_sub.crcb[0] = ref_picture1->imgUV_sub[0];
  2848.     ref_pic1_sub.crcb[1] = ref_picture1->imgUV_sub[1];
  2849.     ref_pic2_sub.crcb[0] = ref_picture2->imgUV_sub[0];
  2850.     ref_pic2_sub.crcb[1] = ref_picture2->imgUV_sub[1];
  2851.     width_pad_cr  = ref_picture1->size_x_cr_pad;
  2852.     height_pad_cr = ref_picture1->size_y_cr_pad;
  2853.   }
  2855.   /*********************************
  2856.    *****                       *****
  2857.    *****  HALF-PEL REFINEMENT  *****
  2858.    *****                       *****
  2859.    *********************************/
  2861.   //===== set function for getting pixel values =====
  2862.   if ((pic4_pix_x + mv[0] > 1) && (pic4_pix_x + mv[0] < max_pos_x4 - 1) &&
  2863.     (pic4_pix_y + mv[1] > 1) && (pic4_pix_y + mv[1] < max_pos_y4 - 1))
  2864.   {
  2865.     bipred1_access_method = FAST_ACCESS;
  2866.   }
  2867.   else
  2868.   {
  2869.     bipred1_access_method = UMV_ACCESS;
  2870.   }
  2872.   if ((pic4_pix_x + static_mv[0] > 1) && (pic4_pix_x + static_mv[0] < max_pos_x4 - 1) &&
  2873.     (pic4_pix_y + static_mv[1] > 1) && (pic4_pix_y + static_mv[1] < max_pos_y4 - 1))
  2874.   {
  2875.     bipred2_access_method = FAST_ACCESS;
  2876.   }
  2877.   else
  2878.   {
  2879.     bipred2_access_method = UMV_ACCESS;
  2880.   }
  2882.   //===== loop over search positions =====
  2883.   for (best_pos = 0, pos = start_hp; pos < 5; pos++)
  2884.   {
  2885.     cand_mv_x = mv[0] + search_point_hp[pos][0];    // quarter-pel units
  2886.     cand_mv_y = mv[1] + search_point_hp[pos][1];    // quarter-pel units
  2888.     //----- set motion vector cost -----
  2889.     mcost  = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv1[0], pred_mv1[1]);
  2890.     mcost += MV_COST_SMP (lambda_factor, static_mv[0], static_mv[1], pred_mv2[0], pred_mv2[1]);
  2891.     mcost += computeBiPred(orig_pic, blocksize_y, blocksize_x, INT_MAX,
  2892.       cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y, smv_x, smv_y);
  2894.     if (mcost < min_mcost)
  2895.     {
  2896.       second_mcost = min_mcost;
  2897.       second_pos  = best_pos;
  2898.       min_mcost = mcost;
  2899.       best_pos  = pos;
  2900.     }
  2901.     else if (mcost < second_mcost)
  2902.     {
  2903.       second_mcost = mcost;
  2904.       second_pos  = pos;
  2905.     }
  2906.   }
  2908. //  if (best_pos ==0 && (pred_mv1[0] == mv[0]) && (pred_mv1[1] - mv[1])== 0 && min_mcost < subthres[blocktype])
  2909.       //return min_mcost;
  2911.   if (best_pos != 0 && second_pos != 0)
  2912.   {
  2913.     switch (best_pos ^ second_pos)
  2914.     {
  2915.     case 1:
  2916.       start_pos = 6;
  2917.       end_pos   = 7;
  2918.       break;
  2919.     case 3:
  2920.       start_pos = 5;
  2921.       end_pos   = 6;
  2922.       break;
  2923.     case 5:
  2924.       start_pos = 8;
  2925.       end_pos   = 9;
  2926.       break;
  2927.     case 7:
  2928.       start_pos = 7;
  2929.       end_pos   = 8;
  2930.       break;
  2931.     default:
  2932.       break;
  2933.     }
  2934.   }
  2935.   else
  2936.   {
  2937.     switch (best_pos + second_pos)
  2938.     {
  2939.     case 0:
  2940.       start_pos = 5;
  2941.       end_pos   = 5;
  2942.       break;
  2943.     case 1:
  2944.       start_pos = 8;
  2945.       end_pos   = 10;
  2946.       break;
  2947.     case 2:
  2948.       start_pos = 5;
  2949.       end_pos   = 7;
  2950.       break;
  2951.     case 5:
  2952.       start_pos = 6;
  2953.       end_pos   = 8;
  2954.       break;
  2955.     case 7:
  2956.       start_pos = 7;
  2957.       end_pos   = 9;
  2958.       break;
  2959.     default:
  2960.       break;
  2961.     }
  2962.   }
  2964.   if (best_pos !=0 || (iabs(pred_mv1[0] - mv[0]) + iabs(pred_mv1[1] - mv[1])))
  2965.   {
  2966.     for (pos = start_pos; pos < end_pos; pos++)
  2967.     {
  2968.       cand_mv_x = mv[0] + search_point_hp[pos][0];    // quarter-pel units
  2969.       cand_mv_y = mv[1] + search_point_hp[pos][1];    // quarter-pel units
  2971.       //----- set motion vector cost -----
  2972.       mcost  = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv1[0], pred_mv1[1]);
  2973.       mcost += MV_COST_SMP (lambda_factor, static_mv[0], static_mv[1], pred_mv2[0], pred_mv2[1]);
  2974.       if (mcost >= min_mcost) continue;
  2976.       mcost += computeBiPred(orig_pic, blocksize_y, blocksize_x, min_mcost - mcost,
  2977.         cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y, smv_x, smv_y);
  2979.       if (mcost < min_mcost)
  2980.       {
  2981.         min_mcost = mcost;
  2982.         best_pos  = pos;
  2983.       }
  2984.     }
  2985.   }
  2987.   if (best_pos)
  2988.   {
  2989.     mv[0] += search_point_hp [best_pos][0];
  2990.     mv[1] += search_point_hp [best_pos][1];
  2991.   }
  2993.   computeBiPred = apply_weights? computeBiPred2[Q_PEL] : computeBiPred1[Q_PEL];
  2995.   /************************************
  2996.   *****                          *****
  2997.   *****  QUARTER-PEL REFINEMENT  *****
  2998.   *****                          *****
  2999.   ************************************/
  3000.   //===== set function for getting pixel values =====
  3001.   if ((pic4_pix_x + mv[0] > 0) && (pic4_pix_x + mv[0] < max_pos_x4) &&
  3002.     (pic4_pix_y + mv[1] > 0) && (pic4_pix_y + mv[1] < max_pos_y4))
  3003.   {
  3004.     bipred1_access_method = FAST_ACCESS;
  3005.   }
  3006.   else
  3007.   {
  3008.     bipred1_access_method = UMV_ACCESS;
  3009.   }
  3011.   if ((pic4_pix_x + static_mv[0] > 0) && (pic4_pix_x + static_mv[0] < max_pos_x4) &&
  3012.     (pic4_pix_y + static_mv[1] > 0) && (pic4_pix_y + static_mv[1] < max_pos_y4))
  3013.   {
  3014.     bipred2_access_method = FAST_ACCESS;
  3015.   }
  3016.   else
  3017.   {
  3018.     bipred2_access_method = UMV_ACCESS;
  3019.   }
  3021.   if ( !start_me_refinement_qp )
  3022.     min_mcost = INT_MAX;
  3024.   lambda_factor = lambda[Q_PEL];
  3025.   second_pos = 0;
  3026.   second_mcost = INT_MAX;
  3027.   //===== loop over search positions =====
  3028.   for (best_pos = 0, pos = start_me_refinement_qp; pos < 5; pos++)
  3029.   {
  3030.     cand_mv_x = mv[0] + search_point_qp[pos][0];    // quarter-pel units
  3031.     cand_mv_y = mv[1] + search_point_qp[pos][1];    // quarter-pel units
  3033.     //----- set motion vector cost -----
  3034.     mcost  = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv1[0], pred_mv1[1]);
  3035.     mcost += MV_COST_SMP (lambda_factor, static_mv[0], static_mv[1], pred_mv2[0], pred_mv2[1]);
  3037.     mcost += computeBiPred(orig_pic, blocksize_y, blocksize_x, INT_MAX,
  3038.       cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y, smv_x, smv_y);
  3041.     if (mcost < min_mcost)
  3042.     {
  3043.       second_mcost = min_mcost;
  3044.       second_pos  = best_pos;
  3045.       min_mcost = mcost;
  3046.       best_pos  = pos;
  3047.     }
  3048.     else if (mcost < second_mcost)
  3049.     {
  3050.       second_mcost = mcost;
  3051.       second_pos  = pos;
  3052.     }
  3053.   }
  3055.   start_pos = 5;
  3056.   end_pos = search_pos4;
  3058.   if (best_pos != 0 && second_pos != 0)
  3059.   {
  3060.     switch (best_pos ^ second_pos)
  3061.     {
  3062.     case 1:
  3063.       start_pos = 6;
  3064.       end_pos   = 7;
  3065.       break;
  3066.     case 3:
  3067.       start_pos = 5;
  3068.       end_pos   = 6;
  3069.       break;
  3070.     case 5:
  3071.       start_pos = 8;
  3072.       end_pos   = 9;
  3073.       break;
  3074.     case 7:
  3075.       start_pos = 7;
  3076.       end_pos   = 8;
  3077.       break;
  3078.     default:
  3079.       break;
  3080.     }
  3081.   }
  3082.   else
  3083.   {
  3084.     switch (best_pos + second_pos)
  3085.     {
  3086.       //case 0:
  3087.       //start_pos = 5;
  3088.       //end_pos   = 5;
  3089.       //break;
  3090.     case 1:
  3091.       start_pos = 8;
  3092.       end_pos   = 10;
  3093.       break;
  3094.     case 2:
  3095.       start_pos = 5;
  3096.       end_pos   = 7;
  3097.       break;
  3098.     case 5:
  3099.       start_pos = 6;
  3100.       end_pos   = 8;
  3101.       break;
  3102.     case 7:
  3103.       start_pos = 7;
  3104.       end_pos   = 9;
  3105.       break;
  3106.     default:
  3107.       break;
  3108.     }
  3109.   }
  3111.   if (best_pos !=0 || (iabs(pred_mv1[0] - mv[0]) + iabs(pred_mv1[1] - mv[1])))
  3112.   {
  3113.     for (pos = start_pos; pos < end_pos; pos++)
  3114.     {
  3115.       cand_mv_x = mv[0] + search_point_qp[pos][0];    // quarter-pel units
  3116.       cand_mv_y = mv[1] + search_point_qp[pos][1];    // quarter-pel units
  3118.       //----- set motion vector cost -----
  3119.       mcost  = MV_COST_SMP (lambda_factor, cand_mv_x, cand_mv_y, pred_mv1[0], pred_mv1[1]);
  3120.       mcost += MV_COST_SMP (lambda_factor, static_mv[0], static_mv[1], pred_mv2[0], pred_mv2[1]);
  3121.       if (mcost >= min_mcost) continue;
  3123.       mcost += computeBiPred(orig_pic, blocksize_y, blocksize_x, min_mcost - mcost,
  3124.         cand_mv_x + pic4_pix_x, cand_mv_y + pic4_pix_y, smv_x, smv_y);
  3127.       if (mcost < min_mcost)
  3128.       {
  3129.         min_mcost = mcost;
  3130.         best_pos  = pos;
  3131.       }
  3132.     }
  3133.   }
  3134.   if (best_pos)
  3135.   {
  3136.     mv[0] += search_point_qp[best_pos][0];
  3137.     mv[1] += search_point_qp[best_pos][1];
  3138.   }
  3140.   //===== return minimum motion cost =====
  3141.   return min_mcost;
  3142. }