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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mv-search.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：56k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mv-search.c：源码内容
  1. /*
  2. ***********************************************************************
  3. * COPYRIGHT AND WARRANTY INFORMATION
  4. *
  5. * Copyright 2001, International Telecommunications Union, Geneva
  6. *
  7. * DISCLAIMER OF WARRANTY
  8. *
  9. * These software programs are available to the user without any
  10. * license fee or royalty on an "as is" basis. The ITU disclaims
  11. * any and all warranties, whether express, implied, or
  12. * statutory, including any implied warranties of merchantability
  13. * or of fitness for a particular purpose.  In no event shall the
  14. * contributor or the ITU be liable for any incidental, punitive, or
  15. * consequential damages of any kind whatsoever arising from the
  16. * use of these programs.
  17. *
  18. * This disclaimer of warranty extends to the user of these programs
  19. * and user's customers, employees, agents, transferees, successors,
  20. * and assigns.
  21. *
  22. * The ITU does not represent or warrant that the programs furnished
  23. * hereunder are free of infringement of any third-party patents.
  24. * Commercial implementations of ITU-T Recommendations, including
  25. * shareware, may be subject to royalty fees to patent holders.
  26. * Information regarding the ITU-T patent policy is available from
  27. * the ITU Web site at http://www.itu.int.
  28. *
  29. * THIS IS NOT A GRANT OF PATENT RIGHTS - SEE THE ITU-T PATENT POLICY.
  30. ************************************************************************
  31. */
  33. /*!
  34.  *************************************************************************************
  35.  * file mv-search.c
  36.  *
  37.  * brief
  38.  *    Motion Vector Search, unified for B and P Pictures
  39.  *
  40.  * author
  41.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  42.  *      - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  43.  *      - Inge Lille-Lang鴜               <inge.lille-langoy@telenor.com>
  44.  *      - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  45.  *      - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  46.  *      - Jani Lainema                    <jani.lainema@nokia.com>
  47.  *      - Detlev Marpe                    <marpe@hhi.de>
  48.  *      - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
  49.  *      - Heiko Schwarz                   <hschwarz@hhi.de>
  50.  *
  51.  *************************************************************************************
  52.  * todo
  53.  *   6. Unite the 1/2, 1/4 and1/8th pel search routines into a single routine       n
  54.  *   7. Clean up parameters, use sensemaking variable names                         n
  55.  *   9. Implement fast leaky search, such as UBCs Diamond search
  56.  *
  57.  *************************************************************************************
  58. */
  60. #include "contributors.h"
  62. #include <math.h>
  63. #include <stdlib.h>
  64. #include <assert.h>
  66. #include "global.h"
  67. #include "mv-search.h"
  68. #include "refbuf.h"
  71. // Local function declarations
  73. __inline int ByteAbs (int foo);
  75. // These procedure pointers are used by motion_search() and one_eigthpel()
  76. static pel_t (*PelY_18) (pel_t**, int, int);
  77. static pel_t (*PelY_14) (pel_t**, int, int);
  78. static pel_t *(*PelYline_11) (pel_t *, int, int);
  80. //! The Spiral for spiral search
  81. static int SpiralX[6561];
  82. static int SpiralY[6561];
  84. /*! The bit usage for MVs (currently lives in img-> mv_bituse and is used by
  85.     b_frame.c, but should move one day to a more appropriate place */
  86. static int *MVBitUse;
  88. // Statistics, temporary
  91. /*!
  92.  ***********************************************************************
  93.  * brief
  94.  *    MV Cost returns the initial penalty for the motion vector representation.
  95.  *    Used by the various MV search routines for MV RD optimization
  96.  *
  97.  * param ParameterResolution
  98.  *    the resolution of the vector parameter, 1, 2, 4, 8, eg 4 means 1/4 pel
  99.  * param BitstreamResolution
  100.  *    the resolyution in which the bitstream is coded
  101.  * param ParameterResolution
  102.  *    TargetResolution
  103.  * param pred_x, pred_y
  104.  *    Predicted vector in BitstreamResolution
  105.  * param Candidate_x, Candidate_y
  106.  *    Candidate vector in Parameter Resolution
  107.  ***********************************************************************
  108.  */
  109. static int MVCost (int ParameterResolution, int BitstreamResolution,
  110.                    int Blocktype, int qp,
  111.                    int Pred_x, int Pred_y,
  112.                    int Candidate_x, int Candidate_y)
  113. {
  115.   int Factor = BitstreamResolution/ParameterResolution;
  116.   int Penalty;
  117.   int len_x, len_y;
  119.   len_x = Candidate_x * Factor - Pred_x;
  120.   len_y = Candidate_y * Factor - Pred_y;
  122.   Penalty = (QP2QUANT[qp] * ( MVBitUse[absm (len_x)]+MVBitUse[absm(len_y)]) );
  124.   if (img->type != B_IMG && Blocktype == 1 && Candidate_x == 0 && Candidate_y == 0)   // 16x16 and no motion
  125.     Penalty -= QP2QUANT [qp] * 16;
  126.   return Penalty;
  127. }
  130. /*!
  131.  ***********************************************************************
  132.  * brief
  133.  *    motion vector cost for rate-distortion optimization
  134.  ***********************************************************************
  135.  */
  136. static int MVCostLambda (int shift, double lambda,
  137.        int pred_x, int pred_y, int cand_x, int cand_y)
  138. {
  139.   return (int)(lambda * (MVBitUse[absm((cand_x << shift) - pred_x)] +
  140.        MVBitUse[absm((cand_y << shift) - pred_y)]   ));
  141. }
  144. /*!
  145.  ***********************************************************************
  146.  * brief
  147.  *    setting the motion vector predictor
  148.  ***********************************************************************
  149.  */
  150. void
  151. SetMotionVectorPredictor (int pred[2], int **refFrArr, int ***tmp_mv,
  152.         int ref_frame, int mb_x, int mb_y, int blockshape_x, int blockshape_y)
  153. {
  154.   int block_x     = mb_x/BLOCK_SIZE;
  155.   int block_y = mb_y/BLOCK_SIZE;
  156.   int pic_block_x = img->block_x + block_x;
  157.   int pic_block_y = img->block_y + block_y;
  158.   int mb_nr = img->current_mb_nr;
  159.   int mb_width = img->width/16;
  160.   int mb_available_up      = (img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width]);
  161.   int mb_available_left    = (img->mb_x == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-1]);
  162.   int mb_available_upleft  = (img->mb_x == 0 || img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width-1]);
  163.   int mb_available_upright = (img->mb_x >= mb_width-1 || img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width+1]);
  164.   int block_available_up, block_available_left, block_available_upright, block_available_upleft;
  165.   int mv_a, mv_b, mv_c, mv_d, pred_vec=0;
  166.   int mvPredType, rFrameL, rFrameU, rFrameUR;
  167.   int hv;
  169.   // D B C
  170.   // A X
  172.   // 1 A, B, D are set to 0 if unavailable
  173.   // 2 If C is not available it is replaced by D
  174.   block_available_up   = mb_available_up   || (mb_y > 0);
  175.   block_available_left = mb_available_left || (mb_x > 0);
  177.   if (mb_y > 0)
  178.     block_available_upright = mb_x+blockshape_x != MB_BLOCK_SIZE ? 1 : 0;
  179.   else if (mb_x+blockshape_x != MB_BLOCK_SIZE)
  180.     block_available_upright = block_available_up;
  181.   else
  182.     block_available_upright = mb_available_upright;
  184.   if (mb_x > 0)
  185.     block_available_upleft = mb_y > 0 ? 1 : block_available_up;
  186.   else if (mb_y > 0)
  187.     block_available_upleft = block_available_left;
  188.   else
  189.     block_available_upleft = mb_available_upleft;
  191.   mvPredType = MVPRED_MEDIAN;
  193.   rFrameL    = block_available_left    ? refFrArr[pic_block_y][pic_block_x-1]   : -1;
  194.   rFrameU    = block_available_up      ? refFrArr[pic_block_y-1][pic_block_x]   : -1;
  195.   rFrameUR   = block_available_upright ? refFrArr[pic_block_y-1][pic_block_x+blockshape_x/4] :
  196.                block_available_upleft  ? refFrArr[pic_block_y-1][pic_block_x-1] : -1;
  198.   /* Prediction if only one of the neighbors uses the reference frame
  199.    * we are checking
  200.    */
  202.   if(rFrameL == ref_frame && rFrameU != ref_frame && rFrameUR != ref_frame)
  203.     mvPredType = MVPRED_L;
  204.   else if(rFrameL != ref_frame && rFrameU == ref_frame && rFrameUR != ref_frame)
  205.     mvPredType = MVPRED_U;
  206.   else if(rFrameL != ref_frame && rFrameU != ref_frame && rFrameUR == ref_frame)
  207.     mvPredType = MVPRED_UR;
  209.   // Directional predictions
  211.   else if(blockshape_x == 8 && blockshape_y == 16)
  212.   {
  213.     if(mb_x == 0)
  214.     {
  215.       if(rFrameL == ref_frame)
  216.         mvPredType = MVPRED_L;
  217.     }
  218.     else
  219.     {
  220.       if(rFrameUR == ref_frame)
  221.         mvPredType = MVPRED_UR;
  222.     }
  223.   }
  224.   else if(blockshape_x == 16 && blockshape_y == 8)
  225.   {
  226.     if(mb_y == 0)
  227.     {
  228.       if(rFrameU == ref_frame)
  229.         mvPredType = MVPRED_U;
  230.     }
  231.     else
  232.     {
  233.       if(rFrameL == ref_frame)
  234.         mvPredType = MVPRED_L;
  235.     }
  236.   }
  237.   else if(blockshape_x == 8 && blockshape_y == 4 && mb_x == 8)
  238.     mvPredType = MVPRED_L;
  239.   else if(blockshape_x == 4 && blockshape_y == 8 && mb_y == 8)
  240.     mvPredType = MVPRED_U;
  242.   for (hv=0; hv < 2; hv++)
  243.   {
  244.     mv_a = block_available_left    ? tmp_mv[hv][pic_block_y][pic_block_x-1+4]   : 0;
  245.     mv_b = block_available_up      ? tmp_mv[hv][pic_block_y-1][pic_block_x+4]   : 0;
  246.     mv_d = block_available_upleft  ? tmp_mv[hv][pic_block_y-1][pic_block_x-1+4] : 0;
  247.     mv_c = block_available_upright ? tmp_mv[hv][pic_block_y-1][pic_block_x+blockshape_x/4+4] : mv_d;
  249.     switch (mvPredType)
  250.     {
  251.     case MVPRED_MEDIAN:
  252.       if(!(block_available_upleft || block_available_up || block_available_upright))
  253.         pred_vec = mv_a;
  254.       else
  255.         pred_vec = mv_a+mv_b+mv_c-min(mv_a,min(mv_b,mv_c))-max(mv_a,max(mv_b,mv_c));
  256.       break;
  258.     case MVPRED_L:
  259.       pred_vec = mv_a;
  260.       break;
  261.     case MVPRED_U:
  262.       pred_vec = mv_b;
  263.       break;
  264.     case MVPRED_UR:
  265.       pred_vec = mv_c;
  266.       break;
  267.     default:
  268.       break;
  269.     }
  271.     pred[hv] = pred_vec;
  272.   }
  273. }
  276. #ifdef _FAST_FULL_ME_
  278. /*****
  279.  *****  static variables for fast integer motion estimation
  280.  *****
  281.  */
  282. static int  *search_setup_done;  //!< flag if all block SAD's have been calculated yet
  283. static int  *search_center_x;    //!< absolute search center for fast full motion search
  284. static int  *search_center_y;    //!< absolute search center for fast full motion search
  285. static int  *pos_00;             //!< position of (0,0) vector
  286. static int  ****BlockSAD;        //!< SAD for all blocksize, ref. frames and motion vectors
  289. /*!
  290.  ***********************************************************************
  291.  * brief
  292.  *    function creating arrays for fast integer motion estimation
  293.  ***********************************************************************
  294.  */
  295. void
  296. InitializeFastFullIntegerSearch (int search_range)
  297. {
  298.   int  i, j, k;
  299.   int  max_pos = (2*search_range+1) * (2*search_range+1);
  301.   if ((BlockSAD = (int****)malloc ((img->buf_cycle+1) * sizeof(int***))) == NULL)
  302.     no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  303.   for (i = 0; i <= img->buf_cycle; i++)
  304.   {
  305.     if ((BlockSAD[i] = (int***)malloc (8 * sizeof(int**))) == NULL)
  306.       no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  307.     for (j = 1; j < 8; j++)
  308.     {
  309.       if ((BlockSAD[i][j] = (int**)malloc (16 * sizeof(int*))) == NULL)
  310.         no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  311.       for (k = 0; k < 16; k++)
  312.       {
  313.         if ((BlockSAD[i][j][k] = (int*)malloc (max_pos * sizeof(int))) == NULL)
  314.           no_mem_exit ("InitializeFastFullIntegerSearch: BlockSAD");
  315.       }
  316.     }
  317.   }
  319.   if ((search_setup_done = (int*)malloc ((img->buf_cycle+1)*sizeof(int)))==NULL)
  320.     no_mem_exit ("InitializeFastFullIntegerSearch: search_setup_done");
  321.   if ((search_center_x = (int*)malloc ((img->buf_cycle+1)*sizeof(int)))==NULL)
  322.     no_mem_exit ("InitializeFastFullIntegerSearch: search_center_x");
  323.   if ((search_center_y = (int*)malloc ((img->buf_cycle+1)*sizeof(int)))==NULL)
  324.     no_mem_exit ("InitializeFastFullIntegerSearch: search_center_y");
  325.   if ((pos_00 = (int*)malloc ((img->buf_cycle+1)*sizeof(int)))==NULL)
  326.     no_mem_exit ("InitializeFastFullIntegerSearch: pos_00");
  327. }
  330. /*!
  331.  ***********************************************************************
  332.  * brief
  333.  *    function for deleting the arrays for fast integer motion estimation
  334.  ***********************************************************************
  335.  */
  336. void
  337. ClearFastFullIntegerSearch ()
  338. {
  339.   int  i, j, k;
  341.   for (i = 0; i <= img->buf_cycle; i++)
  342.   {
  343.     for (j = 1; j < 8; j++)
  344.     {
  345.       for (k = 0; k < 16; k++)
  346.       {
  347.         free (BlockSAD[i][j][k]);
  348.       }
  349.       free (BlockSAD[i][j]);
  350.     }
  351.     free (BlockSAD[i]);
  352.   }
  353.   free (BlockSAD);
  355.   free (search_setup_done);
  356.   free (search_center_x);
  357.   free (search_center_y);
  358.   free (pos_00);
  359. }
  362. /*!
  363.  ***********************************************************************
  364.  * brief
  365.  *    function resetting flags for fast integer motion estimation
  366.  *    (have to be called in start_macroblock())
  367.  ***********************************************************************
  368.  */
  369. void
  370. ResetFastFullIntegerSearch ()
  371. {
  372.   int i;
  373.   for (i = 0; i <= img->buf_cycle; i++)
  374.     search_setup_done [i] = 0;
  375. }
  377. /*!
  378.  ***********************************************************************
  379.  * brief
  380.  *    calculation of SAD for larger blocks on the basis of 4x4 blocks
  381.  ***********************************************************************
  382.  */
  383. void
  384. SetupLargerBlocks (int refindex, int max_pos)
  385. {
  386. #define ADD_UP_BLOCKS()   _o=*_bo; _i=*_bi; _j=*_bj; for(pos=0;pos<max_pos;pos++) *_o++ = *_i++ + *_j++;
  387. #define INCREMENT(inc)    _bo+=inc; _bi+=inc; _bj+=inc;
  389.   int    pos, **_bo, **_bi, **_bj;
  390.   register int *_o,   *_i,   *_j;
  392.   //--- blocktype 6 ---
  393.   _bo = BlockSAD[refindex][6];
  394.   _bi = BlockSAD[refindex][7];
  395.   _bj = _bi + 4;
  396.   ADD_UP_BLOCKS(); INCREMENT(1);
  397.   ADD_UP_BLOCKS(); INCREMENT(1);
  398.   ADD_UP_BLOCKS(); INCREMENT(1);
  399.   ADD_UP_BLOCKS(); INCREMENT(5);
  400.   ADD_UP_BLOCKS(); INCREMENT(1);
  401.   ADD_UP_BLOCKS(); INCREMENT(1);
  402.   ADD_UP_BLOCKS(); INCREMENT(1);
  403.   ADD_UP_BLOCKS();
  405.   //--- blocktype 5 ---
  406.   _bo = BlockSAD[refindex][5];
  407.   _bi = BlockSAD[refindex][7];
  408.   _bj = _bi + 1;
  409.   ADD_UP_BLOCKS(); INCREMENT(2);
  410.   ADD_UP_BLOCKS(); INCREMENT(2);
  411.   ADD_UP_BLOCKS(); INCREMENT(2);
  412.   ADD_UP_BLOCKS(); INCREMENT(2);
  413.   ADD_UP_BLOCKS(); INCREMENT(2);
  414.   ADD_UP_BLOCKS(); INCREMENT(2);
  415.   ADD_UP_BLOCKS(); INCREMENT(2);
  416.   ADD_UP_BLOCKS();
  418.   //--- blocktype 4 ---
  419.   _bo = BlockSAD[refindex][4];
  420.   _bi = BlockSAD[refindex][6];
  421.   _bj = _bi + 1;
  422.   ADD_UP_BLOCKS(); INCREMENT(2);
  423.   ADD_UP_BLOCKS(); INCREMENT(6);
  424.   ADD_UP_BLOCKS(); INCREMENT(2);
  425.   ADD_UP_BLOCKS();
  427.   //--- blocktype 3 ---
  428.   _bo = BlockSAD[refindex][3];
  429.   _bi = BlockSAD[refindex][4];
  430.   _bj = _bi + 8;
  431.   ADD_UP_BLOCKS(); INCREMENT(2);
  432.   ADD_UP_BLOCKS();
  434.   //--- blocktype 2 ---
  435.   _bo = BlockSAD[refindex][2];
  436.   _bi = BlockSAD[refindex][4];
  437.   _bj = _bi + 2;
  438.   ADD_UP_BLOCKS(); INCREMENT(8);
  439.   ADD_UP_BLOCKS();
  441.   //--- blocktype 1 ---
  442.   _bo = BlockSAD[refindex][1];
  443.   _bi = BlockSAD[refindex][3];
  444.   _bj = _bi + 2;
  445.   ADD_UP_BLOCKS();
  446. }
  448. /*!
  449.  ***********************************************************************
  450.  * brief
  451.  *    calculation of all SAD's (for all motion vectors and 4x4 blocks)
  452.  ***********************************************************************
  453.  */
  454. void
  455. SetupFastFullIntegerSearch (int      refframe,
  456.                             int    **refFrArr,
  457.                             int   ***tmp_mv,
  458.                             int *****img_mv,
  459.                             pel_t   *CurrRefPic,
  460.                             int      search_range,
  461.                             int      backward,
  462.                             int      rdopt)
  463. // Note: All Vectors in this function are full pel only.
  464. {
  465.   int     x, y, pos, blky, bindex;
  466.   int Absolute_X, Absolute_Y;
  467.   int LineSadBlk0, LineSadBlk1, LineSadBlk2, LineSadBlk3;
  468.   int     range_partly_outside, offset_x, offset_y, ref_x, ref_y;
  469.   int refindex     = backward ? img->buf_cycle : refframe;
  470.   int max_width    = img->width  - 17;
  471.   int max_height   = img->height - 17;
  472.   int max_pos      = (2*search_range+1) * (2*search_range+1);
  473.   int     mv_mul       = input->mv_res ? 2 : 1;
  474.   int   **block_sad    = BlockSAD[refindex][7];
  475.   pel_t   orig_blocks [256];
  477.   register pel_t  *orgptr = orig_blocks;
  478.   register pel_t  *refptr;
  481.   //===== get search center: predictor of 16x16 block =====
  482.   SetMotionVectorPredictor (img_mv[0][0][refframe][1], refFrArr, tmp_mv,
  483.           refframe, 0, 0, 16, 16);
  484.   search_center_x[refindex] = img_mv[0][0][refframe][1][0] / (mv_mul*4);
  485.   search_center_y[refindex] = img_mv[0][0][refframe][1][1] / (mv_mul*4);
  486.   if (!rdopt)
  487.   {
  488.     // correct center so that (0,0) vector is inside
  489.     search_center_x[refindex] = max(-search_range, min(search_range, search_center_x[refindex]));
  490.     search_center_y[refindex] = max(-search_range, min(search_range, search_center_y[refindex]));
  491.   }
  492.   search_center_x[refindex] += img->pix_x;
  493.   search_center_y[refindex] += img->pix_y;
  494.   offset_x = search_center_x[refindex];
  495.   offset_y = search_center_y[refindex];
  498.   //===== copy original block for fast access =====
  499.   for   (y = img->pix_y; y < img->pix_y+16; y++)
  500.     for (x = img->pix_x; x < img->pix_x+16; x++)
  501.       *orgptr++ = imgY_org [y][x];
  504.   //===== check if whole search range is inside image =====
  505.   if (offset_x >= search_range      &&
  506.       offset_y >= search_range      &&
  507.       offset_x <= max_width  - search_range &&
  508.       offset_y <= max_height - search_range)
  509.   {
  510.     range_partly_outside = 0; PelYline_11 = FastLine16Y_11;
  511.   }
  512.   else
  513.     range_partly_outside = 1;
  516.   //===== determine position of (0,0)-vector =====
  517.   if (!rdopt)
  518.   {
  519.     ref_x = img->pix_x - offset_x;
  520.     ref_y = img->pix_y - offset_y;
  522.     for (pos = 0; pos < max_pos; pos++)
  523.       if (ref_x == SpiralX[pos] &&
  524.           ref_y == SpiralY[pos])
  525.       {
  526.         pos_00[refindex] = pos;
  527.         break;
  528.       }
  529.   }
  532.   //===== loop over search range (spiral search): get blockwise SAD =====
  533.   for (pos = 0; pos < max_pos; pos++)
  534.   {
  535.     Absolute_Y = offset_y + SpiralY[pos];
  536.     Absolute_X = offset_x + SpiralX[pos];
  538.     if (range_partly_outside)
  539.     {
  540.       if (Absolute_Y >= 0 && Absolute_Y <= max_height &&
  541.           Absolute_X >= 0 && Absolute_X <= max_width    )
  542.         PelYline_11 = FastLine16Y_11;
  543.       else
  544.         PelYline_11 = UMVLine16Y_11;
  545.     }
  547.     orgptr = orig_blocks;
  548.     bindex = 0;
  549.     for (blky = 0; blky < 4; blky++)
  550.     {
  551.       LineSadBlk0 = LineSadBlk1 = LineSadBlk2 = LineSadBlk3 = 0;
  552.       for (y = 0; y < 4; y++)
  553.       {
  554.         refptr = PelYline_11 (CurrRefPic, Absolute_Y++, Absolute_X);
  556.         LineSadBlk0 += ByteAbs(*refptr++ - *orgptr++);
  557.         LineSadBlk0 += ByteAbs(*refptr++ - *orgptr++);
  558.         LineSadBlk0 += ByteAbs(*refptr++ - *orgptr++);
  559.         LineSadBlk0 += ByteAbs(*refptr++ - *orgptr++);
  560.         LineSadBlk1 += ByteAbs(*refptr++ - *orgptr++);
  561.         LineSadBlk1 += ByteAbs(*refptr++ - *orgptr++);
  562.         LineSadBlk1 += ByteAbs(*refptr++ - *orgptr++);
  563.         LineSadBlk1 += ByteAbs(*refptr++ - *orgptr++);
  564.         LineSadBlk2 += ByteAbs(*refptr++ - *orgptr++);
  565.         LineSadBlk2 += ByteAbs(*refptr++ - *orgptr++);
  566.         LineSadBlk2 += ByteAbs(*refptr++ - *orgptr++);
  567.         LineSadBlk2 += ByteAbs(*refptr++ - *orgptr++);
  568.         LineSadBlk3 += ByteAbs(*refptr++ - *orgptr++);
  569.         LineSadBlk3 += ByteAbs(*refptr++ - *orgptr++);
  570.         LineSadBlk3 += ByteAbs(*refptr++ - *orgptr++);
  571.         LineSadBlk3 += ByteAbs(*refptr++ - *orgptr++);
  572.       }
  573.       block_sad[bindex++][pos] = LineSadBlk0;
  574.       block_sad[bindex++][pos] = LineSadBlk1;
  575.       block_sad[bindex++][pos] = LineSadBlk2;
  576.       block_sad[bindex++][pos] = LineSadBlk3;
  577.     }
  578.   }
  581.   //===== combine SAD's for larger block types =====
  582.   SetupLargerBlocks (refindex, max_pos);
  585.   //===== set flag marking that search setup have been done =====
  586.   search_setup_done[refindex] = 1;
  587. }
  589. /*!
  590.  ***********************************************************************
  591.  * brief
  592.  *    fast full integer search (SetupFastFullIntegerSearch have to be called before)
  593.  ***********************************************************************
  594.  */
  595. int
  596. FastFullIntegerSearch (int    mv_mul,
  597.                        int    predicted_x,
  598.                        int    predicted_y,
  599.                        int    search_range,
  600.                        int    refindex,
  601.                        int    blocktype,
  602.                        int    mb_x,
  603.                        int    mb_y,
  604.                        int    *center_h2,
  605.                        int    *center_v2,
  606.                        int    pic_pix_x,
  607.                        int    pic_pix_y,
  608.                        double lambda)
  609. {
  610. // Note: All Vectors in this function are full pel only.
  612.   int Candidate_X, Candidate_Y, current_inter_sad;
  613.   int mvres          = mv_mul==1 ? 4 : 8;
  614.   int mvres_l        = mv_mul==1 ? 2 : 3;
  615.   int Offset_X     = search_center_x[refindex] - img->pix_x;
  616.   int Offset_Y       = search_center_y[refindex] - img->pix_y;
  617.   int best_inter_sad = MAX_VALUE;
  618.   int bindex        = mb_y + (mb_x >> 2);
  620.   register int  pos;
  621.   register int  max_pos   = (2*search_range+1)*(2*search_range+1);
  622.   register int *block_sad = BlockSAD[refindex][blocktype][bindex];
  625.   //===== cost for (0,0)-vector: it is done before, because MVCost can be negative =====
  626.   if (!lambda)
  627.   {
  628.     *center_h2     = 0;
  629.     *center_v2     = 0;
  630.     best_inter_sad = block_sad[pos_00[refindex]] + MVCost(1, mvres, blocktype, img->qp, predicted_x, predicted_y, 0, 0);
  631.   }
  634.   //===== loop over search range (spiral search) =====
  635.   if (lambda)
  636.   {
  637.     for (pos = 0; pos < max_pos; pos++, block_sad++)
  638.       if (*block_sad < best_inter_sad)
  639.       {
  640.         Candidate_X        = Offset_X + SpiralX[pos];
  641.         Candidate_Y        = Offset_Y + SpiralY[pos];
  642.         current_inter_sad  = *block_sad;
  643.         current_inter_sad += MVCostLambda (mvres_l, lambda, predicted_x, predicted_y, Candidate_X, Candidate_Y);
  645.         if (current_inter_sad < best_inter_sad)
  646.         {
  647.           *center_h2     = Candidate_X;
  648.           *center_v2     = Candidate_Y;
  649.           best_inter_sad = current_inter_sad;
  650.         }
  651.       }
  652.   }
  653.   else
  654.   {
  655.     for (pos = 0; pos < max_pos; pos++, block_sad++)
  656.       if (*block_sad < best_inter_sad)
  657.       {
  658.         Candidate_X        = Offset_X + SpiralX[pos];
  659.         Candidate_Y        = Offset_Y + SpiralY[pos];
  660.         current_inter_sad  = *block_sad;
  661.         current_inter_sad += MVCost (1, mvres, blocktype, img->qp, predicted_x, predicted_y, Candidate_X, Candidate_Y);
  663.         if (current_inter_sad < best_inter_sad)
  664.         {
  665.           *center_h2     = Candidate_X;
  666.           *center_v2     = Candidate_Y;
  667.           best_inter_sad = current_inter_sad;
  668.         }
  669.       }
  670.   }
  672.   return best_inter_sad;
  673. }
  677. #endif // _FAST_FULL_ME_
  680. /*!
  681.  ***********************************************************************
  682.  * brief
  683.  *    Integer Spiral Search
  684.  * par Output:
  685.  *    best_inter_sad
  686.  * par Output (through Parameter pointers):
  687.  *    center_h2, center_v2 (if better MV was found)
  688.  ***********************************************************************
  689.  */
  690. int IntegerSpiralSearch ( int mv_mul, int center_x, int center_y,
  691.                           int predicted_x, int predicted_y,
  692.                           int blockshape_x, int blockshape_y,
  693.                           int curr_search_range, int blocktype,
  694.                           pel_t mo[16][16], pel_t *FullPelCurrRefPic,
  695.                           int *center_h2, int *center_v2,
  696.                           int pic_pix_x, int pic_pix_y,
  697.                           double lambda)
  698. {
  699. // Note: All Vectors in this function are full pel only.
  701.   int numc, lv;
  702.   int best_inter_sad = MAX_VALUE;
  703.   int abort_search;
  704.   int current_inter_sad;
  705.   int Candidate_X, Candidate_Y, Absolute_X, Absolute_Y;
  706.   int i, x, y;
  707.   int Difference;
  708.   pel_t SingleDimensionMo[16*16];
  709.   pel_t *check;
  711.   numc=(curr_search_range*2+1)*(curr_search_range*2+1);
  713.   // Setup a fast access field for the original
  714.   for (y=0, i=0; y<blockshape_y; y++)
  715.     for (x=0; x<blockshape_x; x++)
  716.       SingleDimensionMo[i++] = mo[y][x];
  718.   for (lv=0; lv < numc; lv++)
  719.   {
  720.     Candidate_X = center_x + SpiralX[lv];
  721.     Candidate_Y = center_y + SpiralY[lv];
  722.     Absolute_X = pic_pix_x + Candidate_X;
  723.     Absolute_Y = pic_pix_y + Candidate_Y;
  725.     if (lambda)
  726.       current_inter_sad = MVCostLambda (mv_mul==1?2:3, lambda, predicted_x, predicted_y, Candidate_X, Candidate_Y);
  727.     else
  728.       current_inter_sad = MVCost (1, (mv_mul==1)?4:8, blocktype, img->qp, predicted_x, predicted_y, Candidate_X,Candidate_Y);
  731.     abort_search=FALSE;
  734.     for (y=0, i=0; y < blockshape_y && !abort_search; y++)
  735.     {
  736.       check = PelYline_11 (FullPelCurrRefPic, Absolute_Y+y, Absolute_X);      // get pointer to line
  737.       for (x=0; x < blockshape_x ;x++)
  738.       {
  739.         Difference = SingleDimensionMo[i++]- *check++;
  740.         current_inter_sad += ByteAbs (Difference);
  741.       }
  742.       if (current_inter_sad >= best_inter_sad)
  743.       {
  744.         abort_search=TRUE;
  745.       }
  746.     }
  748.     if(!abort_search)
  749.     {
  750.       *center_h2=Candidate_X;
  751.       *center_v2=Candidate_Y;
  752.       best_inter_sad=current_inter_sad;
  753.     }
  754.   }
  755.   return best_inter_sad;
  756. }
  759. /*!
  760.  ***********************************************************************
  761.  * brief
  762.  *    Half Pel Search
  763.  ***********************************************************************
  764.  */
  765. int HalfPelSearch(int pic4_pix_x, int pic4_pix_y, int mv_mul, int blockshape_x, int blockshape_y,
  766.       int *s_pos_x1, int *s_pos_y1, int *s_pos_x2, int *s_pos_y2, int center_h2, int center_v2,
  767.       int predicted_x, int predicted_y, int blocktype, pel_t mo[16][16], pel_t **CurrRefPic, int ***tmp_mv,
  768.       int *****all_mv, int block_x, int block_y, int ref_frame, int pic_block_x, int pic_block_y,
  769.       double lambda)
  770. {
  771.   int best_inter_sad=MAX_VALUE;
  772.   int current_inter_sad;
  773.   int lv, iy0, jy0, vec1_x, vec1_y, vec2_x, vec2_y, i, i22, j;
  774.   int s_pos_x, s_pos_y;
  775.   int  m7[16][16];
  777.   for (lv=0; lv < 9; lv++)
  778.   {
  779.     s_pos_x=center_h2+SpiralX[lv]*2;
  780.     s_pos_y=center_v2+SpiralY[lv]*2;
  781.     iy0=pic4_pix_x+s_pos_x;
  782.     jy0=pic4_pix_y+s_pos_y;
  784.     if (lambda)
  785.       current_inter_sad = MVCostLambda (mv_mul==1?0:1, lambda,
  786.       predicted_x, predicted_y, s_pos_x, s_pos_y);
  787.     else
  788.       current_inter_sad = MVCost (4, (mv_mul==1)?4:8, blocktype, img->qp, predicted_x, predicted_y, s_pos_x, s_pos_y);
  790.     for (vec1_x=0; vec1_x < blockshape_x; vec1_x += 4)
  791.     {
  792.       for (vec1_y=0; vec1_y < blockshape_y; vec1_y += 4)
  793.       {
  794.         for (i=0; i < BLOCK_SIZE; i++)
  795.         {
  796.           vec2_x=i+vec1_x;
  797.           i22=iy0+vec2_x*4;
  798.           for (j=0; j < BLOCK_SIZE; j++)
  799.           {
  800.             vec2_y=j+vec1_y;
  801.             m7[i][j]=mo[vec2_y][vec2_x]-PelY_14 (CurrRefPic, jy0+vec2_y*4, i22);
  802.           }
  803.         }
  804.         current_inter_sad += find_sad(input->hadamard, m7);
  805.       }
  806.     }
  807.     if (current_inter_sad < best_inter_sad)
  808.     {
  809.       *s_pos_x1=s_pos_x;
  810.       *s_pos_y1=s_pos_y;
  811.       *s_pos_x2=s_pos_x;
  812.       *s_pos_y2=s_pos_y;
  814.       for (i=0; i < blockshape_x/BLOCK_SIZE; i++)
  815.       {
  816.         for (j=0; j < blockshape_y/BLOCK_SIZE; j++)
  817.         {
  818.           all_mv[block_x+i][block_y+j][ref_frame][blocktype][0]=mv_mul**s_pos_x1;
  819.           all_mv[block_x+i][block_y+j][ref_frame][blocktype][1]=mv_mul**s_pos_y1;
  821.           tmp_mv[0][pic_block_y+j][pic_block_x+i+BLOCK_SIZE]=mv_mul**s_pos_x1;
  822.           tmp_mv[1][pic_block_y+j][pic_block_x+i+BLOCK_SIZE]=mv_mul**s_pos_y1;
  823.         }
  824.       }
  825.       best_inter_sad=current_inter_sad;
  826.     }
  827.   }
  828.   return best_inter_sad;
  829. }
  832. /*!
  833.  ***********************************************************************
  834.  * brief
  835.  *    Quarter Pel Search
  836.  ***********************************************************************
  837.  */
  838. int QuarterPelSearch(int pic4_pix_x, int pic4_pix_y, int mv_mul, int blockshape_x, int blockshape_y,
  839.         int *s_pos_x1, int *s_pos_y1, int *s_pos_x2, int *s_pos_y2, int center_h2, int center_v2,
  840.         int predicted_x, int predicted_y, int blocktype, pel_t mo[16][16], pel_t **CurrRefPic, int ***tmp_mv,
  841.         int *****all_mv, int block_x, int block_y, int ref_frame,
  842.         int pic_block_x, int pic_block_y, int best_inter_sad,
  843.         double lambda
  844.         )
  845. {
  846.   int current_inter_sad;
  847.   int lv, s_pos_x, s_pos_y, iy0, jy0, vec1_x, vec1_y, vec2_x, vec2_y, i, i22, j;
  848.   int  m7[16][16];
  850.   for (lv=1; lv < 9; lv++)
  851.   {
  853.     s_pos_x=*s_pos_x2+SpiralX[lv];
  854.     s_pos_y=*s_pos_y2+SpiralY[lv];
  856.     iy0=pic4_pix_x+s_pos_x;
  857.     jy0=pic4_pix_y+s_pos_y;
  859.     if (lambda)
  860.       current_inter_sad = MVCostLambda (mv_mul==1?0:1, lambda,
  861.                                         predicted_x, predicted_y, s_pos_x, s_pos_y);
  862.     else
  863.       current_inter_sad = MVCost (4, (mv_mul==1)?4:8, blocktype, img->qp, predicted_x, predicted_y, s_pos_x, s_pos_y);
  865.     for (vec1_x=0; vec1_x < blockshape_x; vec1_x += 4)
  866.     {
  867.       for (vec1_y=0; vec1_y < blockshape_y; vec1_y += 4)
  868.       {
  869.         for (i=0; i < BLOCK_SIZE; i++)
  870.         {
  871.           vec2_x=i+vec1_x;
  872.           i22=iy0+vec2_x*4;
  873.           for (j=0; j < BLOCK_SIZE; j++)
  874.           {
  875.             vec2_y=j+vec1_y;
  876.             m7[i][j]=mo[vec2_y][vec2_x]-PelY_14 (CurrRefPic, jy0+vec2_y*4, i22);
  877.           }
  878.         }
  879.         current_inter_sad += find_sad(input->hadamard, m7);
  880.       }
  881.     }
  882.     if (current_inter_sad < best_inter_sad)
  883.     {
  884.       // Vectors are saved in all_mv[] to be able to assign correct vectors to each block after mode selection.
  885.       // tmp_mv[] is a 'temporary' assignment of vectors to be used to estimate 'bit cost' in vector prediction.
  887.       *s_pos_x1=s_pos_x;
  888.       *s_pos_y1=s_pos_y;
  890.       for (i=0; i < blockshape_x/BLOCK_SIZE; i++)
  891.       {
  892.         for (j=0; j < blockshape_y/BLOCK_SIZE; j++)
  893.         {
  894.           all_mv[block_x+i][block_y+j][ref_frame][blocktype][0]=mv_mul**s_pos_x1;
  895.           all_mv[block_x+i][block_y+j][ref_frame][blocktype][1]=mv_mul**s_pos_y1;
  896.           tmp_mv[0][pic_block_y+j][pic_block_x+i+BLOCK_SIZE]=mv_mul**s_pos_x1;
  897.           tmp_mv[1][pic_block_y+j][pic_block_x+i+BLOCK_SIZE]=mv_mul**s_pos_y1;
  898.         }
  899.       }
  900.       best_inter_sad=current_inter_sad;
  901.     }
  902.   }
  904.   *s_pos_x2 = 2 * *s_pos_x1;
  905.   *s_pos_y2 = 2 * *s_pos_y1;
  907.   return best_inter_sad;
  908. }
  911. /*!
  912.  ***********************************************************************
  913.  * brief
  914.  *    Eighth Pel Search
  915.  ***********************************************************************
  916.  */
  917. int EighthPelSearch(int pic8_pix_x, int pic8_pix_y, int mv_mul, int blockshape_x, int blockshape_y,
  918.        int *s_pos_x1, int *s_pos_y1, int *s_pos_x2, int *s_pos_y2, int center_h2, int center_v2,
  919.        int predicted_x, int predicted_y, int blocktype, pel_t mo[16][16], pel_t **CurrRefPic, int ***tmp_mv,
  920.        int *****all_mv, int block_x, int block_y, int ref_frame,
  921.        int pic_block_x, int pic_block_y, int best_inter_sad,
  922.        double lambda
  923.        )
  924. {
  925.   int current_inter_sad;
  926.   int lv, s_pos_x, s_pos_y, iy0, jy0, vec1_x, vec1_y, vec2_x, vec2_y, i, i22, j;
  927.   int  m7[16][16];
  929.   for (lv=1; lv < 9; lv++)
  930.   {
  931.     s_pos_x=*s_pos_x2+SpiralX[lv];
  932.     s_pos_y=*s_pos_y2+SpiralY[lv];
  934.     iy0=pic8_pix_x+s_pos_x;
  935.     jy0=pic8_pix_y+s_pos_y;
  937.     if (lambda)
  938.       current_inter_sad = MVCostLambda (0, lambda,
  939.       predicted_x, predicted_y, s_pos_x, s_pos_y);
  940.     else
  941.       current_inter_sad = MVCost (8, 8, blocktype, img->qp, predicted_x, predicted_y, s_pos_x, s_pos_y);
  943.     for (vec1_x=0; vec1_x < blockshape_x; vec1_x += 4)
  944.     {
  945.       for (vec1_y=0; vec1_y < blockshape_y; vec1_y += 4)
  946.       {
  947.         for (i=0; i < BLOCK_SIZE; i++)
  948.         {
  949.           vec2_x=i+vec1_x;
  950.           i22=iy0+vec2_x*8;
  951.           for (j=0; j < BLOCK_SIZE; j++)
  952.           {
  953.             vec2_y=j+vec1_y;
  954.             m7[i][j]=mo[vec2_y][vec2_x]-PelY_18 (CurrRefPic, jy0+vec2_y*8, i22);
  955.           }
  956.         }
  957.         current_inter_sad += find_sad(input->hadamard, m7);
  958.       }
  959.     }
  960.     if (current_inter_sad < best_inter_sad)
  961.     {
  962.       // Vectors are saved in all_mv[] to be able to assign correct vectors to each block after mode selection.
  963.       // tmp_mv[] is a 'temporary' assignment of vectors to be used to estimate 'bit cost' in vector prediction.
  965.       *s_pos_x1=s_pos_x;
  966.       *s_pos_y1=s_pos_y;
  968.       for (i=0; i < blockshape_x/BLOCK_SIZE; i++)
  969.       {
  970.         for (j=0; j < blockshape_y/BLOCK_SIZE; j++)
  971.         {
  972.           all_mv[block_x+i][block_y+j][ref_frame][blocktype][0]=*s_pos_x1;
  973.           all_mv[block_x+i][block_y+j][ref_frame][blocktype][1]=*s_pos_y1;
  974.           tmp_mv[0][pic_block_y+j][pic_block_x+i+BLOCK_SIZE]=*s_pos_x1;
  975.           tmp_mv[1][pic_block_y+j][pic_block_x+i+BLOCK_SIZE]=*s_pos_y1;
  976.         }
  977.       }
  978.       best_inter_sad=current_inter_sad;
  979.     }
  980.   }
  981.   return best_inter_sad;
  982. }
  985. #define PFRAME    0
  986. #define B_FORWARD 1
  987. #define B_BACKWARD  2
  989. /*!
  990.  ************************************************************************
  991.  * brief
  992.  *    In this routine motion search (integer pel+1/2 and 1/4 pel) and mode selection
  993.  *    is performed. Since we treat all 4x4 blocks before coding/decoding the
  994.  *    prediction may not be based on decoded pixels (except for some of the blocks).
  995.  *    This will result in too good prediction.  To compensate for this the SAD for
  996.  *    intra(tot_intra_sad) is given a 'handicap' depending on QP.
  997.  *                                                                                     par
  998.  *    Note that a couple of speed improvements were implemented by StW, which
  999.  *    slightly change the use of some variables.  In particular, the dimensions
  1000.  *    of the img->m7 and mo[] variables were changed in order to allow better
  1001.  *    cache access.
  1002.  *                                                                                     par
  1003.  *    Depending on the MV-resolution 1/4-pel or 1/8-pel motion vectors are estimated
  1004.  *                                                                                     par
  1005.  * par Input:
  1006.  *    Best intra SAD value.
  1007.  *
  1008.  * par Output:
  1009.  *    Reference image.
  1010.  *
  1011.  * par Side Effects:
  1012.  *    writes refFrArr[ ][ ] to set reference frame ID for each block
  1013.  *
  1014.  *  par Bugs and Limitations:
  1015.  *    currently the B-frame module does not support UMV in its residual coding.
  1016.  *    Hence, the old search range limitation is implemented here for all B frames.
  1017.  *    The if()s in question all start in column 1 of the file and are thus
  1018.  *    easily idetifyable.
  1019.  *
  1020.  ************************************************************************
  1021.  */
  1023. int
  1024. UnifiedMotionSearch (int tot_intra_sad, int **refFrArr, int ***tmp_mv,
  1025.          int *****img_mv,
  1026.          int *img_mb_mode, int *img_blc_size_h, int *img_blc_size_v,
  1027.          int *img_multframe_no, int BFrame, int *min_inter_sad, int *****all_mv)
  1028. {
  1029.   int predframe_no=0;
  1030.   int ref_frame,blocktype;
  1031.   int tot_inter_sad;
  1032.   int ref_inx;
  1034.   *min_inter_sad = MAX_VALUE;
  1037.   // Loop through all reference frames under consideration
  1038.   // P-Frames, B-Forward: All reference frames
  1039.   // P-Backward: use only the last reference frame, stored in mref_P
  1040.   
  1042. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  1043.   for (ref_frame=0; ref_frame < img->nb_references; ref_frame++)
  1044.     if ((ref_frame <  input->no_multpred) || (ref_frame == input->add_ref_frame))
  1045. #else
  1046.   for (ref_frame=0; ref_frame < img->nb_references; ref_frame++)
  1047. #endif
  1049.   {
  1050.     ref_inx = (img->number-ref_frame-1)%img->buf_cycle;
  1052.     //  Looping through all the chosen block sizes:
  1053.     blocktype=1;
  1054.     while (input->blc_size[blocktype][0]==0 && blocktype<=7) // skip blocksizes not chosen
  1055.       blocktype++;
  1057.     for (;blocktype <= 7;)
  1058.     {
  1059.       tot_inter_sad  = QP2QUANT[img->qp] * min(ref_frame,1) * 2; // start 'handicap '
  1060.       tot_inter_sad += SingleUnifiedMotionSearch (ref_frame, blocktype,
  1061.         refFrArr, tmp_mv, img_mv,
  1062.         BFrame, all_mv, 0.0);
  1064.         /*
  1065.         Here we update which is the best inter mode. At the end we have the best inter mode.
  1066.         predframe_no:  which reference frame to use for prediction
  1067.         img->multframe_no:  Index in the mref[] matrix used for prediction
  1068.       */
  1070.       if (tot_inter_sad <= *min_inter_sad)
  1071.       {
  1072.         if (BFrame==PFRAME)
  1073.           *img_mb_mode=blocktype;
  1074.         if (BFrame == B_FORWARD)
  1075.         {
  1076.           if (blocktype == 1)
  1077.             *img_mb_mode = blocktype;
  1078.           else
  1079.             *img_mb_mode = blocktype * 2;
  1080.         }
  1081.         if (BFrame == B_BACKWARD)
  1082.         {
  1083.           if (blocktype == 1)
  1084.             *img_mb_mode = blocktype+1;
  1085.           else
  1086.             *img_mb_mode = blocktype * 2+1;
  1088.         }
  1089.         *img_blc_size_h=input->blc_size[blocktype][0];
  1090.         *img_blc_size_v=input->blc_size[blocktype][1];
  1091.         predframe_no=ref_frame;
  1092.         *img_multframe_no=ref_inx;
  1093.         *min_inter_sad=tot_inter_sad;
  1094.       }
  1096.       while (input->blc_size[++blocktype][0]==0 && blocktype<=7); // only go through chosen blocksizes
  1097.     }
  1098.     if (BFrame == B_BACKWARD)
  1099.       ref_frame = MAX_VALUE;    // jump out of the loop
  1100.   }
  1102.   return predframe_no;
  1103. }
  1107. /*!
  1108.  ************************************************************************
  1109.  * brief
  1110.  *    unified motion search for a single combination of reference frame and blocksize
  1111.  ************************************************************************
  1112.  */
  1113. int
  1114. SingleUnifiedMotionSearch (int    ref_frame,
  1115.                            int    blocktype,
  1116.                            int  **refFrArr,
  1117.                            int ***tmp_mv,
  1118.                            int    *****img_mv,
  1119.                            int    BFrame,
  1120.                            int    *****all_mv,
  1121.                            double lambda)
  1122. {
  1123.   int   j,i;
  1124.   int   pic_block_x,pic_block_y,block_x,ref_inx,block_y,pic_pix_y;
  1125.   int   pic4_pix_y,pic8_pix_y,pic_pix_x,pic4_pix_x,pic8_pix_x;
  1126.   int   ip0,ip1;
  1127.   int   center_h2,curr_search_range,center_v2;
  1128.   int   s_pos_x1,s_pos_y1,s_pos_x2,s_pos_y2;
  1129.   int   mb_y,mb_x;
  1130.   int   best_inter_sad, tot_inter_sad = 0;
  1131.   pel_t mo[16][16];
  1132.   int   blockshape_x,blockshape_y;
  1133.   int   mv_mul;
  1134.   pel_t **CurrRefPic;
  1135.   pel_t *CurrRefPic11;
  1136. #ifdef _FAST_FULL_ME_
  1137.   int  refindex, full_search_range;
  1138. #else
  1139.   int    center_x, center_y;
  1140. #endif
  1144.   /*  curr_search_range is the actual search range used depending on block size and reference frame.
  1145.   It may be reduced by 1/2 or 1/4 for smaller blocks and prediction from older frames due to compexity
  1146.   */
  1147. #ifdef _FULL_SEARCH_RANGE_
  1148.   if (input->full_search == 2) // no restrictions at all
  1149.   {
  1150.     curr_search_range = input->search_range;
  1151.   }
  1152.   else if (input->full_search == 1) // smaller search range for older reference frames
  1153.   {
  1154.     curr_search_range = input->search_range /  (min(ref_frame,1)+1);
  1155.   }
  1156.   else // smaller search range for older reference frames and smaller blocks
  1157. #endif
  1158.   {
  1159.     curr_search_range = input->search_range / ((min(ref_frame,1)+1) * min(2,blocktype));
  1160.   }
  1161. #ifdef _FAST_FULL_ME_
  1162. #ifdef _FULL_SEARCH_RANGE_
  1163.   if (input->full_search == 2)
  1164.     full_search_range   = input->search_range;
  1165.   else
  1166. #endif
  1167.     full_search_range   = input->search_range / (min(ref_frame,1)+1);
  1168. #endif
  1172.   // Motion vector scale-factor for 1/8-pel MV-resolution
  1173.   if(input->mv_res)
  1174.     mv_mul=2;
  1175.   else
  1176.     mv_mul=1;
  1179.   // set reference frame array
  1180.   for (j = 0;j < 4;j++)
  1181.   {
  1182.     for (i = 0;i < 4;i++)
  1183.     {
  1184.       refFrArr[img->block_y+j][img->block_x+i] = ref_frame;
  1185.     }
  1186.   }
  1189.   // find  reference image
  1190.   if (BFrame != B_BACKWARD)
  1191.   {
  1192.     ref_inx=(img->number-ref_frame-1)%img->buf_cycle;
  1193.     CurrRefPic   = mref[ref_inx];
  1194.     CurrRefPic11 = Refbuf11[ref_inx];
  1195.   }
  1196.   else
  1197.   {
  1198.     CurrRefPic   = mref_P;
  1199.     CurrRefPic11 = Refbuf11_P;
  1200.   }
  1203. #ifdef _FAST_FULL_ME_
  1204.   //===== setup fast full integer search: get SAD's for all motion vectors and 4x4 blocks =====
  1205.   //      (this is done just once for a macroblock)
  1206.   refindex = (BFrame != B_BACKWARD ? ref_frame : img->buf_cycle);
  1208.   if (!search_setup_done[refindex])
  1209.   {
  1210.     SetupFastFullIntegerSearch (ref_frame, refFrArr, tmp_mv, img_mv, CurrRefPic11,
  1211.       full_search_range, (BFrame==B_BACKWARD), (lambda != 0));
  1212.   }
  1213. #endif
  1215.   blockshape_x=input->blc_size[blocktype][0];// input->blc_size has information of the 7 blocksizes
  1216.   blockshape_y=input->blc_size[blocktype][1];// array iz stores offset inside one MB
  1219.   //  Loop through the whole MB with all block sizes
  1220.   for (mb_y=0; mb_y < MB_BLOCK_SIZE; mb_y += blockshape_y)
  1221.   {
  1222.     block_y=mb_y/BLOCK_SIZE;
  1223.     pic_block_y=img->block_y+block_y;
  1224.     pic_pix_y=img->pix_y+mb_y;
  1225.     pic4_pix_y=pic_pix_y*4;
  1227.     for (mb_x=0; mb_x < MB_BLOCK_SIZE; mb_x += blockshape_x)
  1228.     {
  1229.       block_x=mb_x/BLOCK_SIZE;
  1230.       pic_block_x=img->block_x+block_x;
  1231.       pic_pix_x=img->pix_x+mb_x;
  1232.       pic4_pix_x=pic_pix_x*4;
  1235.       SetMotionVectorPredictor (img_mv[block_x][block_y][ref_frame][blocktype], refFrArr, tmp_mv,
  1236.         ref_frame, mb_x, mb_y, blockshape_x, blockshape_y);
  1239.       ip0=img_mv[block_x][block_y][ref_frame][blocktype][0];
  1240.       ip1=img_mv[block_x][block_y][ref_frame][blocktype][1];
  1242.       //  mo[] is the the original block to be used in the search process
  1243.       // Note: dimensions changed to speed up access
  1244.       for (i=0; i < blockshape_x; i++)
  1245.         for (j=0; j < blockshape_y; j++)
  1246.           mo[j][i]=imgY_org[pic_pix_y+j][pic_pix_x+i];
  1248.       //  Integer pel search.  center_x,center_y is the 'search center'
  1249. #ifndef _FAST_FULL_ME_
  1250.       // Note that the predictor in mv[][][][][] is in 1/4 or 1/8th pel resolution
  1251.       // The following rounding enforces a "true" integer pel search.
  1252.       center_x=ip0/(mv_mul*4);
  1253.       center_y=ip1/(mv_mul*4);
  1255.       // Limitation of center_x,center_y so that the search wlevel ow contains the (0,0) vector
  1256.       center_x=max(-(input->search_range),min(input->search_range,center_x));
  1257.       center_y=max(-(input->search_range),min(input->search_range,center_y));
  1259.       // The following was deleted to support UMV.  See Remak regarding UMV performance for B
  1260.       // in the Readme File (to be provided)
  1261.       // Search center corrected to prevent vectors outside the frame, this is not permitted in this model.
  1262.       if ((pic_pix_x + center_x > curr_search_range) &&
  1263.           (pic_pix_y + center_y > curr_search_range) &&
  1264.           (pic_pix_x + center_x < img->width  - 1 - curr_search_range - blockshape_x) &&
  1265.           (pic_pix_y + center_y < img->height - 1 - curr_search_range - blockshape_y))
  1266.       {
  1267.         PelYline_11 = FastLine16Y_11;
  1268.       }
  1269.       else
  1270.       {
  1271.         PelYline_11 = UMVLine16Y_11;
  1272.       }
  1274.       best_inter_sad = IntegerSpiralSearch (mv_mul, center_x, center_y, ip0, ip1,
  1275.                                             blockshape_x, blockshape_y, curr_search_range,
  1276.                                             blocktype, mo, CurrRefPic11, &center_h2, &center_v2,
  1277.                                             pic_pix_x, pic_pix_y,
  1278.                                             lambda);
  1280. #else // _FAST_FULL_ME_
  1282.       best_inter_sad = FastFullIntegerSearch (mv_mul, ip0, ip1, curr_search_range,
  1283.                                               refindex, blocktype, mb_x, mb_y,
  1284.                                               &center_h2, &center_v2, pic_pix_x, pic_pix_y,
  1285.                                               lambda);
  1287. #endif // _FAST_FULL_ME_
  1290.       // Adjust center to 1/4 pel positions
  1291.       center_h2 *=4;
  1292.       center_v2 *=4;
  1295.       if ((pic4_pix_x + center_h2 > 1) &&
  1296.           (pic4_pix_y + center_v2 > 1) &&
  1297.           (pic4_pix_x + center_h2 < 4*(img->width  - blockshape_x + 1) - 2) &&
  1298.           (pic4_pix_y + center_v2 < 4*(img->height - blockshape_y + 1) - 2)   )
  1299.         PelY_14 = FastPelY_14;
  1300.       else
  1301.         PelY_14 = UMVPelY_14;
  1303.       //  1/2 pixel search.  In this version the search is over 9 vector positions.
  1304.       best_inter_sad = HalfPelSearch (pic4_pix_x, pic4_pix_y, mv_mul, blockshape_x, blockshape_y,
  1305.                                       &s_pos_x1, &s_pos_y1, &s_pos_x2, &s_pos_y2, center_h2, center_v2,
  1306.                                       ip0, ip1, blocktype, mo, CurrRefPic, tmp_mv, all_mv, block_x,
  1307.                                       block_y, ref_frame, pic_block_x, pic_block_y,
  1308.                                       lambda);
  1312.       //  1/4 pixel search.
  1313.       if ((pic4_pix_x + s_pos_x2 > 0) &&
  1314.           (pic4_pix_y + s_pos_y2 > 0) &&
  1315.           (pic4_pix_x + s_pos_x2 < 4*(img->width  - blockshape_x + 1) - 1) &&
  1316.           (pic4_pix_y + s_pos_y2 < 4*(img->height - blockshape_y + 1) - 1)   )
  1317.         PelY_14 = FastPelY_14;
  1318.       else
  1319.         PelY_14 = UMVPelY_14;
  1321.       best_inter_sad = QuarterPelSearch (pic4_pix_x, pic4_pix_y, mv_mul, blockshape_x, blockshape_y,
  1322.                                          &s_pos_x1, &s_pos_y1, &s_pos_x2, &s_pos_y2, center_h2, center_v2,
  1323.                                          ip0, ip1, blocktype, mo, CurrRefPic, tmp_mv, all_mv, block_x, block_y, ref_frame,
  1324.                                          pic_block_x, pic_block_y, best_inter_sad,
  1325.                                          lambda);
  1328.       //  1/8 pixel search.
  1329.       if(input->mv_res)
  1330.       {
  1331.         pic8_pix_x=2*pic4_pix_x;
  1332.         pic8_pix_y=2*pic4_pix_y;
  1334.         if ((pic8_pix_x + s_pos_x2 > 0) &&
  1335.             (pic8_pix_y + s_pos_y2 > 0) &&
  1336.             (pic8_pix_x + s_pos_x2 < 8*(img->width  - blockshape_x + 1) - 2) &&
  1337.             (pic8_pix_y + s_pos_y2 < 8*(img->height - blockshape_y + 1) - 2)   )
  1338.           PelY_18 = FastPelY_18;
  1339.         else
  1340.           PelY_18 = UMVPelY_18;
  1342.         best_inter_sad = EighthPelSearch(pic8_pix_x, pic8_pix_y, mv_mul, blockshape_x, blockshape_y,
  1343.                                         &s_pos_x1, &s_pos_y1, &s_pos_x2, &s_pos_y2, center_h2, center_v2,
  1344.                                         ip0, ip1, blocktype, mo, CurrRefPic, tmp_mv, all_mv, block_x, block_y, ref_frame,
  1345.                                         pic_block_x, pic_block_y, best_inter_sad,
  1346.                                         lambda);
  1348.       }
  1350.       tot_inter_sad += best_inter_sad;
  1351.     }
  1352.   }
  1353.   return tot_inter_sad;
  1354. }
  1358. /*!
  1359.  ************************************************************************
  1360.  * brief
  1361.  *    motion search for P-frames
  1362.  ************************************************************************
  1363.  */
  1364. int motion_search(int tot_intra_sad)
  1365. {
  1366.   int predframe_no, min_inter_sad, hv, i, j;
  1369.   predframe_no = UnifiedMotionSearch(tot_intra_sad, refFrArr, tmp_mv, img->mv, &img->mb_mode,
  1370.     &img->blc_size_h, &img->blc_size_v, &img->multframe_no, PFRAME, &min_inter_sad, img->all_mv);
  1372.   // tot_intra_sad is now the minimum SAD for intra.  min_inter_sad is the best (min) SAD for inter (see above).
  1373.   // Inter/intra is determined depending on which is smallest
  1375.   if (tot_intra_sad < min_inter_sad)
  1376.   {
  1377.     img->mb_mode=img->imod+8*img->type; // set intra mode in inter frame
  1378.     for (hv=0; hv < 2; hv++)
  1379.       for (i=0; i < 4; i++)
  1380.         for (j=0; j < 4; j++)
  1381.           tmp_mv[hv][img->block_y+j][img->block_x+i+4]=0;
  1382.   }
  1383.   else
  1384.   {
  1385.     img->mb_data[img->current_mb_nr].intraOrInter = INTER_MB;
  1386.     img->imod=INTRA_MB_INTER; // Set inter mode
  1387.     for (hv=0; hv < 2; hv++)
  1388.       for (i=0; i < 4; i++)
  1389.         for (j=0; j < 4; j++)
  1390.           tmp_mv[hv][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][predframe_no][img->mb_mode][hv];
  1391.   }
  1392.   return predframe_no;
  1393. };
  1397. /*!
  1398.  ************************************************************************
  1399.  * brief
  1400.  *    forward motion search for B-frames
  1401.  ************************************************************************
  1402.  */
  1403. int get_fwMV(int *min_fw_sad, int tot_intra_sad)
  1404. {
  1405.   int fw_predframe_no, hv, i, j;
  1407.   fw_predframe_no = UnifiedMotionSearch(tot_intra_sad, fw_refFrArr, tmp_fwMV,
  1408.                                         img->p_fwMV, &img->fw_mb_mode,
  1409.                                         &img->fw_blc_size_h, &img->fw_blc_size_v,
  1410.                                         &img->fw_multframe_no, B_FORWARD,
  1411.                                         min_fw_sad, img->all_mv);
  1413.   // save forward MV to tmp_fwMV
  1414.   for (hv=0; hv < 2; hv++)
  1415.     for (i=0; i < 4; i++)
  1416.       for (j=0; j < 4; j++)
  1417.       {
  1418.         if(img->fw_mb_mode==1)
  1419.           tmp_fwMV[hv][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][fw_predframe_no][1][hv];
  1420.         else
  1421.           tmp_fwMV[hv][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][fw_predframe_no][(img->fw_mb_mode)/2][hv];
  1422.       }
  1424.   return fw_predframe_no;
  1425. }
  1429. /*!
  1430.  ************************************************************************
  1431.  * brief
  1432.  *    backward motion search for B-frames
  1433.  ************************************************************************
  1434.  */
  1435. void get_bwMV(int *min_bw_sad)
  1436. {
  1437.   int bw_predframe_no, hv, i, j;
  1439.   bw_predframe_no = UnifiedMotionSearch(MAX_VALUE, bw_refFrArr, tmp_bwMV,
  1440.           img->p_bwMV, &img->bw_mb_mode,
  1441.           &img->bw_blc_size_h, &img->bw_blc_size_v,
  1442.           &img->bw_multframe_no, B_BACKWARD,
  1443.           min_bw_sad, img->all_mv);
  1446.   // save backward MV to tmp_bwMV
  1447.   for (hv=0; hv < 2; hv++)
  1448.     for (i=0; i < 4; i++)
  1449.       for (j=0; j < 4; j++)
  1450.       {
  1451.         if(img->bw_mb_mode==2)
  1452.           tmp_bwMV[hv][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][bw_predframe_no][1][hv];
  1453.         else
  1454.           tmp_bwMV[hv][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][bw_predframe_no][(img->bw_mb_mode-1)/2][hv];
  1455.       }
  1456. }
  1459. /*!
  1460.  ************************************************************************
  1461.  * brief
  1462.  *    Do hadamard transform or normal SAD calculation.
  1463.  *    If Hadamard=1 4x4 Hadamard transform is performed and SAD of transform
  1464.  *    levels is calculated
  1465.  *
  1466.  * par Input:
  1467.  *    hadamard=0 : normal SAD                                                  n
  1468.  *    hadamard=1 : 4x4 Hadamard transform is performed and SAD of transform
  1469.  *                 levels is calculated
  1470.  *
  1471.  * par Output:
  1472.  *    SAD/hadamard transform value
  1473.  *
  1474.  * note
  1475.  *    This function was optimized by manual loop unrolling and pointer arithmetic
  1476.  ************************************************************************
  1477.  */
  1478. int find_sad(int hadamard, int m7[16][16])
  1479. {
  1480.   int i, j,x, y, best_sad,current_sad;
  1481.   int m1[BLOCK_SIZE*BLOCK_SIZE], m[BLOCK_SIZE*BLOCK_SIZE], *mp;
  1483. #ifdef COMPLEXITY
  1484.     SadCalls++;
  1485. #endif
  1487.   current_sad=0;
  1488.   if (hadamard != 0)
  1489.   {
  1490.     best_sad=0;
  1492. // Copy img->m7[][] into local variable, to avoid costly address arithmetic and cache misses
  1494.     mp=m;
  1495.     for (y=0; y<BLOCK_SIZE; y++)
  1496.       for (x=0; x<BLOCK_SIZE; x++)
  1497.         *mp++= m7[y][x];
  1500.     m1[0] = m[0] + m[12];
  1501.     m1[4] = m[4] + m[8];
  1502.     m1[8] = m[4] - m[8];
  1503.     m1[12]= m[0] - m[12];
  1505.     m1[1] = m[1] + m[13];
  1506.     m1[5] = m[5] + m[9];
  1507.     m1[9] = m[5] - m[9];
  1508.     m1[13]= m[1] - m[13];
  1510.     m1[2] = m[2] + m[14];
  1511.     m1[6] = m[6] + m[10];
  1512.     m1[10]= m[6] - m[10];
  1513.     m1[14]= m[2] - m[14];
  1515.     m1[3] = m[3] + m[15];
  1516.     m1[7] = m[7] + m[11];
  1517.     m1[11]= m[7] - m[11];
  1518.     m1[15]= m[3] - m[15];
  1521.     m[0] = m1[0] + m1[4];
  1522.     m[8] = m1[0] - m1[4];
  1523.     m[4] = m1[8] + m1[12];
  1524.     m[12]= m1[12]- m1[8];
  1526.     m[1] = m1[1] + m1[5];
  1527.     m[9] = m1[1] - m1[5];
  1528.     m[5] = m1[9] + m1[13];
  1529.     m[13]= m1[13]- m1[9];
  1531.     m[2] = m1[2] + m1[6];
  1532.     m[10] = m1[2] - m1[6];
  1533.     m[6] = m1[10] + m1[14];
  1534.     m[14]= m1[14]- m1[10];
  1536.     m[3] = m1[3] + m1[7];
  1537.     m[11]= m1[3] - m1[7];
  1538.     m[7] = m1[11]+ m1[15];
  1539.     m[15]= m1[15]- m1[11];
  1543.     m1[0] = m[0] + m[3];
  1544.     m1[1] = m[1] + m[2];
  1545.     m1[2] = m[1] - m[2];
  1546.     m1[3] = m[0] - m[3];
  1548.     m1[4] = m[4] + m[7];
  1549.     m1[5] = m[5] + m[6];
  1550.     m1[6] = m[5] - m[6];
  1551.     m1[7] = m[4] - m[7];
  1553.     m1[8] = m[8] + m[11];
  1554.     m1[9] = m[9] + m[10];
  1555.     m1[10]= m[9] - m[10];
  1556.     m1[11]= m[8] - m[11];
  1558.     m1[12]= m[12]+ m[15];
  1559.     m1[13]= m[13]+ m[14];
  1560.     m1[14]= m[13]- m[14];
  1561.     m1[15]= m[12]- m[15];
  1564.     m[0] = m1[0] + m1[1];
  1565.     m[1] = m1[0] - m1[1];
  1566.     m[2] = m1[2] + m1[3];
  1567.     m[3] = m1[3] - m1[2];
  1569.     m[4] = m1[4] + m1[5];
  1570.     m[5] = m1[4] - m1[5];
  1571.     m[6] = m1[6] + m1[7];
  1572.     m[7] = m1[7] - m1[6];
  1574.     m[8] = m1[8] + m1[9];
  1575.     m[9] = m1[8] - m1[9];
  1576.     m[10]= m1[10]+ m1[11];
  1577.     m[11]= m1[11]- m1[10];
  1579.     m[12]= m1[12]+ m1[13];
  1580.     m[13]= m1[12]- m1[13];
  1581.     m[14]= m1[14]+ m1[15];
  1582.     m[15]= m1[15]- m1[14];
  1585.     // Note: we cannot use ByteAbs() here because the absolute values can be bigger
  1586.     // than +- 256.  WOuld either need to enhance ByteAbs to WordAbs (or something)
  1587.     // or leave it as is (use of absm*( macro)
  1589.     for (j=0; j< BLOCK_SIZE * BLOCK_SIZE; j++)
  1590.       best_sad += absm (m[j]);
  1592.       /*
  1593.     Calculation of normalized Hadamard transforms would require divison by 4 here.
  1594.     However,we flevel  that divison by 2 is better (assuming we give the same penalty for
  1595.     bituse for Hadamard=0 and 1)
  1596.     */
  1598.     current_sad += best_sad/2;
  1599.   }
  1600.   else
  1601.   {
  1602.     register int *p;
  1603.     {
  1604.       for (i=0;i<4;i++)
  1605.       {
  1606.         p = m7[i];
  1607.         for (j=0;j<4;j++)
  1608.           current_sad+=ByteAbs(*p++);
  1609.       }
  1610.     }
  1611.   }
  1612.   return current_sad;
  1613. }
  1617. /*!
  1618.  ************************************************************************
  1619.  * brief
  1620.  *    control the sign of a with b
  1621.  ************************************************************************
  1622.  */
  1623. int sign(int a,int b)
  1624. {
  1625.   int x;
  1626.   x=absm(a);
  1627.   if (b >= 0)
  1628.     return x;
  1629.   else
  1630.     return -x;
  1631. }
  1633. static int ByteAbsLookup[] = {
  1634.   255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,
  1635.   239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,
  1636.   223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,
  1637.   207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,
  1638.   191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,
  1639.   175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,
  1640.   159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,
  1641.   143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,
  1642.   127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,
  1643.   111,110,109,108,107,106,105,104,103,102,101,100, 99, 98, 97, 96,
  1644.    95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80,
  1645.    79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64,
  1646.    63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48,
  1647.    47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32,
  1648.    31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
  1649.    15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,
  1650.     1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
  1651.    17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
  1652.    33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
  1653.    49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
  1654.    65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
  1655.    81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
  1656.    97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,112,
  1657.   113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
  1658.   129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,
  1659.   145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,
  1660.   161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,
  1661.   177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,
  1662.   193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,
  1663.   209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,
  1664.   225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,
  1665.   241,242,243,244,245,246,247,248,249,250,251,252,253,254,255 };
  1667. __inline int ByteAbs (int foo)
  1668. {
  1669.   return ByteAbsLookup [foo+255];
  1670. }
  1673. void InitMotionVectorSearchModule ()
  1674. {
  1675.   int i,j,k,l,l2;
  1677.   // Set up the static pointer for MV_bituse;
  1678.   MVBitUse = img->mv_bituse;
  1680.   // initialize Spiral Search statics
  1682.   k=1;
  1683.   for (l=1; l < 41; l++)
  1684.   {
  1685.     l2=l+l;
  1686.     for (i=-l+1; i < l; i++)
  1687.     {
  1688.       for (j=-l; j < l+1; j += l2)
  1689.       {
  1690.         SpiralX[k] = i;
  1691.         SpiralY[k] = j;
  1692.         k++;
  1693.       }
  1694.     }
  1696.     for (j=-l; j <= l; j++)
  1697.     {
  1698.       for (i=-l;i <= l; i += l2)
  1699.       {
  1700.         SpiralX[k] = i;
  1701.         SpiralY[k] = j;
  1702.         k++;
  1703.       }
  1704.     }
  1705.   }
  1706. }