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

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

Audio

开发平台：

Visual C++

me_fullfast.c：源码内容
  2. /*!
  3. *************************************************************************************
  4. * file me_fullfast.c
  5. *
  6. * brief
  7. *    Motion Estimation using Full Search Fast
  8. *
  9. * author
  10. *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11. *      - Alexis Michael Tourapis <alexismt@ieee.org>
  12. *
  13. *************************************************************************************
  14. */
  16. // Includes
  17. #include "contributors.h"
  18. #include <limits.h>
  20. #include "global.h"
  21. #include "image.h"
  22. #include "memalloc.h"
  23. #include "mb_access.h"
  24. #include "refbuf.h"
  26. #include "me_distortion.h"
  27. #include "me_fullsearch.h"
  28. #include "conformance.h"
  29. #include "mv-search.h"
  31. // Define External Global Parameters
  32. extern short*   spiral_search_x;
  33. extern short*   spiral_search_y;
  35. /*****
  36.  *****  static variables for fast integer motion estimation
  37.  *****
  38.  */
  39. static int  **search_setup_done;  //!< flag if all block SAD's have been calculated yet
  40. static int  **search_center_x;    //!< absolute search center for fast full motion search
  41. static int  **search_center_y;    //!< absolute search center for fast full motion search
  42. static int  **pos_00;             //!< position of (0,0) vector
  43. static distpel  *****BlockSAD;        //!< SAD for all blocksize, ref. frames and motion vectors
  44. static int  **max_search_range;
  46. extern void SetMotionVectorPredictor (Macroblock *currMB, short  pmv[2], char   **refPic,
  47.                                       short  ***tmp_mv, short  ref_frame,
  48.                                       int    list,      int mb_x, int mb_y, 
  49.                                       int    blockshape_x, int blockshape_y);
  51. // Functions
  52. /*!
  53.  ***********************************************************************
  54.  * brief
  55.  *    Full pixel block motion search
  56.  ***********************************************************************
  57.  */
  60. /*!
  61.  ***********************************************************************
  62.  * brief
  63.  *    function creating arrays for fast integer motion estimation
  64.  ***********************************************************************
  65.  */
  66. void InitializeFastFullIntegerSearch (void)
  67. {
  68.   int  i, j, k, list;
  69.   int  search_range = params->search_range;
  70.   int  max_pos      = (2*search_range+1) * (2*search_range+1);
  72.   if ((BlockSAD = (distpel*****)malloc (2 * sizeof(distpel****))) == NULL)
  73.     no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  75.   for (list=0; list<2;list++)
  76.   {
  77.     if ((BlockSAD[list] = (distpel****)malloc ((img->max_num_references) * sizeof(distpel***))) == NULL)
  78.       no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  79.     for (i = 0; i < img->max_num_references; i++)
  80.     {
  81.       if ((BlockSAD[list][i] = (distpel***)malloc (8 * sizeof(distpel**))) == NULL)
  82.         no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  83.       for (j = 1; j < 8; j++)
  84.       {
  85.         if ((BlockSAD[list][i][j] = (distpel**)malloc (16 * sizeof(distpel*))) == NULL)
  86.           no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  87.         for (k = 0; k < 16; k++)
  88.         {
  89.           if ((BlockSAD[list][i][j][k] = (distpel*)malloc (max_pos * sizeof(distpel))) == NULL)
  90.             no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  91.         }
  92.       }
  93.     }
  94.   }
  96.   if ((search_setup_done = (int**)malloc (2*sizeof(int*)))==NULL)
  97.     no_mem_exit ("InitializeFastFullIntegerSearch: search_setup_done");
  98.   if ((search_center_x = (int**)malloc (2*sizeof(int*)))==NULL)
  99.     no_mem_exit ("InitializeFastFullIntegerSearch: search_center_x");
  100.   if ((search_center_y = (int**)malloc (2*sizeof(int*)))==NULL)
  101.     no_mem_exit ("InitializeFastFullIntegerSearch: search_center_y");
  102.   if ((pos_00 = (int**)malloc (2*sizeof(int*)))==NULL)
  103.     no_mem_exit ("InitializeFastFullIntegerSearch: pos_00");
  104.   if ((max_search_range = (int**)malloc (2*sizeof(int*)))==NULL)
  105.     no_mem_exit ("InitializeFastFullIntegerSearch: max_search_range");
  107.   for (list=0; list<2; list++)
  108.   {
  109.     if ((search_setup_done[list] = (int*)malloc ((img->max_num_references)*sizeof(int)))==NULL)
  110.       no_mem_exit ("InitializeFastFullIntegerSearch: search_setup_done");
  111.     if ((search_center_x[list] = (int*)malloc ((img->max_num_references)*sizeof(int)))==NULL)
  112.       no_mem_exit ("InitializeFastFullIntegerSearch: search_center_x");
  113.     if ((search_center_y[list] = (int*)malloc ((img->max_num_references)*sizeof(int)))==NULL)
  114.       no_mem_exit ("InitializeFastFullIntegerSearch: search_center_y");
  115.     if ((pos_00[list] = (int*)malloc ((img->max_num_references)*sizeof(int)))==NULL)
  116.       no_mem_exit ("InitializeFastFullIntegerSearch: pos_00");
  117.     if ((max_search_range[list] = (int*)malloc ((img->max_num_references)*sizeof(int)))==NULL)
  118.       no_mem_exit ("InitializeFastFullIntegerSearch: max_search_range");
  119.   }
  121.   // assign max search ranges for reference frames
  122.   if (params->full_search == 2)
  123.   {
  124.     for (list=0;list<2;list++)
  125.       for (i=0; i<img->max_num_references; i++)
  126.         max_search_range[list][i] = search_range;
  127.   }
  128.   else
  129.   {
  130.     for (list=0;list<2;list++)
  131.     {
  132.       max_search_range[list][0] = search_range;
  133.       for (i=1; i< img->max_num_references; i++)  max_search_range[list][i] = search_range / 2;
  134.     }
  135.   }
  136. }
  138. /*!
  139.  ***********************************************************************
  140.  * brief
  141.  *    function for deleting the arrays for fast integer motion estimation
  142.  ***********************************************************************
  143.  */
  144. void
  145. ClearFastFullIntegerSearch ()
  146. {
  147.   int  i, j, k, list;
  149.   for (list=0; list<2; list++)
  150.   {
  151.     for (i = 0; i < img->max_num_references; i++)
  152.     {
  153.       for (j = 1; j < 8; j++)
  154.       {
  155.         for (k = 0; k < 16; k++)
  156.         {
  157.           free (BlockSAD[list][i][j][k]);
  158.         }
  159.         free (BlockSAD[list][i][j]);
  160.       }
  161.       free (BlockSAD[list][i]);
  162.     }
  163.     free (BlockSAD[list]);
  164.   }
  165.   free (BlockSAD);
  167.   for (list=0; list<2; list++)
  168.   {
  169.     free (search_setup_done[list]);
  170.     free (search_center_x[list]);
  171.     free (search_center_y[list]);
  172.     free (pos_00[list]);
  173.     free (max_search_range[list]);
  174.   }
  175.   free (search_setup_done);
  176.   free (search_center_x);
  177.   free (search_center_y);
  178.   free (pos_00);
  179.   free (max_search_range);
  181. }
  184. /*!
  185.  ***********************************************************************
  186.  * brief
  187.  *    function resetting flags for fast integer motion estimation
  188.  *    (have to be called in start_macroblock())
  189.  ***********************************************************************
  190.  */
  191. void ResetFastFullIntegerSearch ()
  192. {
  193.   int list;
  194.   for (list=0; list<2; list++)
  195.     memset(&search_setup_done [list][0], 0, img->max_num_references * sizeof(int));
  196. }
  197. /*!
  198.  ***********************************************************************
  199.  * brief
  200.  *    calculation of SAD for larger blocks on the basis of 4x4 blocks
  201.  ***********************************************************************
  202.  */
  203. void
  204. SetupLargerBlocks (int list, int refindex, int max_pos)
  205. {
  206. #define ADD_UP_BLOCKS()   _o=*_bo; _i=*_bi; _j=*_bj; for(pos=0;pos<max_pos;pos++) _o[pos] = _i[pos] + _j[pos];
  207. #define INCREMENT(inc)    _bo+=inc; _bi+=inc; _bj+=inc;
  209.   int       pos;
  210.   distpel   **_bo, **_bi, **_bj;
  211.   register distpel *_o,   *_i,   *_j;
  213.   //--- blocktype 6 ---
  214.   _bo = BlockSAD[list][refindex][6];
  215.   _bi = BlockSAD[list][refindex][7];
  216.   _bj = _bi + 4;
  217.   ADD_UP_BLOCKS(); INCREMENT(1);
  218.   ADD_UP_BLOCKS(); INCREMENT(1);
  219.   ADD_UP_BLOCKS(); INCREMENT(1);
  220.   ADD_UP_BLOCKS(); INCREMENT(5);
  221.   ADD_UP_BLOCKS(); INCREMENT(1);
  222.   ADD_UP_BLOCKS(); INCREMENT(1);
  223.   ADD_UP_BLOCKS(); INCREMENT(1);
  224.   ADD_UP_BLOCKS();
  226.   //--- blocktype 5 ---
  227.   _bo = BlockSAD[list][refindex][5];
  228.   _bi = BlockSAD[list][refindex][7];
  229.   _bj = _bi + 1;
  230.   ADD_UP_BLOCKS(); INCREMENT(2);
  231.   ADD_UP_BLOCKS(); INCREMENT(2);
  232.   ADD_UP_BLOCKS(); INCREMENT(2);
  233.   ADD_UP_BLOCKS(); INCREMENT(2);
  234.   ADD_UP_BLOCKS(); INCREMENT(2);
  235.   ADD_UP_BLOCKS(); INCREMENT(2);
  236.   ADD_UP_BLOCKS(); INCREMENT(2);
  237.   ADD_UP_BLOCKS();
  239.   //--- blocktype 4 ---
  240.   _bo = BlockSAD[list][refindex][4];
  241.   _bi = BlockSAD[list][refindex][6];
  242.   _bj = _bi + 1;
  243.   ADD_UP_BLOCKS(); INCREMENT(2);
  244.   ADD_UP_BLOCKS(); INCREMENT(6);
  245.   ADD_UP_BLOCKS(); INCREMENT(2);
  246.   ADD_UP_BLOCKS();
  248.   //--- blocktype 3 ---
  249.   _bo = BlockSAD[list][refindex][3];
  250.   _bi = BlockSAD[list][refindex][4];
  251.   _bj = _bi + 8;
  252.   ADD_UP_BLOCKS(); INCREMENT(2);
  253.   ADD_UP_BLOCKS();
  255.   //--- blocktype 2 ---
  256.   _bo = BlockSAD[list][refindex][2];
  257.   _bi = BlockSAD[list][refindex][4];
  258.   _bj = _bi + 2;
  259.   ADD_UP_BLOCKS(); INCREMENT(8);
  260.   ADD_UP_BLOCKS();
  262.   //--- blocktype 1 ---
  263.   _bo = BlockSAD[list][refindex][1];
  264.   _bi = BlockSAD[list][refindex][3];
  265.   _bj = _bi + 2;
  266.   ADD_UP_BLOCKS();
  267. }
  270. /*!
  271.  ***********************************************************************
  272.  * brief
  273.  *    Setup the fast search for an macroblock
  274.  ***********************************************************************
  275.  */
  276. #define GEN_ME 0
  277. #if GEN_ME
  278. void SetupFastFullPelSearch (Macroblock *currMb, short ref, int list)  // <--  reference frame parameter, list0 or 1
  279. {
  280.   short   pmv[2], mv[2];
  281.   static imgpel   orig_pels[768];
  283.   imgpel  *srcptr = orig_pels;
  284.   int     offset_x, offset_y, range_partly_outside, ref_x, ref_y, pos, abs_x, abs_y, bindex, blky;
  285.   int     max_width, max_height;
  286.   int     img_width, img_height;
  288.   StorablePicture *ref_picture;
  289.   distpel**   block_sad = BlockSAD[list][ref][7];
  290.   int     search_range  = max_search_range[list][ref];
  291.   int     max_pos       = (2*search_range+1) * (2*search_range+1);
  293.   int     list_offset   = img->mb_data[img->current_mb_nr].list_offset;
  295.   int     apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
  296.     (active_pps->weighted_bipred_idc && (img->type == B_SLICE))) && params->UseWeightedReferenceME;
  297.   int abs_y4, abs_x4;
  299.   int   i, j, k;
  300.   int   level_dist = F_PEL + apply_weights * 3;
  301.   int   pixel_x, pixel_y;
  304.   for ( j= img->opix_y; j < img->opix_y + MB_BLOCK_SIZE; j +=BLOCK_SIZE)
  305.   {
  306.     for (pixel_y = j; pixel_y < j + BLOCK_SIZE; pixel_y++)
  307.     {
  308.       memcpy( srcptr, &pCurImg[pixel_y][img->opix_x], BLOCK_SIZE * sizeof(imgpel));
  309.       memcpy( srcptr + 16, &pCurImg[pixel_y][img->opix_x + BLOCK_SIZE], BLOCK_SIZE * sizeof(imgpel));
  310.       memcpy( srcptr + 32, &pCurImg[pixel_y][img->opix_x + 2 * BLOCK_SIZE], BLOCK_SIZE * sizeof(imgpel));
  311.       memcpy( srcptr + 48, &pCurImg[pixel_y][img->opix_x + 3 * BLOCK_SIZE], BLOCK_SIZE * sizeof(imgpel));
  312.       srcptr += BLOCK_SIZE;
  313.     }
  314.     srcptr += 48;
  315.   }
  316.   // storage format is different from that of orig_pic
  317.   // for YUV 4:2:0 we have:
  318.   // YYYY
  319.   // YYYY
  320.   // U U
  321.   //
  322.   // V V
  323.   //
  324.   if (ChromaMEEnable)
  325.   {
  326.     imgpel *auxptr;
  327.     int   uv;
  328.     int   bsx_c = BLOCK_SIZE >> (chroma_shift_x - 2);
  329.     int   bsy_c = BLOCK_SIZE >> (chroma_shift_y - 2);
  330.     int   pic_pix_x_c = img->opix_x >> (chroma_shift_x - 2);
  331.     int   pic_pix_y_c = img->opix_y >> (chroma_shift_y - 2);
  333.     // copy the original cmp1 and cmp2 data to the orig_pic matrix
  334.     // This seems to be wrong.
  335.     for (uv = 1; uv < 3; uv++)
  336.     {
  337.       srcptr = auxptr = orig_pels + (256 << (uv - 1));
  338.       for ( pixel_y = 0, i = 0; i < (BLOCK_SIZE >> (chroma_shift_y - 2)); i++, pixel_y += bsy_c )
  339.       {
  340.         for ( pixel_x = 0, k = 0; k < (BLOCK_SIZE >> (chroma_shift_x - 2)); k++, pixel_x += bsx_c )
  341.         {
  342.           srcptr = auxptr;
  343.           for (j = 0; j < bsy_c; j++)
  344.           {
  345.             memcpy( srcptr, &pImgOrg[uv][pic_pix_y_c + pixel_y + j][pic_pix_x_c + pixel_x], bsx_c * sizeof(imgpel));
  346.             srcptr += bsx_c;
  347.           }
  348.           auxptr += MB_BLOCK_SIZE;
  349.         }
  350.       }
  351.     }
  352.   }
  355.   ref_picture     = listX[list+list_offset][ref];
  356.   ref_access_method = FAST_ACCESS;
  358.   //===== Use weighted Reference for ME ====
  359.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  361.   if (apply_weights)
  362.   {
  363.     weight_luma = wp_weight[list + list_offset][ref][0];
  364.     offset_luma = wp_offset[list + list_offset][ref][0];
  365.   }
  367.   if ( ChromaMEEnable)
  368.   {
  369.     ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
  370.     ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
  371.     width_pad_cr  = ref_picture->size_x_cr_pad;
  372.     height_pad_cr = ref_picture->size_y_cr_pad;
  373.     if (apply_weights)
  374.     {
  375.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  376.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  377.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  378.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  379.     }
  380.   }
  382.   max_width     = ref_picture->size_x - 17;
  383.   max_height    = ref_picture->size_y - 17;
  385.   img_width     = ref_picture->size_x;
  386.   img_height    = ref_picture->size_y;
  387.   width_pad     = ref_picture->size_x_pad;
  388.   height_pad    = ref_picture->size_y_pad;
  390.   //===== get search center: predictor of 16x16 block =====
  391.   SetMotionVectorPredictor (currMB, pmv, enc_picture->motion.ref_idx[list], enc_picture->motion.mv[list], ref, list, 0, 0, 16, 16);
  393.   mv[0] = pmv[0] / 4;
  394.   mv[1] = pmv[1] / 4;
  396.   if (!params->rdopt)
  397.   {
  398.     //--- correct center so that (0,0) vector is inside ---
  399.     mv[0] = iClip3(-search_range, search_range, mv[0]);
  400.     mv[1] = iClip3(-search_range, search_range, mv[1]);
  401.   }
  403.   clip_mv_range(img, search_range, mv, F_PEL);
  405.   search_center_x[list][ref] = mv[0] + img->opix_x;
  406.   search_center_y[list][ref] = mv[1] + img->opix_y;
  408.   offset_x = search_center_x[list][ref];
  409.   offset_y = search_center_y[list][ref];
  412.   //===== check if whole search range is inside image =====
  413.   if (offset_x >= search_range && offset_x <= max_width  - search_range &&
  414.     offset_y >= search_range && offset_y <= max_height - search_range   )
  415.   {
  416.     range_partly_outside = 0;
  417.   }
  418.   else
  419.   {
  420.     range_partly_outside = 1;
  421.   }
  423.   //===== determine position of (0,0)-vector =====
  424.   if (!params->rdopt)
  425.   {
  426.     ref_x = img->opix_x - offset_x;
  427.     ref_y = img->opix_y - offset_y;
  429.     for (pos = 0; pos < max_pos; pos++)
  430.     {
  431.       if (ref_x == spiral_search_x[pos] &&
  432.         ref_y == spiral_search_y[pos])
  433.       {
  434.         pos_00[list][ref] = pos;
  435.         break;
  436.       }
  437.     }
  438.   }
  440.   //===== loop over search range (spiral search): get blockwise SAD =====
  441.   for (pos = 0; pos < max_pos; pos++)
  442.   {
  443.     abs_y = offset_y + spiral_search_y[pos];
  444.     abs_x = offset_x + spiral_search_x[pos];
  446.     abs_y4 = (abs_y + IMG_PAD_SIZE) << 2;
  447.     abs_x4 = (abs_x + IMG_PAD_SIZE) << 2;
  449.     if (range_partly_outside)
  450.     {
  451.       if (abs_y >= 0 && abs_y <= max_height &&
  452.         abs_x >= 0 && abs_x <= max_width    )
  453.       {
  454.         ref_access_method = FAST_ACCESS;
  455.       }
  456.       else
  457.       {
  458.         ref_access_method = UMV_ACCESS;
  459.       }
  460.     }
  462.     srcptr = orig_pels;
  463.     bindex = 0;
  464.     for (blky = 0; blky < 4; blky++)
  465.     {
  466.       block_sad[bindex++][pos] = computeUniPred[level_dist](srcptr, 4, 4, INT_MAX, abs_x4,      abs_y4);
  467.       srcptr += 16;
  468.       block_sad[bindex++][pos] = computeUniPred[level_dist](srcptr, 4, 4, INT_MAX, abs_x4 + 16, abs_y4);
  469.       srcptr += 16;
  470.       block_sad[bindex++][pos] = computeUniPred[level_dist](srcptr, 4, 4, INT_MAX, abs_x4 + 32, abs_y4);
  471.       srcptr += 16;
  472.       block_sad[bindex++][pos] = computeUniPred[level_dist](srcptr, 4, 4, INT_MAX, abs_x4 + 48, abs_y4);
  473.       srcptr += 16;
  474.       abs_y4 += 16;
  475.     }
  476.   }
  478.   //===== combine SAD's for larger block types =====
  479.   SetupLargerBlocks (list, ref, max_pos);
  481.   //===== set flag marking that search setup have been done =====
  482.   search_setup_done[list][ref] = 1;
  483. }
  485. #else
  486. void SetupFastFullPelSearch (Macroblock *currMB, short ref, int list)  // <--  reference frame parameter, list0 or 1
  487. {
  488.   short   pmv[2];
  489.   static imgpel orig_pels[768];
  490.   imgpel  *srcptr = orig_pels, *refptr;
  491.   int     k, x, y;
  492.   int     abs_y4, abs_x4;
  493.   int     offset_x, offset_y, range_partly_outside, ref_x, ref_y, pos, abs_x, abs_y, bindex, blky;
  494.   int     LineSadBlk0, LineSadBlk1, LineSadBlk2, LineSadBlk3;
  495.   int     max_width, max_height;
  496.   int     img_width, img_height;
  498.   StorablePicture *ref_picture;
  499.   distpel**   block_sad = BlockSAD[list][ref][7];
  500.   int     search_range  = max_search_range[list][ref];
  501.   int     max_pos       = (2*search_range+1) * (2*search_range+1);
  503.   int     list_offset   = img->mb_data[img->current_mb_nr].list_offset;
  504.   int     apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
  505.     (active_pps->weighted_bipred_idc && (img->type == B_SLICE))) && params->UseWeightedReferenceME;
  506.   int     weighted_pel;
  507.   int *dist_method = params->MEErrorMetric[0] ? img->quad : byte_abs;
  509.   ref_picture     = listX[list+list_offset][ref];
  510.   ref_access_method = FAST_ACCESS;
  512.   ref_pic_sub.luma = ref_picture->p_curr_img_sub;
  514.   max_width     = ref_picture->size_x - 17;
  515.   max_height    = ref_picture->size_y - 17;
  517.   img_width     = ref_picture->size_x;
  518.   img_height    = ref_picture->size_y;
  519.   width_pad     = ref_picture->size_x_pad;
  520.   height_pad    = ref_picture->size_y_pad;
  522.   if (apply_weights)
  523.   {
  524.     weight_luma = wp_weight[list + list_offset][ref][0];
  525.     offset_luma = wp_offset[list + list_offset][ref][0];
  526.   }
  528.   if ( ChromaMEEnable)
  529.   {
  530.     ref_pic_sub.crcb[0] = ref_picture->imgUV_sub[0];
  531.     ref_pic_sub.crcb[1] = ref_picture->imgUV_sub[1];
  532.     width_pad_cr  = ref_picture->size_x_cr_pad;
  533.     height_pad_cr = ref_picture->size_y_cr_pad;
  535.     if (apply_weights)
  536.     {
  537.       weight_cr[0] = wp_weight[list + list_offset][ref][1];
  538.       weight_cr[1] = wp_weight[list + list_offset][ref][2];
  539.       offset_cr[0] = wp_offset[list + list_offset][ref][1];
  540.       offset_cr[1] = wp_offset[list + list_offset][ref][2];
  541.     }
  542.   }
  544.   //===== get search center: predictor of 16x16 block =====
  545.   SetMotionVectorPredictor (currMB, pmv, enc_picture->motion.ref_idx[list], enc_picture->motion.mv[list], ref, list, 0, 0, 16, 16);
  547.   search_center_x[list][ref] = pmv[0] / 4;
  548.   search_center_y[list][ref] = pmv[1] / 4;
  550.   if (!params->rdopt)
  551.   {
  552.     //--- correct center so that (0,0) vector is inside ---
  553.     search_center_x[list][ref] = iClip3(-search_range, search_range, search_center_x[list][ref]);
  554.     search_center_y[list][ref] = iClip3(-search_range, search_range, search_center_y[list][ref]);
  555.   }
  557.   search_center_x[list][ref] = iClip3(-2047 + search_range, 2047 - search_range, search_center_x[list][ref]);
  558.   search_center_y[list][ref] = iClip3(LEVELMVLIMIT[img->LevelIndex][0] + search_range, LEVELMVLIMIT[img->LevelIndex][1]  - search_range, search_center_y[list][ref]);
  560.   search_center_x[list][ref] += img->opix_x;
  561.   search_center_y[list][ref] += img->opix_y;
  563.   offset_x = search_center_x[list][ref];
  564.   offset_y = search_center_y[list][ref];
  567.   //===== copy original block for fast access =====
  568.   for   (y = img->opix_y; y < img->opix_y+MB_BLOCK_SIZE; y++)
  569.   {
  570.     memcpy(srcptr, &pCurImg[y][img->opix_x], MB_BLOCK_SIZE * sizeof(imgpel));
  571.     srcptr += MB_BLOCK_SIZE;
  572.   }
  573.   if ( ChromaMEEnable)
  574.   {
  575.     for (k = 1; k < 3; k++)
  576.     {
  577.       for   (y = img->opix_c_y; y < img->opix_c_y + img->mb_cr_size_y; y++)
  578.       {
  579.         memcpy(srcptr, &pImgOrg[k][y][img->opix_c_x], img->mb_cr_size_x * sizeof(imgpel));
  580.         srcptr += img->mb_cr_size_x;
  581.       }
  582.     }
  583.   }
  585.   //===== check if whole search range is inside image =====
  586.   if (offset_x >= search_range && offset_x <= max_width  - search_range &&
  587.     offset_y >= search_range && offset_y <= max_height - search_range   )
  588.   {
  589.     range_partly_outside = 0;
  590.   }
  591.   else
  592.   {
  593.     range_partly_outside = 1;
  594.   }
  596.   //===== determine position of (0,0)-vector =====
  597.   if (!params->rdopt)
  598.   {
  599.     ref_x = img->opix_x - offset_x;
  600.     ref_y = img->opix_y - offset_y;
  602.     for (pos = 0; pos < max_pos; pos++)
  603.     {
  604.       if (ref_x == spiral_search_x[pos] &&
  605.         ref_y == spiral_search_y[pos])
  606.       {
  607.         pos_00[list][ref] = pos;
  608.         break;
  609.       }
  610.     }
  611.   }
  613.   //===== loop over search range (spiral search): get blockwise SAD =====
  614.   for (pos = 0; pos < max_pos; pos++)
  615.   {
  616.     abs_y = offset_y + spiral_search_y[pos];
  617.     abs_x = offset_x + spiral_search_x[pos];
  619.     abs_y4 = (abs_y + IMG_PAD_SIZE) << 2;
  620.     abs_x4 = (abs_x + IMG_PAD_SIZE) << 2;
  622.     if (range_partly_outside)
  623.     {
  624.       if (abs_y >= 0 && abs_y <= max_height&&
  625.         abs_x >= 0 && abs_x <= max_width  )
  626.       {
  627.         ref_access_method = FAST_ACCESS;
  628.       }
  629.       else
  630.       {
  631.         ref_access_method = UMV_ACCESS;
  632.       }
  633.     }
  635.     if (apply_weights)
  636.     {
  637.       srcptr = orig_pels;
  638.       bindex = 0;
  640.       refptr = get_line[ref_access_method] (ref_pic_sub.luma, abs_y4, abs_x4);
  642.       for (blky = 0; blky < 4; blky++)
  643.       {
  644.         LineSadBlk0 = LineSadBlk1 = LineSadBlk2 = LineSadBlk3 = 0;
  646.         for (y = 0; y < 4; y++)
  647.         {
  648.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  649.           LineSadBlk0 += dist_method [weighted_pel - *srcptr++];
  650.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  651.           LineSadBlk0 += dist_method [weighted_pel - *srcptr++];
  652.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  653.           LineSadBlk0 += dist_method [weighted_pel - *srcptr++];
  654.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  655.           LineSadBlk0 += dist_method [weighted_pel - *srcptr++];
  656.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  657.           LineSadBlk1 += dist_method [weighted_pel - *srcptr++];
  658.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  659.           LineSadBlk1 += dist_method [weighted_pel - *srcptr++];
  660.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  661.           LineSadBlk1 += dist_method [weighted_pel - *srcptr++];
  662.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  663.           LineSadBlk1 += dist_method [weighted_pel - *srcptr++];
  664.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  665.           LineSadBlk2 += dist_method [weighted_pel - *srcptr++];
  666.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  667.           LineSadBlk2 += dist_method [weighted_pel - *srcptr++];
  668.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  669.           LineSadBlk2 += dist_method [weighted_pel - *srcptr++];
  670.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  671.           LineSadBlk2 += dist_method [weighted_pel - *srcptr++];
  672.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  673.           LineSadBlk3 += dist_method [weighted_pel - *srcptr++];
  674.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  675.           LineSadBlk3 += dist_method [weighted_pel - *srcptr++];
  676.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  677.           LineSadBlk3 += dist_method [weighted_pel - *srcptr++];
  678.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *refptr++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  679.           LineSadBlk3 += dist_method [weighted_pel - *srcptr++];
  680.           refptr += img_padded_size_x - MB_BLOCK_SIZE;
  681.         }
  683.         block_sad[bindex++][pos] = LineSadBlk0;
  684.         block_sad[bindex++][pos] = LineSadBlk1;
  685.         block_sad[bindex++][pos] = LineSadBlk2;
  686.         block_sad[bindex++][pos] = LineSadBlk3;
  687.       }
  688.       if (ChromaMEEnable)
  689.       {
  690.         int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  691.         for (k = 0; k < 2; k ++)
  692.         {
  693.           bindex = 0;
  695.           refptr = get_crline[ref_access_method] (ref_pic_sub.crcb[k], abs_y4, abs_x4);
  696.           for (blky = 0; blky < 4; blky++)
  697.           {
  698.             LineSadBlk0 = LineSadBlk1 = LineSadBlk2 = LineSadBlk3 = 0;
  700.             for (y = 0; y < img->mb_cr_size_y; y+=BLOCK_SIZE)
  701.             {
  702.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  703.               {
  704.                 weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *refptr++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  705.                 LineSadBlk0 += dist_method [weighted_pel - *srcptr++];
  706.               }
  707.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  708.               {
  709.                 weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *refptr++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  710.                 LineSadBlk1 += dist_method [weighted_pel - *srcptr++];
  711.               }
  712.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  713.               {
  714.                 weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *refptr++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  715.                 LineSadBlk2 += dist_method [weighted_pel - *srcptr++];
  716.               }
  717.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  718.               {
  719.                 weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *refptr++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  720.                 LineSadBlk3 += dist_method [weighted_pel - *srcptr++];
  721.               }
  722.               refptr += img_cr_padded_size_x - img->mb_cr_size_x;
  723.             }
  725.             block_sad[bindex++][pos] += LineSadBlk0;
  726.             block_sad[bindex++][pos] += LineSadBlk1;
  727.             block_sad[bindex++][pos] += LineSadBlk2;
  728.             block_sad[bindex++][pos] += LineSadBlk3;
  729.           }
  730.         }
  731.       }
  732.     }
  733.     else
  734.     {
  735.       srcptr = orig_pels;
  736.       bindex = 0;
  738.       refptr = get_line[ref_access_method] (ref_pic_sub.luma, abs_y4, abs_x4);
  740.       for (blky = 0; blky < 4; blky++)
  741.       {
  742.         LineSadBlk0 = LineSadBlk1 = LineSadBlk2 = LineSadBlk3 = 0;
  744.         for (y = 0; y < 4; y++)
  745.         {
  746.           LineSadBlk0 += dist_method [*refptr++ - *srcptr++];
  747.           LineSadBlk0 += dist_method [*refptr++ - *srcptr++];
  748.           LineSadBlk0 += dist_method [*refptr++ - *srcptr++];
  749.           LineSadBlk0 += dist_method [*refptr++ - *srcptr++];
  750.           LineSadBlk1 += dist_method [*refptr++ - *srcptr++];
  751.           LineSadBlk1 += dist_method [*refptr++ - *srcptr++];
  752.           LineSadBlk1 += dist_method [*refptr++ - *srcptr++];
  753.           LineSadBlk1 += dist_method [*refptr++ - *srcptr++];
  754.           LineSadBlk2 += dist_method [*refptr++ - *srcptr++];
  755.           LineSadBlk2 += dist_method [*refptr++ - *srcptr++];
  756.           LineSadBlk2 += dist_method [*refptr++ - *srcptr++];
  757.           LineSadBlk2 += dist_method [*refptr++ - *srcptr++];
  758.           LineSadBlk3 += dist_method [*refptr++ - *srcptr++];
  759.           LineSadBlk3 += dist_method [*refptr++ - *srcptr++];
  760.           LineSadBlk3 += dist_method [*refptr++ - *srcptr++];
  761.           LineSadBlk3 += dist_method [*refptr++ - *srcptr++];
  762.           refptr += img_padded_size_x - MB_BLOCK_SIZE;
  763.         }
  765.         block_sad[bindex++][pos] = LineSadBlk0;
  766.         block_sad[bindex++][pos] = LineSadBlk1;
  767.         block_sad[bindex++][pos] = LineSadBlk2;
  768.         block_sad[bindex++][pos] = LineSadBlk3;
  769.       }
  771.       if (ChromaMEEnable)
  772.       {
  773.         for (k = 0; k < 2; k ++)
  774.         {
  775.           bindex = 0;
  777.           refptr = get_crline[ref_access_method] (ref_pic_sub.crcb[k], abs_y4, abs_x4);
  778.           for (blky = 0; blky < 4; blky++)
  779.           {
  780.             LineSadBlk0 = LineSadBlk1 = LineSadBlk2 = LineSadBlk3 = 0;
  782.             for (y = 0; y < img->mb_cr_size_y; y+=BLOCK_SIZE)
  783.             {
  784.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  785.               {
  786.                 LineSadBlk0 += dist_method [*refptr++ - *srcptr++];
  787.               }
  788.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  789.               {
  790.                 LineSadBlk1 += dist_method [*refptr++ - *srcptr++];
  791.               }
  792.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  793.               {
  794.                 LineSadBlk2 += dist_method [*refptr++ - *srcptr++];
  795.               }
  796.               for (x = 0; x < img->mb_cr_size_x; x += BLOCK_SIZE)
  797.               {
  798.                 LineSadBlk3 += dist_method [*refptr++ - *srcptr++];
  799.               }
  800.               refptr += img_cr_padded_size_x - img->mb_cr_size_x;
  801.             }
  803.             block_sad[bindex++][pos] += LineSadBlk0;
  804.             block_sad[bindex++][pos] += LineSadBlk1;
  805.             block_sad[bindex++][pos] += LineSadBlk2;
  806.             block_sad[bindex++][pos] += LineSadBlk3;
  807.           }
  808.         }
  809.       }
  810.     }
  811.   }
  813.   //===== combine SAD's for larger block types =====
  814.   SetupLargerBlocks (list, ref, max_pos);
  816.   //===== set flag marking that search setup have been done =====
  817.   search_setup_done[list][ref] = 1;
  818. }
  819. #endif
  821. /*!
  822.  ***********************************************************************
  823.  * brief
  824.  *    Fast Full pixel block motion search
  825.  ***********************************************************************
  826.  */
  827. int                                                     //  ==> minimum motion cost after search
  828. FastFullPelBlockMotionSearch (Macroblock *currMB,       // <--  current Macroblock
  829.                               imgpel*   orig_pic,       // <--  not used
  830.                               short     ref,            // <--  reference frame (0... or -1 (backward))
  831.                               int       list,
  832.                               int       list_offset,    // <--  MBAFF list offset
  833.                               char   ***refPic,         // <--  reference array
  834.                               short ****tmp_mv,         // <--  mv array
  835.                               int       pic_pix_x,      // <--  absolute x-coordinate of regarded AxB block
  836.                               int       pic_pix_y,      // <--  absolute y-coordinate of regarded AxB block
  837.                               int       blocktype,      // <--  block type (1-16x16 ... 7-4x4)
  838.                               short     pred_mv[2],     // <--  motion vector predictor (x) in sub-pel units
  839.                               short     mv[2],          // <--> in: search center (x) / out: motion vector (x) - in pel units
  840.                               int       search_range,   // <--  1-d search range in pel units
  841.                               int       min_mcost,      // <--  minimum motion cost (cost for center or huge value)
  842.                               int       lambda_factor,  // <--  lagrangian parameter for determining motion cost
  843.                               int       apply_weights
  844.                               )
  845. {
  846.   int   pos, offset_x, offset_y, cand_x, cand_y, mcost;
  847.   int   max_pos       = (2*search_range+1)*(2*search_range+1);              // number of search positions
  848.   int   best_pos      = 0;                                                  // position with minimum motion cost
  849.   int   block_index;                                                        // block index for indexing SAD array
  850.   distpel*  block_sad;                                                          // pointer to SAD array
  852.   block_index   = (pic_pix_y-img->opix_y)+((pic_pix_x-img->opix_x)>>2); // block index for indexing SAD array
  853.   block_sad     = BlockSAD[list][ref][blocktype][block_index];         // pointer to SAD array
  855.   //===== set up fast full integer search if needed / set search center =====
  856.   if (!search_setup_done[list][ref])
  857.   {
  858.     SetupFastFullPelSearch (currMB, ref, list);
  859.   }
  861.   offset_x = search_center_x[list][ref] - img->opix_x;
  862.   offset_y = search_center_y[list][ref] - img->opix_y;
  864.   //===== cost for (0,0)-vector: it is done before, because MVCost can be negative =====
  865.   if (!params->rdopt)
  866.   {
  867.     mcost = block_sad[pos_00[list][ref]] + MV_COST_SMP (lambda_factor, 0, 0, pred_mv[0], pred_mv[1]);
  869.     if (mcost < min_mcost)
  870.     {
  871.       min_mcost = mcost;
  872.       best_pos  = pos_00[list][ref];
  873.     }
  874.   }
  876.   //===== loop over all search positions =====
  877.   for (pos=0; pos<max_pos; pos++, block_sad++)
  878.   {
  879.     //--- check residual cost ---
  880.     if (*block_sad < min_mcost)
  881.     {
  882.       //--- get motion vector cost ---
  883.       cand_x = (offset_x + spiral_search_x[pos])<<2;
  884.       cand_y = (offset_y + spiral_search_y[pos])<<2;
  885.       mcost  = *block_sad;
  886.       mcost += MV_COST_SMP (lambda_factor, cand_x, cand_y, pred_mv[0], pred_mv[1]);
  888.       //--- check motion cost ---
  889.       if (mcost < min_mcost)
  890.       {
  891.         min_mcost = mcost;
  892.         best_pos  = pos;
  893.       }
  894.     }
  895.   }
  897.   //===== set best motion vector and return minimum motion cost =====
  898.   mv[0] = offset_x + spiral_search_x[best_pos];
  899.   mv[1] = offset_y + spiral_search_y[best_pos];
  900.   return min_mcost;
  901. }