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

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

Audio

开发平台：

Visual C++

mv-search.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file mv-search.c
  5.  *
  6.  * brief
  7.  *    Motion Vector Search, unified for B and P Pictures
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *      - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  12.  *      - Inge Lille-Langoy               <inge.lille-langoy@telenor.com>
  13.  *      - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  14.  *      - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  15.  *      - Jani Lainema                    <jani.lainema@nokia.com>
  16.  *      - Detlev Marpe                    <marpe@hhi.de>
  17.  *      - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
  18.  *      - Heiko Schwarz                   <hschwarz@hhi.de>
  19.  *      - Alexis Michael Tourapis         <alexismt@ieee.org>
  20.  *
  21.  *************************************************************************************
  22. */
  24. #include "contributors.h"
  26. #include <math.h>
  27. #include <limits.h>
  28. #include <time.h>
  29. #include <sys/timeb.h>
  31. #include "global.h"
  33. #include "image.h"
  34. #include "mv-search.h"
  35. #include "refbuf.h"
  36. #include "memalloc.h"
  37. #include "mb_access.h"
  38. #include "macroblock.h"
  39. #include "mc_prediction.h"
  40. #include "conformance.h"
  42. // Motion estimation distortion header file
  43. #include "me_distortion.h"
  45. // Motion estimation search algorithms
  46. #include "me_epzs.h"
  47. #include "me_fullfast.h"
  48. #include "me_fullsearch.h"
  49. #include "me_umhex.h"
  50. #include "me_umhexsmp.h"
  51. #include "rdoq.h"
  54. // Statistics, temporary
  55. int     max_mvd;
  56. short*  spiral_search_x;
  57. short*  spiral_search_y;
  58. short*  spiral_hpel_search_x;
  59. short*  spiral_hpel_search_y;
  61. int*    mvbits;
  62. int*    refbits;
  63. int*    byte_abs;
  64. int**** motion_cost;
  65. int     byte_abs_range;
  67. static int diff  [16];
  68. static int diff64[64];
  69. static imgpel orig_pic [768];
  70. int (*IntPelME)       (Macroblock *, imgpel *, short, int, int, char ***, short ****,
  71.                        int, int, int, short[2], short[2], int, int, int, int);
  73. int (*BiPredME)       (Macroblock *, imgpel *, short, int, int, char  ***, short  ****,
  74.                        int, int, int, short[2], short[2], short[2], short[2], int, int, int, int, int);
  76. int (*SubPelBiPredME) (imgpel* orig_pic, short ref, int list, int pic_pix_x, int pic_pix_y,
  77.                        int blocktype, short pred_mv1[2], short pred_mv2[2], short mv1[2], short mv2[2], 
  78.                        int search_pos2, int search_pos4, int min_mcost, int* lambda_factor, int apply_weights);
  79. int (*SubPelME)       (imgpel* orig_pic, short ref, int list, int list_offset, int pic_pix_x, int pic_pix_y, 
  80.                        int blocktype, short pred_mv[2], short mv[2], 
  81.                        int search_pos2, int search_pos4, int min_mcost, int* lambda_factor, int apply_weights);
  84. int BlockMotionSearch (Macroblock *currMB, short,int,int,int,int,int, int*);
  85. int BiPredBlockMotionSearch(Macroblock *currMB, short[2], short*, short, int, int, int, int , int, int, int*);
  87. int GetSkipCostMB     (Macroblock *currMB);
  89. extern ColocatedParams *Co_located;
  90. extern const short block_type_shift_factor[8];
  92. /*!
  93.  ************************************************************************
  94.  * brief
  95.  *    Initialize ME engine
  96.  ************************************************************************
  97.  */
  98. void init_ME_engine(int SearchMode)
  99. {
  100.   switch (SearchMode)
  101.   {
  102.    case EPZS:
  103.      IntPelME       = EPZSPelBlockMotionSearch;
  104.      BiPredME       = EPZSBiPredBlockMotionSearch;
  105.      SubPelBiPredME = (params->EPZSSubPelMEBiPred) ? EPZSSubPelBlockSearchBiPred : SubPelBlockSearchBiPred;
  106.      SubPelME       = (params->EPZSSubPelME) ? EPZSSubPelBlockMotionSearch : SubPelBlockMotionSearch;
  107.      break;
  108.    case UM_HEX:
  109.      IntPelME       = UMHEXIntegerPelBlockMotionSearch;
  110.      BiPredME       = UMHEXBipredIntegerPelBlockMotionSearch;
  111.      SubPelBiPredME = SubPelBlockSearchBiPred;
  112.      SubPelME       = UMHEXSubPelBlockME;
  113.      break;
  114.    case UM_HEX_SIMPLE:
  115.      IntPelME       = smpUMHEXIntegerPelBlockMotionSearch;
  116.      BiPredME       = smpUMHEXBipredIntegerPelBlockMotionSearch;
  117.      SubPelBiPredME = SubPelBlockSearchBiPred;
  118.      SubPelME       = smpUMHEXSubPelBlockME;
  119.      break;
  120.    case FULL_SEARCH:
  121.      IntPelME       = FullPelBlockMotionSearch;
  122.      BiPredME       = FullPelBlockMotionBiPred;
  123.      SubPelBiPredME = SubPelBlockSearchBiPred;
  124.      SubPelME       = SubPelBlockMotionSearch;
  125.      break;
  126.    case FAST_FULL_SEARCH:
  127.    default:
  128.      IntPelME       = FastFullPelBlockMotionSearch;
  129.      BiPredME       = FullPelBlockMotionBiPred;
  130.      SubPelBiPredME = SubPelBlockSearchBiPred;
  131.      SubPelME       = SubPelBlockMotionSearch;
  132.      break;
  133.   }
  134. }
  136. /*!
  137.  ************************************************************************
  138.  * brief
  139.  *    Prepare Motion Estimation parameters for single list ME
  140.  ************************************************************************
  141.  */
  142. void PrepareMEParams(int apply_weights, int ChromaMEEnable, int list, int ref)
  143. {
  144.   if (apply_weights)
  145.   {
  146.     weight_luma = wp_weight[list][ref][0];
  147.     offset_luma = wp_offset[list][ref][0];
  149.     if ( ChromaMEEnable)
  150.     {
  151.       weight_cr[0] = wp_weight[list][ref][1];
  152.       weight_cr[1] = wp_weight[list][ref][2];
  153.       offset_cr[0] = wp_offset[list][ref][1];
  154.       offset_cr[1] = wp_offset[list][ref][2];
  155.     }
  156.   }
  157. }
  159. /*!
  160.  ************************************************************************
  161.  * brief
  162.  *    Prepare Motion Estimation parameters for bipred list ME
  163.  ************************************************************************
  164.  */
  165. void PrepareBiPredMEParams(int apply_weights, int ChromaMEEnable, int list, int list_offset, int ref)
  166. {
  167.   if (apply_weights)
  168.   {
  169.     if (list == LIST_0)
  170.     {
  171.       weight1  = wbp_weight[list_offset         ][ref][0][0];
  172.       weight2  = wbp_weight[list_offset + LIST_1][ref][0][0];
  173.       offsetBi = (wp_offset[list_offset         ][ref][0] + wp_offset[list_offset + LIST_1][ref][0] + 1)>>1;
  175.       if ( ChromaMEEnable)
  176.       {
  177.         weight1_cr[0] = wbp_weight[list_offset         ][ref][0][1];
  178.         weight1_cr[1] = wbp_weight[list_offset         ][ref][0][2];
  179.         weight2_cr[0] = wbp_weight[list_offset + LIST_1][ref][0][1];
  180.         weight2_cr[1] = wbp_weight[list_offset + LIST_1][ref][0][2];
  181.    
  182.         offsetBi_cr[0] = (wp_offset[list_offset        ][ref][1] + wp_offset[list_offset + LIST_1][ref][1] + 1) >> 1;
  183.         offsetBi_cr[1] = (wp_offset[list_offset        ][ref][2] + wp_offset[list_offset + LIST_1][ref][2] + 1) >> 1;
  184.       }
  185.     }
  186.     else
  187.     {
  188.       weight1  = wbp_weight[list_offset + LIST_1][0  ][ref][0];
  189.       weight2  = wbp_weight[list_offset         ][0  ][ref][0];
  190.       offsetBi = (wp_offset[list_offset + LIST_1][0][0] + wp_offset[list_offset][0][0] + 1)>>1;
  192.       if ( ChromaMEEnable)
  193.       {
  194.         weight1_cr[0] = wbp_weight[list_offset + LIST_1][0  ][ref][1];
  195.         weight1_cr[1] = wbp_weight[list_offset + LIST_1][0  ][ref][2];
  196.         weight2_cr[0] = wbp_weight[list_offset         ][0  ][ref][1];
  197.         weight2_cr[1] = wbp_weight[list_offset         ][0  ][ref][2];
  199.         offsetBi_cr[0] = (wp_offset[list_offset + LIST_1][0  ][1] + wp_offset[list_offset         ][0  ][1] + 1) >> 1;
  200.         offsetBi_cr[1] = (wp_offset[list_offset + LIST_1][0  ][2] + wp_offset[list_offset         ][0  ][2] + 1) >> 1;
  201.       }
  202.     }
  203.   }
  204.   else
  205.   {
  206.     weight1 = 1<<luma_log_weight_denom;
  207.     weight2 = 1<<luma_log_weight_denom;
  208.     offsetBi = 0;
  209.     if ( ChromaMEEnable)
  210.     {
  211.       weight1_cr[0] = 1<<chroma_log_weight_denom;
  212.       weight1_cr[1] = 1<<chroma_log_weight_denom;
  213.       weight2_cr[0] = 1<<chroma_log_weight_denom;
  214.       weight2_cr[1] = 1<<chroma_log_weight_denom;
  215.       offsetBi_cr[0] = 0;
  216.       offsetBi_cr[1] = 0;
  217.     }
  218.   }
  219. }
  221. /*!
  222.  ************************************************************************
  223.  * brief
  224.  *    Set motion vector predictor
  225.  ************************************************************************
  226.  */
  227. void SetMotionVectorPredictor (Macroblock *currMB, 
  228.                                short  pmv[2],
  229.                                char   **refPic,
  230.                                short  ***tmp_mv,
  231.                                short  ref_frame,
  232.                                int    list,
  233.                                int    mb_x,
  234.                                int    mb_y,
  235.                                int    blockshape_x,
  236.                                int    blockshape_y)
  237. {
  238.   int mv_a, mv_b, mv_c, pred_vec=0;
  239.   int mvPredType, rFrameL, rFrameU, rFrameUR;
  240.   int hv;
  242.   PixelPos block_a, block_b, block_c, block_d;
  243.   int *mb_size = img->mb_size[IS_LUMA];
  245.   get4x4Neighbour(currMB, mb_x - 1,            mb_y    , mb_size, &block_a);
  246.   get4x4Neighbour(currMB, mb_x,                mb_y - 1, mb_size, &block_b);
  247.   get4x4Neighbour(currMB, mb_x + blockshape_x, mb_y - 1, mb_size, &block_c);
  248.   get4x4Neighbour(currMB, mb_x - 1,            mb_y - 1, mb_size, &block_d);
  250.   if (mb_y > 0)
  251.   {
  252.     if (mb_x < 8)  // first column of 8x8 blocks
  253.     {
  254.       if (mb_y == 8 )
  255.       {
  256.         if (blockshape_x == 16)      block_c.available  = 0;
  257.       }
  258.       else if (mb_x+blockshape_x == 8)
  259.       {
  260.           block_c.available = 0;
  261.       }
  262.     }
  263.     else if (mb_x+blockshape_x == 16)
  264.     {
  265.       block_c.available = 0;
  266.     }
  267.   }
  269.   if (!block_c.available)
  270.   {
  271.     block_c = block_d;
  272.   }
  274.   mvPredType = MVPRED_MEDIAN;
  276.   if (!img->MbaffFrameFlag)
  277.   {
  278.     rFrameL    = block_a.available ? refPic[block_a.pos_y][block_a.pos_x] : -1;
  279.     rFrameU    = block_b.available ? refPic[block_b.pos_y][block_b.pos_x] : -1;
  280.     rFrameUR   = block_c.available ? refPic[block_c.pos_y][block_c.pos_x] : -1;
  281.   }
  282.   else
  283.   {
  284.     if (currMB->mb_field)
  285.     {
  286.       rFrameL  = block_a.available
  287.         ? (img->mb_data[block_a.mb_addr].mb_field
  288.         ? refPic[block_a.pos_y][block_a.pos_x]
  289.         : refPic[block_a.pos_y][block_a.pos_x] * 2) : -1;
  290.       rFrameU  = block_b.available
  291.         ? (img->mb_data[block_b.mb_addr].mb_field
  292.         ? refPic[block_b.pos_y][block_b.pos_x]
  293.         : refPic[block_b.pos_y][block_b.pos_x] * 2) : -1;
  294.       rFrameUR = block_c.available
  295.         ? (img->mb_data[block_c.mb_addr].mb_field
  296.         ? refPic[block_c.pos_y][block_c.pos_x]
  297.         : refPic[block_c.pos_y][block_c.pos_x] * 2) : -1;
  298.     }
  299.     else
  300.     {
  301.       rFrameL = block_a.available
  302.         ? (img->mb_data[block_a.mb_addr].mb_field
  303.         ? refPic[block_a.pos_y][block_a.pos_x] >>1
  304.         : refPic[block_a.pos_y][block_a.pos_x]) : -1;
  305.       rFrameU  = block_b.available
  306.         ? (img->mb_data[block_b.mb_addr].mb_field
  307.         ? refPic[block_b.pos_y][block_b.pos_x] >>1
  308.         : refPic[block_b.pos_y][block_b.pos_x]) : -1;
  309.       rFrameUR = block_c.available
  310.         ? (img->mb_data[block_c.mb_addr].mb_field
  311.         ? refPic[block_c.pos_y][block_c.pos_x] >>1
  312.         : refPic[block_c.pos_y][block_c.pos_x]) : -1;
  313.     }
  314.   }
  316.   /* Prediction if only one of the neighbors uses the reference frame
  317.   *  we are checking
  318.   */
  319.   if(rFrameL == ref_frame && rFrameU != ref_frame && rFrameUR != ref_frame)       
  320.     mvPredType = MVPRED_L;
  321.   else if(rFrameL != ref_frame && rFrameU == ref_frame && rFrameUR != ref_frame)  
  322.     mvPredType = MVPRED_U;
  323.   else if(rFrameL != ref_frame && rFrameU != ref_frame && rFrameUR == ref_frame)  
  324.     mvPredType = MVPRED_UR;
  325.   // Directional predictions
  326.   if(blockshape_x == 8 && blockshape_y == 16)
  327.   {
  328.     if(mb_x == 0)
  329.     {
  330.       if(rFrameL == ref_frame)
  331.         mvPredType = MVPRED_L;
  332.     }
  333.     else
  334.     {
  335.       if( rFrameUR == ref_frame)
  336.         mvPredType = MVPRED_UR;
  337.     }
  338.   }
  339.   else if(blockshape_x == 16 && blockshape_y == 8)
  340.   {
  341.     if(mb_y == 0)
  342.     {
  343.       if(rFrameU == ref_frame)
  344.         mvPredType = MVPRED_U;
  345.     }
  346.     else
  347.     {
  348.       if(rFrameL == ref_frame)
  349.         mvPredType = MVPRED_L;
  350.     }
  351.   }
  353.   for (hv=0; hv < 2; hv++)
  354.   {
  355.     if (!img->MbaffFrameFlag || hv==0)
  356.     {
  357.       mv_a = block_a.available ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] : 0;
  358.       mv_b = block_b.available ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] : 0;
  359.       mv_c = block_c.available ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] : 0;
  360.     }
  361.     else
  362.     {
  363.       if (currMB->mb_field)
  364.       {
  365.         mv_a = block_a.available  ? img->mb_data[block_a.mb_addr].mb_field
  366.           ? tmp_mv[block_a.pos_y][block_a.pos_x][hv]
  367.           : tmp_mv[block_a.pos_y][block_a.pos_x][hv] / 2
  368.           : 0;
  369.         mv_b = block_b.available  ? img->mb_data[block_b.mb_addr].mb_field
  370.           ? tmp_mv[block_b.pos_y][block_b.pos_x][hv]
  371.           : tmp_mv[block_b.pos_y][block_b.pos_x][hv] / 2
  372.           : 0;
  373.         mv_c = block_c.available  ? img->mb_data[block_c.mb_addr].mb_field
  374.           ? tmp_mv[block_c.pos_y][block_c.pos_x][hv]
  375.           : tmp_mv[block_c.pos_y][block_c.pos_x][hv] / 2
  376.           : 0;
  377.       }
  378.       else
  379.       {
  380.         mv_a = block_a.available  ? img->mb_data[block_a.mb_addr].mb_field
  381.           ? tmp_mv[block_a.pos_y][block_a.pos_x][hv] * 2
  382.           : tmp_mv[block_a.pos_y][block_a.pos_x][hv]
  383.           : 0;
  384.         mv_b = block_b.available  ? img->mb_data[block_b.mb_addr].mb_field
  385.           ? tmp_mv[block_b.pos_y][block_b.pos_x][hv] * 2
  386.           : tmp_mv[block_b.pos_y][block_b.pos_x][hv]
  387.           : 0;
  388.         mv_c = block_c.available  ? img->mb_data[block_c.mb_addr].mb_field
  389.           ? tmp_mv[block_c.pos_y][block_c.pos_x][hv] * 2
  390.           : tmp_mv[block_c.pos_y][block_c.pos_x][hv]
  391.           : 0;
  392.       }
  393.     }
  395.     switch (mvPredType)
  396.     {
  397.     case MVPRED_MEDIAN:
  398.       if(!(block_b.available || block_c.available))
  399.       {
  400.         pred_vec = mv_a;
  401.       }
  402.       else
  403.       {
  404.         pred_vec = mv_a+mv_b+mv_c-imin(mv_a,imin(mv_b,mv_c))-imax(mv_a,imax(mv_b,mv_c));
  405.       }
  406.       break;
  407.     case MVPRED_L:
  408.       pred_vec = mv_a;
  409.       break;
  410.     case MVPRED_U:
  411.       pred_vec = mv_b;
  412.       break;
  413.     case MVPRED_UR:
  414.       pred_vec = mv_c;
  415.       break;
  416.     default:
  417.       break;
  418.     }
  420.     pmv[hv] = pred_vec;
  421.   }
  422. }
  424. /*!
  425. ************************************************************************
  426. * brief
  427. *    Initialize the motion search
  428. ************************************************************************
  429. */
  430. void Init_Motion_Search_Module (void)
  431. {
  432.   int bits, i_min, i_max, k;
  433.   int i, l;
  435.   int search_range               = params->search_range;
  436.   int max_search_points          = imax(9, (2*search_range+1)*(2*search_range+1));
  437.   int max_ref_bits               = 1 + 2 * (int)floor(log(imax(16, img->max_num_references + 1)) / log(2) + 1e-10);
  438.   int max_ref                    = (1<<((max_ref_bits>>1)+1))-1;
  439.   int number_of_subpel_positions = 4 * (2*search_range+3);
  440.   int max_mv_bits                = 3 + 2 * (int)ceil (log(number_of_subpel_positions+1) / log(2) + 1e-10);
  441.   max_mvd                        = (1<<( max_mv_bits >>1)   )-1;
  442.   byte_abs_range                 = (imax(img->max_imgpel_value_comp[0],img->max_imgpel_value_comp[1]) + 1) * 64;
  444.   //=====   CREATE ARRAYS   =====
  445.   //-----------------------------
  446.   if ((spiral_search_x = (short*)calloc(max_search_points, sizeof(short))) == NULL)
  447.     no_mem_exit("Init_Motion_Search_Module: spiral_search_x");
  448.   if ((spiral_search_y = (short*)calloc(max_search_points, sizeof(short))) == NULL)
  449.     no_mem_exit("Init_Motion_Search_Module: spiral_search_y");
  450.   if ((spiral_hpel_search_x = (short*)calloc(max_search_points, sizeof(short))) == NULL)
  451.     no_mem_exit("Init_Motion_Search_Module: spiral_hpel_search_x");
  452.   if ((spiral_hpel_search_y = (short*)calloc(max_search_points, sizeof(short))) == NULL)
  453.     no_mem_exit("Init_Motion_Search_Module: spiral_hpel_search_y");
  455.   if ((mvbits = (int*)calloc(2 * max_mvd + 1, sizeof(int))) == NULL)
  456.     no_mem_exit("Init_Motion_Search_Module: mvbits");
  458.   if ((refbits = (int*)calloc(max_ref, sizeof(int))) == NULL)
  459.     no_mem_exit("Init_Motion_Search_Module: refbits");
  460.   if ((byte_abs = (int*)calloc(byte_abs_range, sizeof(int))) == NULL)
  461.     no_mem_exit("Init_Motion_Search_Module: byte_abs");
  463.   if (img->max_num_references)
  464.     get_mem4Dint (&motion_cost, 8, 2, img->max_num_references, 4);
  466.   //--- set array offsets ---
  467.   mvbits   += max_mvd;
  468.   byte_abs += byte_abs_range/2;
  470.   //=====   INIT ARRAYS   =====
  471.   //---------------------------
  472.   //--- init array: motion vector bits ---
  473.   mvbits[0] = 1;
  474.   for (bits=3; bits<=max_mv_bits; bits+=2)
  475.   {
  476.     i_max = 1    << (bits >> 1);
  477.     i_min = i_max >> 1;
  479.     for (i = i_min; i < i_max; i++)
  480.       mvbits[-i] = mvbits[i] = bits;
  481.   }
  483.   //--- init array: reference frame bits ---
  484.   refbits[0] = 1;
  485.   for (bits=3; bits<=max_ref_bits; bits+=2)
  486.   {
  487.     i_max = (1   << ((bits >> 1) + 1)) - 1;
  488.     i_min = i_max >> 1;
  490.     for (i = i_min; i < i_max; i++)
  491.       refbits[i] = bits;
  492.   }
  494.   //--- init array: absolute value ---
  495.   byte_abs[0] = 0;
  496.   // Set scaler for integer/subpel motion refinement.
  497.   // Currently only EPZS supports subpel positions
  500.   for (i=1; i<byte_abs_range/2; i++)
  501.   {
  502.     byte_abs[i] = byte_abs[-i] = i;
  503.   }
  505.   //--- init array: search pattern ---
  506.   spiral_search_x[0] = spiral_search_y[0] = 0;
  507.   spiral_hpel_search_x[0] = spiral_hpel_search_y[0] = 0;
  509.   for (k=1, l=1; l <= imax(1,search_range); l++)
  510.   {
  511.     for (i=-l+1; i< l; i++)
  512.     {
  513.       spiral_search_x[k] =  i;
  514.       spiral_search_y[k] = -l;
  515.       spiral_hpel_search_x[k] =  i<<1;
  516.       spiral_hpel_search_y[k++] = -l<<1;
  517.       spiral_search_x[k] =  i;
  518.       spiral_search_y[k] =  l;
  519.       spiral_hpel_search_x[k] =  i<<1;
  520.       spiral_hpel_search_y[k++] =  l<<1;
  521.     }
  522.     for (i=-l;   i<=l; i++)
  523.     {
  524.       spiral_search_x[k] = -l;
  525.       spiral_search_y[k] =  i;
  526.       spiral_hpel_search_x[k] = -l<<1;
  527.       spiral_hpel_search_y[k++] = i<<1;
  528.       spiral_search_x[k] =  l;
  529.       spiral_search_y[k] =  i;
  530.       spiral_hpel_search_x[k] =  l<<1;
  531.       spiral_hpel_search_y[k++] = i<<1;
  532.     }
  533.   }
  535.   // set global variable prior to ME
  536.   start_me_refinement_hp = (params->ChromaMEEnable == 1 || params->MEErrorMetric[F_PEL] != params->MEErrorMetric[H_PEL] ) ? 0 : 1;
  537.   start_me_refinement_qp = (params->ChromaMEEnable == 1 || params->MEErrorMetric[H_PEL] != params->MEErrorMetric[Q_PEL] ) ? 0 : 1;
  539.   // Setup Distortion Metrics depending on refinement level
  540.   for (i=0; i<3; i++)
  541.   {
  542.     switch(params->MEErrorMetric[i])
  543.     {
  544.     case ERROR_SAD:
  545.       computeUniPred[i] = computeSAD;
  546.       computeUniPred[i + 3] = computeSADWP;
  547.       computeBiPred1[i] = computeBiPredSAD1;
  548.       computeBiPred2[i] = computeBiPredSAD2;
  549.       break;
  550.     case ERROR_SSE:
  551.       computeUniPred[i] = computeSSE;
  552.       computeUniPred[i + 3] = computeSSEWP;
  553.       computeBiPred1[i] = computeBiPredSSE1;
  554.       computeBiPred2[i] = computeBiPredSSE2;
  555.       break;
  556.     case ERROR_SATD :
  557.     default:
  558.       computeUniPred[i] = computeSATD;
  559.       computeUniPred[i + 3] = computeSATDWP;
  560.       computeBiPred1[i] = computeBiPredSATD1;
  561.       computeBiPred2[i] = computeBiPredSATD2;
  562.       break;
  563.     }
  564.   }
  565.   // Setup buffer access methods
  566.   get_line[0] = FastLine4X;
  567.   get_line[1] = UMVLine4X;
  568.   get_crline[0] = FastLine8X_chroma;
  569.   get_crline[1] = UMVLine8X_chroma;
  571.   if (!params->IntraProfile)
  572.   {
  573.     if(params->SearchMode == FAST_FULL_SEARCH)
  574.       InitializeFastFullIntegerSearch ();
  576.     init_ME_engine(params->SearchMode);
  578.     if (params->SearchMode == UM_HEX)
  579.       UMHEX_DefineThreshold();
  580.   }
  581. }
  583. /*!
  584.  ************************************************************************
  585.  * brief
  586.  *    Free memory used by motion search
  587.  ************************************************************************
  588.  */
  589. void
  590. Clear_Motion_Search_Module ()
  591. {
  592.   //--- correct array offset ---
  593.   mvbits   -= max_mvd;
  594.   byte_abs -= byte_abs_range/2;
  596.   //--- delete arrays ---
  597.   free (spiral_search_x);
  598.   free (spiral_search_y);
  599.   free (spiral_hpel_search_x);
  600.   free (spiral_hpel_search_y);
  601.   free (mvbits);
  602.   free (refbits);
  603.   free (byte_abs);
  605.   if (motion_cost)
  606.     free_mem4Dint (motion_cost);
  608.   if ((params->SearchMode == FAST_FULL_SEARCH) && (!params->IntraProfile) )
  609.     ClearFastFullIntegerSearch ();
  610. }
  612. static inline int mv_bits_cost(short ***all_mv, short ***p_mv, int by, int bx, int step_v0, int step_v, int step_h0, int step_h, int mvd_bits)
  613. {
  614.   int v, h;
  615.   for (v=by; v<by + step_v0; v+=step_v)
  616.   {
  617.     for (h=bx; h<bx + step_h0; h+=step_h)
  618.     {
  619.       mvd_bits += mvbits[ all_mv[v][h][0] - p_mv[v][h][0] ];
  620.       mvd_bits += mvbits[ all_mv[v][h][1] - p_mv[v][h][1] ];
  621.     }
  622.   }
  623.   return mvd_bits;
  624. }
  626. /*!
  627.  ***********************************************************************
  628.  * brief
  629.  *    Motion Cost for Bidirectional modes
  630.  ***********************************************************************
  631.  */
  632. int BPredPartitionCost (Macroblock *currMB,
  633.                         int   blocktype,
  634.                         int   block8x8,
  635.                         short ref_l0,
  636.                         short ref_l1,
  637.                         int   lambda_factor,
  638.                         int   list)
  639. {
  640.   static int  bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}};
  641.   static int  by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}};
  643.   int   curr_blk[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; // ABT pred.error buffer
  644.   int   bsx       = imin(params->blc_size[blocktype][0], 8);
  645.   int   bsy       = imin(params->blc_size[blocktype][1], 8);
  647.   int   pic_pix_x, pic_pix_y, block_x, block_y;
  648.   int   v, h, mcost, i, j, k;
  649.   int   mvd_bits  = 0;
  650.   int   parttype  = (blocktype < 4 ? blocktype : 4);
  651.   int   step_h0   = (params->part_size[ parttype][0]);
  652.   int   step_v0   = (params->part_size[ parttype][1]);
  653.   int   step_h    = (params->part_size[blocktype][0]);
  654.   int   step_v    = (params->part_size[blocktype][1]);
  655.   int   bxx, byy;                               // indexing curr_blk
  656.   int   by0_part = by0[parttype][block8x8];
  657.   int   bx0_part = bx0[parttype][block8x8];
  659.   short   ***all_mv_l0 = img->bipred_mv[list][LIST_0][ref_l0][blocktype]; 
  660.   short   ***all_mv_l1 = img->bipred_mv[list][LIST_1][ref_l1][blocktype]; 
  661.   short   ***p_mv_l0   = img->pred_mv[LIST_0][ref_l0][blocktype];
  662.   short   ***p_mv_l1   = img->pred_mv[LIST_1][ref_l1][blocktype];
  663.   imgpel  (*mb_pred)[16] = img->mb_pred[0];
  665.   // List0 
  666.   mvd_bits = mv_bits_cost(all_mv_l0, p_mv_l0, by0_part, bx0_part, step_v0, step_v, step_h0, step_h, mvd_bits);
  667.   // List1
  668.   mvd_bits = mv_bits_cost(all_mv_l1, p_mv_l1, by0_part, bx0_part, step_v0, step_v, step_h0, step_h, mvd_bits);
  670.   mcost = WEIGHTED_COST (lambda_factor, mvd_bits);
  672.   //----- cost of residual signal -----
  673.   for (byy=0, v=by0_part; v < by0_part + step_v0; byy += 4, v++)
  674.   {
  676.     pic_pix_y = img->opix_y + (block_y = (v<<2));
  677.     for (bxx=0, h = bx0_part; h < bx0_part + step_h0; bxx += 4, h++)
  678.     {
  679.       pic_pix_x = img->opix_x + (block_x = (h<<2));
  680.       LumaPredictionBi (currMB, block_x, block_y, 4, 4, blocktype, blocktype, ref_l0, ref_l1, list);
  682.       for (k = j = 0; j < 4; j++)
  683.       {
  684.         for (i = 0; i < 4; i++)
  685.           diff64[k++] = curr_blk[byy+j][bxx+i] =
  686.           pCurImg[pic_pix_y+j][pic_pix_x+i] - mb_pred[j+block_y][i+block_x];
  687.       }
  689.       if ((!params->Transform8x8Mode) || (blocktype>4))
  690.       {
  691.         mcost += distortion4x4 (diff64);
  692.       }
  693.     }
  694.   }
  695.   if (params->Transform8x8Mode && (blocktype<=4))  // tchen 4-29-04
  696.   {
  697.     for (byy=0; byy < params->blc_size[parttype][1]; byy += bsy)
  698.       for (bxx=0; bxx < params->blc_size[parttype][0]; bxx += bsx)
  699.       {
  700.         for (k=0, j = byy; j < byy + 8; j++, k += 8)
  701.           memcpy(&diff64[k], &(curr_blk[j][bxx]), 8 * sizeof(int));
  703.         mcost += distortion8x8(diff64);
  704.       }
  705.   }
  706.   return mcost;
  707. }
  710. /*!
  711.  ***********************************************************************
  712.  * brief
  713.  *    Block motion search
  714.  ***********************************************************************
  715.  */
  716. int                                         //!< minimum motion cost after search
  717. BlockMotionSearch (Macroblock *currMB,      //!< Current Macroblock
  718.                    short     ref,           //!< reference idx
  719.                    int       list,          //!< reference picture list
  720.                    int       mb_x,          //!< x-coordinate inside macroblock
  721.                    int       mb_y,          //!< y-coordinate inside macroblock
  722.                    int       blocktype,     //!< block type (1-16x16 ... 7-4x4)
  723.                    int       search_range,  //!< 1-d search range for integer-position search
  724.                    int*      lambda_factor) //!< lagrangian parameter for determining motion cost
  725. {
  726.   // each 48-pel line stores the 16 luma pels (at 0) followed by 8 or 16 crcb[0] (at 16) and crcb[1] (at 32) pels
  727.   // depending on the type of chroma subsampling used: YUV 4:4:4, 4:2:2, and 4:2:0
  728.   imgpel *orig_pic_tmp = orig_pic;
  730.   int   apply_bi_weights = params->UseWeightedReferenceME && ((img->type == B_SLICE) && active_pps->weighted_bipred_idc != 0);
  731.   int   apply_weights    = params->UseWeightedReferenceME &&
  732.                            ((active_pps->weighted_pred_flag  && (img->type == P_SLICE || img->type == SP_SLICE)) || apply_bi_weights);
  734.   short     mv[2];
  735.   int       i, j;
  737.   int       max_value = INT_MAX;
  738.   int       min_mcost = max_value;
  740.   int       block_x   = (mb_x>>2);
  741.   int       block_y   = (mb_y>>2);
  743.   int       bsx       = params->blc_size[blocktype][0];
  744.   int       bsy       = params->blc_size[blocktype][1];
  746.   int       pic_pix_x = img->opix_x + mb_x;
  747.   int       pic_pix_y = img->opix_y + mb_y;
  749.   int pic_pix_x_c = pic_pix_x >> (shift_cr_x);
  750.   int pic_pix_y_c = pic_pix_y >> (shift_cr_y);
  751.   int bsx_c = bsx >> (shift_cr_x);
  752.   int bsy_c = bsy >> (shift_cr_y);
  754.   short*    pred_mv = img->pred_mv[list][ref][blocktype][block_y][block_x];
  755.   short***   all_mv = &img->all_mv[list][ref][blocktype][block_y];
  756.   int list_offset = ((img->MbaffFrameFlag) && (currMB->mb_field)) ? img->current_mb_nr % 2 ? 4 : 2 : 0;
  757.   int *prevSad = (params->SearchMode == EPZS)? EPZSDistortion[list + list_offset][blocktype - 1]: NULL;
  759. #if GET_METIME
  760.   static TIME_T me_time_start;
  761.   static TIME_T me_time_end;
  762.   time_t me_tmp_time;
  763.   gettime( &me_time_start );    // start time ms
  764. #endif
  765.   PrepareMEParams(apply_weights, params->ChromaMEEnable, list + list_offset, ref);
  767.   //==================================
  768.   //=====   GET ORIGINAL BLOCK   =====
  769.   //==================================
  770.   for (j = pic_pix_y; j < pic_pix_y + bsy; j++)
  771.   {
  772.     memcpy(orig_pic_tmp,&pCurImg[j][pic_pix_x], bsx *sizeof(imgpel));
  773.     orig_pic_tmp += bsx;
  774.   }
  776.   ChromaMEEnable = params->ChromaMEEnable;
  777.   if ( ChromaMEEnable )
  778.   {
  779.     // copy the original cmp1 and cmp2 data to the orig_pic matrix
  780.     for ( i = 1; i<=2; i++)
  781.     {
  782.       orig_pic_tmp = orig_pic + (256 << (i - 1));
  783.       for (j = pic_pix_y_c; j < pic_pix_y_c + bsy_c; j++)
  784.       {
  785.         memcpy(orig_pic_tmp, &(pImgOrg[i][j][pic_pix_x_c]), bsx_c * sizeof(imgpel));
  786.         orig_pic_tmp += bsx_c;
  787.       }
  788.     }
  789.   }
  791.   if (params->SearchMode == UM_HEX)
  792.   {
  793.     UMHEX_blocktype = blocktype;
  794.     bipred_flag = 0;
  795.   }
  796.   else if (params->SearchMode == UM_HEX_SIMPLE)
  797.   {
  798.     smpUMHEX_setup(ref, list, block_y, block_x, blocktype, img->all_mv );
  799.   }
  801.   // Set if 8x8 transform will be used if SATD is used
  802.   test8x8transform = params->Transform8x8Mode && blocktype <= 4;
  804.   //===========================================
  805.   //=====   GET MOTION VECTOR PREDICTOR   =====
  806.   //===========================================
  808.   if (params->SearchMode == UM_HEX)
  809.     UMHEXSetMotionVectorPredictor(currMB, pred_mv, enc_picture->motion.ref_idx[list], enc_picture->motion.mv[list], ref, list, mb_x, mb_y, bsx, bsy, &search_range);
  810.   else
  811.     SetMotionVectorPredictor (currMB, pred_mv, enc_picture->motion.ref_idx[list], enc_picture->motion.mv[list], ref, list, mb_x, mb_y, bsx, bsy);
  814.   //==================================
  815.   //=====   INTEGER-PEL SEARCH   =====
  816.   //==================================
  817.   if (params->EPZSSubPelGrid)
  818.   {
  819.     mv[0] = pred_mv[0];
  820.     mv[1] = pred_mv[1];
  821.   }
  822.   else
  823.   {
  824.     mv[0] = (pred_mv[0] + 2)>> 2;
  825.     mv[1] = (pred_mv[1] + 2)>> 2;
  826.   }
  828.   if (!params->rdopt)
  829.   {
  830.     //--- adjust search center so that the (0,0)-vector is inside ---
  831.     mv[0] = iClip3 (-search_range<<(params->EPZSGrid), search_range<<(params->EPZSGrid), mv[0]);
  832.     mv[1] = iClip3 (-search_range<<(params->EPZSGrid), search_range<<(params->EPZSGrid), mv[1]);
  833.   }
  835.   // valid search range limits could be precomputed once during the initialization process
  836.   clip_mv_range(img, search_range, mv, params->EPZSGrid);
  838.   //--- perform motion search ---
  839.     min_mcost = IntPelME (currMB, orig_pic, ref, list, list_offset,
  840.     enc_picture->motion.ref_idx, enc_picture->motion.mv, pic_pix_x, pic_pix_y, blocktype,
  841.     pred_mv, mv, search_range<<(params->EPZSGrid), min_mcost, lambda_factor[F_PEL], apply_weights);
  843.   //===== convert search center to quarter-pel units =====
  844.   if (params->EPZSSubPelGrid == 0 || params->SearchMode != EPZS)
  845.   {
  846.     mv[0] <<= 2;
  847.     mv[1] <<= 2;
  848.   }
  850.   //==============================
  851.   //=====   SUB-PEL SEARCH   =====
  852.   //============================== 
  853.   ChromaMEEnable = (params->ChromaMEEnable == ME_YUV_FP_SP ) ? 1 : 0; // set it externally
  855.   if (!params->DisableSubpelME)
  856.   {
  857.     if (params->SearchMode != EPZS || (ref == 0 || img->structure != FRAME || (ref > 0 && min_mcost < 3.5 * prevSad[pic_pix_x >> 2])))
  858.     {
  859.       if ( !start_me_refinement_hp )
  860.       {
  861.         min_mcost = max_value;
  862.       }
  863.       min_mcost =  SubPelME (orig_pic, ref, list, list_offset, pic_pix_x, pic_pix_y, blocktype,
  864.         pred_mv, mv, 9, 9, min_mcost, lambda_factor, apply_weights);
  865.     }
  866.   }
  868.   if (!params->rdopt)
  869.   {
  870.     // Get the skip mode cost
  871.     if (blocktype == 1 && (img->type == P_SLICE||img->type == SP_SLICE))
  872.     {
  873.       int cost;
  875.       FindSkipModeMotionVector (currMB);
  877.       cost  = GetSkipCostMB (currMB);
  878.       cost -= ((lambda_factor[Q_PEL] + 4096) >> 13);
  879.       if (cost < min_mcost)
  880.       {
  881.         min_mcost = cost;
  882.         mv[0]      = img->all_mv [0][0][0][0][0][0];
  883.         mv[1]      = img->all_mv [0][0][0][0][0][1];
  884.       }
  885.     } 
  886.   }
  888.   //===============================================
  889.   //=====   SET MV'S AND RETURN MOTION COST   =====
  890.   //===============================================
  892.   // Set first line
  893.   for (i=block_x; i < block_x + (bsx>>2); i++)
  894.   {
  895.     all_mv[0][i][0] = mv[0];
  896.     all_mv[0][i][1] = mv[1];
  897.   }
  899.   // set all other lines
  900.   for (j=1; j < (bsy>>2); j++)
  901.   {
  902.     memcpy(all_mv[j][block_x], all_mv[0][block_x], (bsx>>2) * 2 * sizeof(short));
  903.   }
  906.   // Bipred ME consideration: returns minimum bipred cost
  907.   if (img->type == B_SLICE && is_bipred_enabled(blocktype) && (ref == 0)) 
  908.   {
  909.     BiPredBlockMotionSearch(currMB, mv, pred_mv, ref, list, mb_x, mb_y, blocktype, search_range, apply_bi_weights, lambda_factor);
  910.   }
  912. #if GET_METIME
  913.   gettime(&me_time_end);   // end time ms
  914.   me_tmp_time = timediff (&me_time_start, &me_time_end);
  915.   me_tot_time += me_tmp_time;
  916.   me_time += me_tmp_time;
  917. #endif
  918.   return min_mcost;
  919. }
  922. /*!
  923.  ***********************************************************************
  924.  * brief
  925.  *    Block bi-prediction motion search
  926.  ***********************************************************************
  927.  */
  928. int BiPredBlockMotionSearch(Macroblock *currMB,      //!< Current Macroblock
  929.                    short     mv[2],           //!< current list motion vector
  930.                    short*    pred_mv,         //!< current list motion vector predictor
  931.                    short     ref,             //!< reference idx
  932.                    int       list,            //!< reference picture list
  933.                    int       mb_x,            //!< x-coordinate inside macroblock
  934.                    int       mb_y,            //!< y-coordinate inside macroblock
  935.                    int       blocktype,       //!< block type (1-16x16 ... 7-4x4)
  936.                    int       search_range,    //!< 1-d search range for integer-position search
  937.                    int       apply_bi_weights, //!< apply bipred weights
  938.                    int*      lambda_factor)   //!< lagrangian parameter for determining motion cost
  939. {
  940.   int         iteration_no, i, j;
  941.   short       bipred_type = list ? 0 : 1;
  942.   short****** bipred_mv = img->bipred_mv[bipred_type];
  943.   int         min_mcostbi = INT_MAX;
  944.   short       bimv[2] = {0, 0}, tempmv[2] = {0, 0};
  945.   short*      pred_mv1 = NULL;
  946.   short*      pred_mv2 = NULL;
  947.   short*      bi_mv1 = NULL, *bi_mv2 = NULL;
  948.   short       iterlist=list;
  949.   short       pred_mv_bi[2];
  950.   int         block_x   = (mb_x>>2);
  951.   int         block_y   = (mb_y>>2);
  952.   int         bsx       = params->blc_size[blocktype][0];
  953.   int         bsy       = params->blc_size[blocktype][1];
  954.   int         pic_pix_x = img->opix_x + mb_x;
  955.   int         pic_pix_y = img->opix_y + mb_y;
  956.   int         list_offset = ((img->MbaffFrameFlag) && (currMB->mb_field)) ? img->current_mb_nr % 2 ? 4 : 2 : 0;
  958.   if (params->SearchMode == UM_HEX)
  959.   {
  960.     bipred_flag = 1;
  961.     UMHEXSetMotionVectorPredictor(currMB, pred_mv_bi, enc_picture->motion.ref_idx[list ^ 1], enc_picture->motion.mv[(list == LIST_0? LIST_1: LIST_0)], 0, (list == LIST_0? LIST_1: LIST_0), mb_x, mb_y, bsx, bsy, &search_range);
  962.   }
  963.   else
  964.     SetMotionVectorPredictor     (currMB, pred_mv_bi, enc_picture->motion.ref_idx[list ^ 1], enc_picture->motion.mv[(list == LIST_0? LIST_1: LIST_0)], 0, (list == LIST_0? LIST_1: LIST_0), mb_x, mb_y, bsx, bsy);
  966.   if ((params->SearchMode != EPZS) || (params->EPZSSubPelGrid == 0))
  967.   {
  968.     mv[0] = (mv[0] + 2) >> 2;
  969.     mv[1] = (mv[1] + 2) >> 2;
  970.     bimv[0] = (pred_mv_bi[0] + 2)>>2;
  971.     bimv[1] = (pred_mv_bi[1] + 2)>>2;
  972.   }
  973.   else
  974.   {
  975.     bimv[0] = pred_mv_bi[0];
  976.     bimv[1] = pred_mv_bi[1];
  977.   }
  979.   //Bi-predictive motion Refinements
  980.   for (iteration_no = 0; iteration_no <= params->BiPredMERefinements; iteration_no++)
  981.   {
  982.     if (iteration_no & 0x01)
  983.     {
  984.       pred_mv1  = pred_mv;
  985.       pred_mv2  = pred_mv_bi;
  986.       bi_mv1    = mv;
  987.       bi_mv2    = bimv;
  988.       iterlist  = list;
  989.     }
  990.     else
  991.     {
  992.       pred_mv1  = pred_mv_bi;
  993.       pred_mv2  = pred_mv;
  994.       bi_mv1    = bimv;
  995.       bi_mv2    = mv;
  996.       iterlist = list ^ 1;
  997.     }
  999.     tempmv[0] = bi_mv1[0];
  1000.     tempmv[1] = bi_mv1[1];
  1002.     PrepareBiPredMEParams(apply_bi_weights, ChromaMEEnable, iterlist, list_offset, ref);
  1003.     // Get bipred mvs for list iterlist given previously computed mvs from other list
  1004.     min_mcostbi = BiPredME (currMB, orig_pic, ref, iterlist, list_offset, enc_picture->motion.ref_idx, enc_picture->motion.mv,
  1005.       pic_pix_x, pic_pix_y, blocktype, pred_mv1, pred_mv2, bi_mv1, bi_mv2,
  1006.       (params->BiPredMESearchRange <<(params->EPZSGrid))>>iteration_no, min_mcostbi, iteration_no, lambda_factor[F_PEL], apply_bi_weights);
  1008.     if (iteration_no > 0 && (tempmv[0] == bi_mv1[0]) && (tempmv[1] == bi_mv1[1]))
  1009.     {
  1010.       break;
  1011.     }
  1012.   }
  1014.   if ((params->SearchMode != EPZS) || (params->EPZSSubPelGrid == 0))
  1015.   {
  1016.     bi_mv2[0] = (bi_mv2[0] << 2);
  1017.     bi_mv2[1] = (bi_mv2[1] << 2);
  1018.     bi_mv1[0] = (bi_mv1[0] << 2);
  1019.     bi_mv1[1] = (bi_mv1[1] << 2);
  1020.   }
  1022.   if (!params->DisableSubpelME)
  1023.   {
  1024.     if (params->BiPredMESubPel)
  1025.     {
  1026.       min_mcostbi = INT_MAX;
  1027.       PrepareBiPredMEParams(apply_bi_weights, ChromaMEEnable, iterlist, list_offset, ref);
  1029.       min_mcostbi =  SubPelBiPredME (orig_pic, ref, iterlist, pic_pix_x, pic_pix_y, blocktype,
  1030.         pred_mv1, pred_mv2, bi_mv1, bi_mv2, 9, 9, min_mcostbi, lambda_factor, apply_bi_weights);
  1031.     }
  1033.     if (params->BiPredMESubPel==2)
  1034.     {
  1035.       min_mcostbi = INT_MAX;
  1036.       PrepareBiPredMEParams(apply_bi_weights, ChromaMEEnable, iterlist ^ 1, list_offset, ref);
  1038.       min_mcostbi =  SubPelBiPredME (orig_pic, ref, iterlist ^ 1, pic_pix_x, pic_pix_y, blocktype,
  1039.         pred_mv2, pred_mv1, bi_mv2, bi_mv1, 9, 9, min_mcostbi, lambda_factor, apply_bi_weights);
  1040.     }
  1041.   }
  1043.   for (j=block_y; j < block_y + (bsy>>2); j++)
  1044.   {
  1045.     for (i=block_x ; i < block_x + (bsx>>2); i++)
  1046.     {
  1047.       bipred_mv[iterlist    ][ref][blocktype][j][i][0] = bi_mv1[0];
  1048.       bipred_mv[iterlist    ][ref][blocktype][j][i][1] = bi_mv1[1];
  1049.       bipred_mv[iterlist ^ 1][ref][blocktype][j][i][0] = bi_mv2[0];
  1050.       bipred_mv[iterlist ^ 1][ref][blocktype][j][i][1] = bi_mv2[1];
  1051.     }
  1052.   }
  1053.   return min_mcostbi;
  1054. }
  1056. /*!
  1057.  ***********************************************************************
  1058.  * brief
  1059.  *    Motion Cost for Bidirectional modes
  1060.  ***********************************************************************
  1061.  */
  1062. int BIDPartitionCost (Macroblock *currMB, 
  1063.                       int   blocktype,
  1064.                       int   block8x8,
  1065.                       char  cur_ref[2],
  1066.                       int   lambda_factor)
  1067. {
  1068.   static int  bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}};
  1069.   static int  by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}};
  1071.   int   curr_blk[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; // ABT pred.error buffer
  1072.   int   bsx       = imin(params->blc_size[blocktype][0],8);
  1073.   int   bsy       = imin(params->blc_size[blocktype][1],8);
  1075.   int   pic_pix_x, pic_pix_y, block_x, block_y;
  1076.   int   v, h, mcost, i, j, k;
  1077.   int   mvd_bits  = 0;
  1078.   int   parttype  = (blocktype<4?blocktype:4);
  1079.   int   step_h0   = (params->part_size[ parttype][0]);
  1080.   int   step_v0   = (params->part_size[ parttype][1]);
  1081.   int   step_h    = (params->part_size[blocktype][0]);
  1082.   int   step_v    = (params->part_size[blocktype][1]);
  1083.   int   bxx, byy;                               // indexing curr_blk
  1084.   int   bx = bx0[parttype][block8x8];
  1085.   int   by = by0[parttype][block8x8];
  1086.   short   ***   p_mv_l0 = img->pred_mv[LIST_0][(int) cur_ref[LIST_0]][blocktype];
  1087.   short   ***   p_mv_l1 = img->pred_mv[LIST_1][(int) cur_ref[LIST_1]][blocktype];
  1088.   short   *** all_mv_l0 = img->all_mv [LIST_0][(int) cur_ref[LIST_0]][blocktype];
  1089.   short   *** all_mv_l1 = img->all_mv [LIST_1][(int) cur_ref[LIST_1]][blocktype];
  1090.   short bipred_me =  0; //no bipred for this case 
  1091.   imgpel  (*mb_pred)[16] = img->mb_pred[0];
  1093.   //----- cost for motion vector bits -----
  1094.   // Should write a separate, small function to do this processing
  1095.   // List0 
  1096.   mvd_bits = mv_bits_cost(all_mv_l0, p_mv_l0, by, bx, step_v0, step_v, step_h0, step_h, mvd_bits);
  1097.   // List1
  1098.   mvd_bits = mv_bits_cost(all_mv_l1, p_mv_l1, by, bx, step_v0, step_v, step_h0, step_h, mvd_bits);
  1100.   mcost = WEIGHTED_COST (lambda_factor, mvd_bits);
  1102.   //----- cost of residual signal -----
  1103.   for (byy=0, v=by; v<by + step_v0; byy+=4, v++)
  1104.   {
  1105.     pic_pix_y = img->opix_y + (block_y = (v<<2));
  1106.     for (bxx=0, h=bx; h<bx + step_h0; bxx+=4, h++)
  1107.     {
  1108.       pic_pix_x = img->opix_x + (block_x = (h<<2));
  1109.       LumaPrediction (currMB, block_x, block_y, 4, 4, 2, blocktype, blocktype, (short) cur_ref[0], (short) cur_ref[1], bipred_me);
  1111.       for (k=j=0; j<4; j++)
  1112.       {
  1113.         for (  i=0; i<4; i++)
  1114.           diff64[k++] = curr_blk[byy+j][bxx+i] =
  1115.           pCurImg[pic_pix_y+j][pic_pix_x+i] - mb_pred[j+block_y][i+block_x];
  1116.       }
  1117.       if ((!params->Transform8x8Mode) || (blocktype>4))
  1118.         mcost += distortion4x4 (diff64);
  1119.     }
  1120.   }
  1122.   if (params->Transform8x8Mode && (blocktype<=4))  // tchen 4-29-04
  1123.   {
  1124.     for (byy=0; byy < params->blc_size[parttype][1]; byy+=bsy)
  1125.     {
  1126.       for (bxx=0; bxx<params->blc_size[parttype][0]; bxx+=bsx)
  1127.       {
  1128.         for (k=0, j=byy;j<byy + 8;j++, k += 8)
  1129.           memcpy(&diff64[k], &(curr_blk[j][bxx]), 8 * sizeof(int));
  1131.         mcost += distortion8x8(diff64);
  1132.       }
  1133.     }
  1134.   }
  1135.   return mcost;
  1136. }
  1138. /*!
  1139.  ************************************************************************
  1140.  * brief
  1141.  *    Get cost for skip mode for an macroblock
  1142.  ************************************************************************
  1143.  */
  1144. int GetSkipCostMB (Macroblock *currMB)
  1145. {
  1146.   int block_y, block_x, pic_pix_y, pic_pix_x, i, j, k;
  1147.   int cost = 0;
  1149.   int curr_diff[8][8];
  1150.   int mb_x, mb_y;
  1151.   int block;
  1152.   imgpel  (*mb_pred)[16] = img->mb_pred[0];
  1154.   for(block = 0;block < 4;block++)
  1155.   {
  1156.     mb_y    = (block >>   1)<<3;
  1157.     mb_x    = (block & 0x01)<<3;
  1158.     for (block_y = mb_y; block_y < mb_y+8; block_y += 4)
  1159.     {
  1160.       pic_pix_y = img->opix_y + block_y;
  1161.       for (block_x = mb_x; block_x < mb_x + 8; block_x += 4)
  1162.       {
  1163.         pic_pix_x = img->opix_x + block_x;
  1165.         //===== prediction of 4x4 block =====
  1166.         LumaPrediction (currMB, block_x, block_y, 4, 4, 0, 0, 0, 0, 0, 0);
  1168.         //===== get displaced frame difference ======
  1169.         for (k = j = 0; j < 4; j++)
  1170.         {
  1171.           for (i = 0; i < 4; i++, k++)
  1172.           {
  1173.             diff[k] = curr_diff[block_y-mb_y+j][block_x-mb_x+i] = pCurImg[pic_pix_y+j][pic_pix_x+i] - mb_pred[j+block_y][i+block_x];
  1174.           }
  1175.         }
  1177.         if(!((params->rdopt==0) && (params->Transform8x8Mode)))
  1178.           cost += distortion4x4 (diff);
  1179.       }
  1180.     }
  1182.     if((params->rdopt == 0) && (params->Transform8x8Mode))
  1183.     {
  1184.       for(k=j=0; j<8; j++, k+=8)
  1185.         memcpy(&diff64[k], &(curr_diff[j]), 8 * sizeof(int));
  1186.       cost += distortion8x8 (diff64);
  1187.     }
  1188.   }
  1190.   return cost;
  1191. }
  1193. /*!
  1194.  ************************************************************************
  1195.  * brief
  1196.  *    Find motion vector for the Skip mode
  1197.  ************************************************************************
  1198.  */
  1199. void FindSkipModeMotionVector (Macroblock *currMB)
  1200. {
  1201.   int   bx, by;
  1202.   short ***all_mv = img->all_mv[0][0][0];
  1204.   short pmv[2];
  1206.   int zeroMotionAbove;
  1207.   int zeroMotionLeft;
  1208.   PixelPos mb_a, mb_b;
  1209.   int      a_mv_y = 0;
  1210.   int      a_ref_idx = 0;
  1211.   int      b_mv_y = 0;
  1212.   int      b_ref_idx = 0;
  1213.   short    ***mv = enc_picture->motion.mv[LIST_0];
  1214.   int *mb_size = img->mb_size[IS_LUMA];
  1217.   get4x4Neighbour(currMB,-1, 0, mb_size, &mb_a);
  1218.   get4x4Neighbour(currMB, 0,-1, mb_size, &mb_b);
  1220.   if (mb_a.available)
  1221.   {
  1222.     a_mv_y    = mv[mb_a.pos_y][mb_a.pos_x][1];
  1223.     a_ref_idx = enc_picture->motion.ref_idx[LIST_0][mb_a.pos_y][mb_a.pos_x];
  1225.     if (currMB->mb_field && !img->mb_data[mb_a.mb_addr].mb_field)
  1226.     {
  1227.       a_mv_y    /=2;
  1228.       a_ref_idx *=2;
  1229.     }
  1230.     if (!currMB->mb_field && img->mb_data[mb_a.mb_addr].mb_field)
  1231.     {
  1232.       a_mv_y    *= 2;
  1233.       a_ref_idx >>=1;
  1234.     }
  1235.   }
  1237.   if (mb_b.available)
  1238.   {
  1239.     b_mv_y    = mv[mb_b.pos_y][mb_b.pos_x][1];
  1240.     b_ref_idx = enc_picture->motion.ref_idx[LIST_0][mb_b.pos_y][mb_b.pos_x];
  1242.     if (currMB->mb_field && !img->mb_data[mb_b.mb_addr].mb_field)
  1243.     {
  1244.       b_mv_y    /=2;
  1245.       b_ref_idx *=2;
  1246.     }
  1247.     if (!currMB->mb_field && img->mb_data[mb_b.mb_addr].mb_field)
  1248.     {
  1249.       b_mv_y    *=2;
  1250.       b_ref_idx >>=1;
  1251.     }
  1252.   }
  1254.   zeroMotionLeft  = !mb_a.available ? 1 : a_ref_idx==0 && mv[mb_a.pos_y][mb_a.pos_x][0]==0 && a_mv_y==0 ? 1 : 0;
  1255.   zeroMotionAbove = !mb_b.available ? 1 : b_ref_idx==0 && mv[mb_b.pos_y][mb_b.pos_x][0]==0 && b_mv_y==0 ? 1 : 0;
  1257.   if (zeroMotionAbove || zeroMotionLeft)
  1258.   {
  1259.     memset(all_mv [0][0], 0, 4 * 4 * 2* sizeof(short));
  1260.   }
  1261.   else
  1262.   {
  1263.     SetMotionVectorPredictor (currMB, pmv, enc_picture->motion.ref_idx[LIST_0], mv, 0, LIST_0, 0, 0, 16, 16);
  1264.     for (bx = 0;bx < 4;bx++)
  1265.     {
  1266.       memcpy(all_mv [0][bx], pmv, 2* sizeof(short));
  1267.     }
  1269.     for (by = 1;by < 4;by++)
  1270.       memcpy(all_mv [by][0], all_mv [0][0], 4 * 2* sizeof(short));
  1271.   }
  1272. }
  1274. /*!
  1275.  ************************************************************************
  1276.  * brief
  1277.  *    Get cost for direct mode for an 8x8 block
  1278.  ************************************************************************
  1279.  */
  1280. int GetDirectCost8x8 (Macroblock *currMB, int block, int *cost8x8)
  1281. {
  1282.   int block_y, block_x, pic_pix_y, pic_pix_x, i, j, k;
  1283.   int curr_diff[8][8];
  1284.   int cost  = 0;
  1285.   int mb_y  = (block/2)<<3;
  1286.   int mb_x  = (block%2)<<3;
  1287.   short bipred_me  = 0;
  1288.   imgpel  (*mb_pred)[16] = img->mb_pred[0];
  1290.   for (block_y=mb_y; block_y<mb_y+8; block_y+=4)
  1291.   {
  1292.     pic_pix_y = img->opix_y + block_y;
  1294.     for (block_x=mb_x; block_x<mb_x+8; block_x+=4)
  1295.     {
  1296.       pic_pix_x = img->opix_x + block_x;
  1298.       if (direct_pdir[pic_pix_y>>2][pic_pix_x>>2]<0)
  1299.       {
  1300.         *cost8x8=INT_MAX;
  1301.         return INT_MAX; //mode not allowed
  1302.       }
  1304.       //===== prediction of 4x4 block =====
  1306.       LumaPrediction (currMB, block_x, block_y, 4, 4,
  1307.         direct_pdir[pic_pix_y>>2][pic_pix_x>>2], 0, 0,
  1308.         direct_ref_idx[LIST_0][pic_pix_y>>2][pic_pix_x>>2],
  1309.         direct_ref_idx[LIST_1][pic_pix_y>>2][pic_pix_x>>2], bipred_me);
  1311.       //===== get displaced frame difference ======
  1312.       for (k=j=0; j<4; j++)
  1313.         for (i=0; i<4; i++, k++)
  1314.         {
  1315.           diff[k] = curr_diff[block_y-mb_y+j][block_x-mb_x+i] =
  1316.             pCurImg[pic_pix_y+j][pic_pix_x+i] - mb_pred[j+block_y][i+block_x];
  1317.         }
  1319.         cost += distortion4x4 (diff);
  1320.     }
  1321.   }
  1323.   if((params->rdopt == 0) && (params->Transform8x8Mode))
  1324.   {
  1325.     k=0;
  1326.     for(j=0; j<8; j++, k+=8)
  1327.       memcpy(&diff64[k], &(curr_diff[j]), 8 * sizeof(int));          
  1329.     *cost8x8 += distortion8x8 (diff64);
  1330.   }
  1332.   return cost;
  1333. }
  1337. /*!
  1338.  ************************************************************************
  1339.  * brief
  1340.  *    Get cost for direct mode for an macroblock
  1341.  ************************************************************************
  1342.  */
  1343. int GetDirectCostMB (Macroblock *currMB, int bslice)
  1344. {
  1345.   int i;
  1346.   int cost = 0;
  1347.   int cost8x8 = 0;
  1349.   for (i=0; i<4; i++)
  1350.   {
  1351.     cost += GetDirectCost8x8 (currMB, i, &cost8x8);
  1352.     if (cost8x8 == INT_MAX) return INT_MAX;
  1353.   }
  1355.   switch(params->Transform8x8Mode)
  1356.   {
  1357.   case 1: // Mixture of 8x8 & 4x4 transform
  1358.     if((cost8x8 < cost)||
  1359.       !(params->InterSearch[bslice][5] &&
  1360.       params->InterSearch[bslice][6] &&
  1361.       params->InterSearch[bslice][7])
  1362.       )
  1363.     {
  1364.       cost = cost8x8; //return 8x8 cost
  1365.     }
  1366.     break;
  1367.   case 2: // 8x8 Transform only
  1368.     cost = cost8x8;
  1369.     break;
  1370.   default: // 4x4 Transform only
  1371.     break;
  1372.   }
  1374.   return cost;
  1375.   // T.Nishi(MEI ACC) 04-28-2004 end
  1376. }
  1379. /*!
  1380.  ************************************************************************
  1381.  * brief
  1382.  *    Motion search for a partition
  1383.  ************************************************************************
  1384.  */
  1385. void
  1386. PartitionMotionSearch (Macroblock *currMB,
  1387.                        int    blocktype,
  1388.                        int    block8x8,
  1389.                        int    *lambda_factor)
  1390. {
  1391.   static int  bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}};
  1392.   static int  by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}};
  1394.   char  **ref_array;
  1395.   short ***mv_array;
  1396.   short *all_mv;
  1397.   short ref;
  1398.   int   v, h, mcost, search_range, i, j;
  1399.   int   pic_block_x, pic_block_y;
  1400.   int   bslice    = (img->type==B_SLICE);
  1401.   int   parttype  = (blocktype < 4 ? blocktype : 4);
  1402.   int   step_h0   = (params->part_size[ parttype][0]);
  1403.   int   step_v0   = (params->part_size[ parttype][1]);
  1404.   int   step_h    = (params->part_size[blocktype][0]);
  1405.   int   step_v    = (params->part_size[blocktype][1]);
  1406.   int   list;
  1407.   int   numlists  = bslice ? 2 : 1;
  1408.   int   list_offset = currMB->list_offset;
  1409.   int   *m_cost;
  1410.   int   by = by0[parttype][block8x8];
  1411.   int   bx = bx0[parttype][block8x8];
  1413.   //===== LOOP OVER REFERENCE FRAMES =====
  1414.   for (list=0; list<numlists;list++)
  1415.   {
  1416.     for (ref=0; ref < listXsize[list+list_offset]; ref++)
  1417.     {
  1418.       m_cost = &motion_cost[blocktype][list][ref][block8x8];
  1419.       //----- set search range ---
  1420.       if      (params->full_search == 2)
  1421.         search_range = params->search_range;
  1422.       else if (params->full_search == 1)
  1423.         search_range = params->search_range /  (imin(ref,1)+1);
  1424.       else
  1425.         search_range = params->search_range / ((imin(ref,1)+1) * imin(2,blocktype));
  1427.       //----- set arrays -----
  1428.       ref_array = enc_picture->motion.ref_idx[list];
  1429.       mv_array  = enc_picture->motion.mv[list];
  1431.       //----- init motion cost -----
  1432.       //motion_cost[blocktype][list][ref][block8x8] = 0;
  1433.       if (Motion_Selected != 1)
  1434.         *m_cost = 0;
  1436.       //===== LOOP OVER SUB MACRO BLOCK partitions
  1437.       for (v=by; v<by + step_v0; v += step_v)
  1438.       {
  1439.         pic_block_y = img->block_y + v;
  1441.         for (h=bx; h<bx+step_h0; h+=step_h)
  1442.         {
  1443.           all_mv = img->all_mv[list][ref][blocktype][v][h];
  1444.           pic_block_x = img->block_x + h;
  1446.           //--- motion search for block ---          
  1447.           if (Motion_Selected != 1)
  1448.           {
  1449.             mcost = BlockMotionSearch     (currMB, ref, list, h<<2, v<<2, blocktype, search_range, lambda_factor);
  1450.             *m_cost += mcost;
  1451.             if ( (params->Transform8x8Mode == 1) && params->RDOQ_CP_MV && (blocktype == 4) && currMB->luma_transform_size_8x8_flag)
  1452.             {
  1453.               tmp_mv8[list][ref][v][h][0] = all_mv[0];
  1454.               tmp_mv8[list][ref][v][h][1] = all_mv[1];
  1455.               tmp_pmv8[list][ref][v][h][0] = img->pred_mv[list][ref][blocktype][v][h][0];
  1456.               tmp_pmv8[list][ref][v][h][1] = img->pred_mv[list][ref][blocktype][v][h][1];
  1457.               motion_cost8[list][ref][block8x8] = mcost;
  1458.             }
  1459.           }
  1460.           else
  1461.             updateMV_mp(m_cost, ref, list, h, v, blocktype, lambda_factor, block8x8);
  1463.           //--- set motion vectors and reference frame (for motion vector prediction) ---
  1464.           for (j=pic_block_y; j<pic_block_y + step_v; j++)
  1465.           {
  1466.             memset(&ref_array [j][pic_block_x], ref, step_h * sizeof(char));
  1468.             for (i=pic_block_x; i<pic_block_x + step_h; i++)
  1469.             {
  1470.               memcpy(mv_array  [j][i], all_mv, 2* sizeof(short));
  1471.             }
  1472.           }
  1473.         }
  1474.       }
  1475.     }
  1476.   }
  1477. }
  1479. /*!
  1480.  ************************************************************************
  1481.  * brief
  1482.  *    Calculate Direct Motion Vectors  *****
  1483.  ************************************************************************
  1484.  */
  1485. void Get_Direct_Motion_Vectors (Macroblock *currMB)
  1486. {
  1488.   int   block_x, block_y, pic_block_x, pic_block_y, opic_block_x, opic_block_y;
  1489.   short ******all_mvs;
  1490.   int   mv_scale;
  1491.   int refList;
  1492.   int ref_idx;
  1494.   MotionParams *colocated;
  1495.   char  **     ref_pic_l0 = enc_picture->motion.ref_idx[LIST_0];
  1496.   char  **     ref_pic_l1 = enc_picture->motion.ref_idx[LIST_1];
  1498.   if (currMB->list_offset)
  1499.   {
  1500.     if(img->current_mb_nr%2)
  1501.     {
  1502.       colocated = &Co_located->bottom;
  1503.     }
  1504.     else
  1505.     {
  1506.       colocated = &Co_located->top;
  1507.     }
  1508.   }
  1509.   else
  1510.   {
  1511.     colocated = &Co_located->frame;
  1512.   }
  1514.   if (img->direct_spatial_mv_pred_flag)  //spatial direct mode copy from decoder
  1515.   {
  1517.     short l0_refA, l0_refB, l0_refD, l0_refC;
  1518.     short l1_refA, l1_refB, l1_refD, l1_refC;
  1519.     short l0_refX,l1_refX;
  1520.     short pmvfw[2]={0,0},pmvbw[2]={0,0};
  1522.     PixelPos mb_a, mb_b, mb_d, mb_c;
  1523.     int *mb_size = img->mb_size[IS_LUMA];
  1525.     get4x4Neighbour(currMB, -1,  0, mb_size, &mb_a);
  1526.     get4x4Neighbour(currMB,  0, -1, mb_size, &mb_b);
  1527.     get4x4Neighbour(currMB, 16, -1, mb_size, &mb_c);
  1528.     get4x4Neighbour(currMB, -1, -1, mb_size, &mb_d);
  1530.     if (!img->MbaffFrameFlag)
  1531.     {
  1532.       l0_refA = mb_a.available ? ref_pic_l0[mb_a.pos_y][mb_a.pos_x] : -1;
  1533.       l0_refB = mb_b.available ? ref_pic_l0[mb_b.pos_y][mb_b.pos_x] : -1;
  1534.       l0_refD = mb_d.available ? ref_pic_l0[mb_d.pos_y][mb_d.pos_x] : -1;
  1535.       l0_refC = mb_c.available ? ref_pic_l0[mb_c.pos_y][mb_c.pos_x] : l0_refD;
  1537.       l1_refA = mb_a.available ? ref_pic_l1[mb_a.pos_y][mb_a.pos_x] : -1;
  1538.       l1_refB = mb_b.available ? ref_pic_l1[mb_b.pos_y][mb_b.pos_x] : -1;
  1539.       l1_refD = mb_d.available ? ref_pic_l1[mb_d.pos_y][mb_d.pos_x] : -1;
  1540.       l1_refC = mb_c.available ? ref_pic_l1[mb_c.pos_y][mb_c.pos_x] : l1_refD;
  1541.     }
  1542.     else
  1543.     {
  1544.       if (currMB->mb_field)
  1545.       {
  1546.         l0_refA = mb_a.available
  1547.           ? (img->mb_data[mb_a.mb_addr].mb_field  || ref_pic_l0[mb_a.pos_y][mb_a.pos_x] < 0
  1548.           ?  ref_pic_l0[mb_a.pos_y][mb_a.pos_x]
  1549.           :  ref_pic_l0[mb_a.pos_y][mb_a.pos_x] * 2) : -1;
  1551.         l0_refB = mb_b.available
  1552.           ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l0[mb_b.pos_y][mb_b.pos_x] < 0
  1553.           ?  ref_pic_l0[mb_b.pos_y][mb_b.pos_x]
  1554.           :  ref_pic_l0[mb_b.pos_y][mb_b.pos_x] * 2) : -1;
  1556.         l0_refD = mb_d.available
  1557.           ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l0[mb_d.pos_y][mb_d.pos_x] < 0
  1558.           ?  ref_pic_l0[mb_d.pos_y][mb_d.pos_x]
  1559.           :  ref_pic_l0[mb_d.pos_y][mb_d.pos_x] * 2) : -1;
  1561.         l0_refC = mb_c.available
  1562.           ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l0[mb_c.pos_y][mb_c.pos_x] < 0
  1563.           ?  ref_pic_l0[mb_c.pos_y][mb_c.pos_x]
  1564.           :  ref_pic_l0[mb_c.pos_y][mb_c.pos_x] * 2) : l0_refD;
  1566.         l1_refA = mb_a.available
  1567.           ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l1[mb_a.pos_y][mb_a.pos_x] < 0
  1568.           ?  ref_pic_l1[mb_a.pos_y][mb_a.pos_x]
  1569.           :  ref_pic_l1[mb_a.pos_y][mb_a.pos_x] * 2) : -1;
  1571.         l1_refB = mb_b.available
  1572.           ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l1[mb_b.pos_y][mb_b.pos_x] < 0
  1573.           ?  ref_pic_l1[mb_b.pos_y][mb_b.pos_x]
  1574.           :  ref_pic_l1[mb_b.pos_y][mb_b.pos_x] * 2) : -1;
  1576.         l1_refD = mb_d.available
  1577.           ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l1[mb_d.pos_y][mb_d.pos_x] < 0
  1578.           ?  ref_pic_l1[mb_d.pos_y][mb_d.pos_x]
  1579.           :  ref_pic_l1[mb_d.pos_y][mb_d.pos_x] * 2) : -1;
  1581.         l1_refC = mb_c.available
  1582.           ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l1[mb_c.pos_y][mb_c.pos_x] < 0
  1583.           ?  ref_pic_l1[mb_c.pos_y][mb_c.pos_x]
  1584.           :  ref_pic_l1[mb_c.pos_y][mb_c.pos_x] * 2) : l1_refD;
  1585.       }
  1586.       else
  1587.       {
  1588.         l0_refA = mb_a.available
  1589.           ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l0[mb_a.pos_y][mb_a.pos_x]  < 0
  1590.           ?  ref_pic_l0[mb_a.pos_y][mb_a.pos_x] >> 1
  1591.           :  ref_pic_l0[mb_a.pos_y][mb_a.pos_x]) : -1;
  1593.         l0_refB = mb_b.available
  1594.           ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l0[mb_b.pos_y][mb_b.pos_x] < 0
  1595.           ?  ref_pic_l0[mb_b.pos_y][mb_b.pos_x] >> 1
  1596.           :  ref_pic_l0[mb_b.pos_y][mb_b.pos_x]) : -1;
  1598.         l0_refD = mb_d.available
  1599.           ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l0[mb_d.pos_y][mb_d.pos_x] < 0
  1600.           ?  ref_pic_l0[mb_d.pos_y][mb_d.pos_x] >> 1
  1601.           :  ref_pic_l0[mb_d.pos_y][mb_d.pos_x]) : -1;
  1603.         l0_refC = mb_c.available
  1604.           ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l0[mb_c.pos_y][mb_c.pos_x] < 0
  1605.           ?  ref_pic_l0[mb_c.pos_y][mb_c.pos_x] >> 1
  1606.           :  ref_pic_l0[mb_c.pos_y][mb_c.pos_x]) : l0_refD;
  1608.         l1_refA = mb_a.available
  1609.           ? (img->mb_data[mb_a.mb_addr].mb_field || ref_pic_l1[mb_a.pos_y][mb_a.pos_x] < 0
  1610.           ?  ref_pic_l1[mb_a.pos_y][mb_a.pos_x] >> 1
  1611.           :  ref_pic_l1[mb_a.pos_y][mb_a.pos_x]) : -1;
  1613.         l1_refB = mb_b.available
  1614.           ? (img->mb_data[mb_b.mb_addr].mb_field || ref_pic_l1[mb_b.pos_y][mb_b.pos_x] < 0
  1615.           ?  ref_pic_l1[mb_b.pos_y][mb_b.pos_x] >> 1
  1616.           :  ref_pic_l1[mb_b.pos_y][mb_b.pos_x]) : -1;
  1618.         l1_refD = mb_d.available
  1619.           ? (img->mb_data[mb_d.mb_addr].mb_field || ref_pic_l1[mb_d.pos_y][mb_d.pos_x] < 0
  1620.           ?  ref_pic_l1[mb_d.pos_y][mb_d.pos_x] >> 1
  1621.           :  ref_pic_l1[mb_d.pos_y][mb_d.pos_x]) : -1;
  1623.         l1_refC = mb_c.available
  1624.           ? (img->mb_data[mb_c.mb_addr].mb_field || ref_pic_l1[mb_c.pos_y][mb_c.pos_x] < 0
  1625.           ?  ref_pic_l1[mb_c.pos_y][mb_c.pos_x] >> 1
  1626.           :  ref_pic_l1[mb_c.pos_y][mb_c.pos_x]) : l1_refD;
  1627.       }
  1628.     }
  1630.     l0_refX = (l0_refA >= 0 && l0_refB >= 0) ? imin(l0_refA,l0_refB): imax(l0_refA,l0_refB);
  1631.     l0_refX = (l0_refX >= 0 && l0_refC >= 0) ? imin(l0_refX,l0_refC): imax(l0_refX,l0_refC);
  1633.     l1_refX = (l1_refA >= 0 && l1_refB >= 0) ? imin(l1_refA,l1_refB): imax(l1_refA,l1_refB);
  1634.     l1_refX = (l1_refX >= 0 && l1_refC >= 0) ? imin(l1_refX,l1_refC): imax(l1_refX,l1_refC);
  1636.     if (l0_refX >=0)
  1637.       SetMotionVectorPredictor (currMB, pmvfw, enc_picture->motion.ref_idx[LIST_0], enc_picture->motion.mv[LIST_0], l0_refX, LIST_0, 0, 0, 16, 16);
  1639.     if (l1_refX >=0)
  1640.       SetMotionVectorPredictor (currMB, pmvbw, enc_picture->motion.ref_idx[LIST_1], enc_picture->motion.mv[LIST_1], l1_refX, LIST_1, 0, 0, 16, 16);
  1642.     for (block_y=0; block_y<4; block_y++)
  1643.     {
  1644.       pic_block_y  = (img->pix_y  >> 2) + block_y;
  1645.       opic_block_y = (img->opix_y >> 2) + block_y;
  1647.       for (block_x=0; block_x<4; block_x++)
  1648.       {
  1649.         pic_block_x  = (img->pix_x  >> 2) + block_x;
  1650.         opic_block_x = (img->opix_x >> 2) + block_x;
  1652.         all_mvs = img->all_mv;
  1654.         if (l0_refX >=0)
  1655.         {
  1656.           if (!l0_refX  && !colocated->moving_block[opic_block_y][opic_block_x])
  1657.           {
  1658.             memset(all_mvs[LIST_0][0][0][block_y][block_x], 0, 2 * sizeof(short));
  1659.             direct_ref_idx[LIST_0][pic_block_y][pic_block_x]=0;
  1660.           }
  1661.           else
  1662.           {
  1663.             memcpy(all_mvs[LIST_0][l0_refX][0][block_y][block_x], pmvfw, 2 * sizeof(short));
  1664.             direct_ref_idx[LIST_0][pic_block_y][pic_block_x]= (char)l0_refX;
  1665.           }
  1666.         }
  1667.         else
  1668.         {
  1669.           memset(all_mvs[LIST_0][0][0][block_y][block_x], 0, 2 * sizeof(short));
  1670.           direct_ref_idx[LIST_0][pic_block_y][pic_block_x]=-1;
  1671.         }
  1673.         if (l1_refX >=0)
  1674.         {
  1675.           if(l1_refX==0 && !colocated->moving_block[opic_block_y][opic_block_x])
  1676.           {
  1677.             memset(all_mvs[LIST_1][0][0][block_y][block_x], 0, 2 * sizeof(short));
  1678.             direct_ref_idx[LIST_1][pic_block_y][pic_block_x]= (char)l1_refX;
  1679.           }
  1680.           else
  1681.           {
  1682.             memcpy(all_mvs[LIST_1][l1_refX][0][block_y][block_x], pmvbw, 2 * sizeof(short));
  1683.             direct_ref_idx[LIST_1][pic_block_y][pic_block_x]= (char)l1_refX;
  1684.           }
  1685.         }
  1686.         else
  1687.         {
  1688.           memset(all_mvs[LIST_1][0][0][block_y][block_x], 0, 2 * sizeof(short));
  1689.           direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1;
  1690.         }
  1692.         // Test Level Limits if satisfied.
  1693.         if (img->MbaffFrameFlag
  1694.           && (out_of_bounds_mvs(img, all_mvs[LIST_0][l0_refX < 0? 0 : l0_refX][0][block_y][block_x], Q_PEL)
  1695.           ||  out_of_bounds_mvs(img, all_mvs[LIST_1][l1_refX < 0? 0 : l1_refX][0][block_y][block_x], Q_PEL)))
  1696.         {
  1697.           direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1;
  1698.           direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1;
  1699.           direct_pdir           [pic_block_y][pic_block_x] = -1;
  1700.         }
  1701.         else
  1702.         {
  1703.           if (l0_refX < 0 && l1_refX < 0)
  1704.           {
  1705.             direct_ref_idx[LIST_0][pic_block_y][pic_block_x] =
  1706.               direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = 0;
  1707.             l0_refX = 0;
  1708.             l1_refX = 0;
  1709.           }
  1711.           if      (direct_ref_idx[LIST_1][pic_block_y][pic_block_x] == -1)
  1712.             direct_pdir[pic_block_y][pic_block_x] = 0;
  1713.           else if (direct_ref_idx[LIST_0][pic_block_y][pic_block_x] == -1)
  1714.             direct_pdir[pic_block_y][pic_block_x] = 1;
  1715.           else if (active_pps->weighted_bipred_idc == 1)
  1716.           {
  1717.             int weight_sum, i;
  1718.             Boolean invalid_wp = FALSE;
  1719.             for (i=0;i< (active_sps->chroma_format_idc == YUV400 ? 1 : 3); i++)
  1720.             {
  1721.               weight_sum = wbp_weight[0][l0_refX][l1_refX][i] + wbp_weight[1][l0_refX][l1_refX][i];
  1722.               if (weight_sum < -128 ||  weight_sum > 127)
  1723.               {
  1724.                 invalid_wp = TRUE;
  1725.                 break;
  1726.               }
  1727.             }
  1728.             if (invalid_wp == FALSE)
  1729.               direct_pdir[pic_block_y][pic_block_x] = 2;
  1730.             else
  1731.             {
  1732.               direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1;
  1733.               direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1;
  1734.               direct_pdir           [pic_block_y][pic_block_x] = -1;
  1735.             }
  1736.           }
  1737.           else
  1738.             direct_pdir[pic_block_y][pic_block_x] = 2;
  1739.         }
  1740.       }
  1741.     }
  1742.   }
  1743.   else
  1744.   {
  1745.     int64 *refpic = enc_picture->ref_pic_num[LIST_0 +currMB->list_offset];
  1747.     //temporal direct mode copy from decoder
  1748.     for (block_y = 0; block_y < 4; block_y++)
  1749.     {
  1750.       pic_block_y  = (img->pix_y  >> 2) + block_y;
  1751.       opic_block_y = (img->opix_y >> 2) + block_y;
  1753.       for (block_x = 0; block_x < 4; block_x++)
  1754.       {
  1755.         pic_block_x  = (img->pix_x>>2) + block_x;
  1756.         opic_block_x = (img->opix_x>>2) + block_x;
  1757.         all_mvs = img->all_mv;
  1759.         refList = (colocated->ref_idx[LIST_0][opic_block_y][opic_block_x]== -1 ? LIST_1 : LIST_0);
  1760.         ref_idx = colocated->ref_idx[refList][opic_block_y][opic_block_x];
  1762.         // next P is intra mode
  1763.         if (ref_idx==-1)
  1764.         {
  1765.           memset(all_mvs[LIST_0][0][0][block_y][block_x], 0, 2* sizeof(short));
  1766.           memset(all_mvs[LIST_1][0][0][block_y][block_x], 0, 2* sizeof(short));
  1767.           direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = 0;
  1768.           direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = 0;
  1769.           direct_pdir[pic_block_y][pic_block_x] = 2;
  1770.         }
  1771.         // next P is skip or inter mode
  1772.         else
  1773.         {
  1774.           int mapped_idx=INVALIDINDEX;
  1775.           int iref;
  1777.           for (iref=0;iref<imin(img->num_ref_idx_l0_active,listXsize[LIST_0+currMB->list_offset]);iref++)
  1778.           {
  1779.             if (refpic[iref]==colocated->ref_pic_id[refList ][opic_block_y][opic_block_x])
  1780.             {
  1781.               mapped_idx=iref;
  1782.               break;
  1783.             }
  1784.             else //! invalid index. Default to zero even though this case should not happen
  1785.             {
  1786.               mapped_idx=INVALIDINDEX;
  1787.             }
  1788.           }
  1790.           if (mapped_idx !=INVALIDINDEX)
  1791.           {
  1792.             mv_scale = img->mvscale[LIST_0+currMB->list_offset][mapped_idx];
  1794.             if (mv_scale==9999)
  1795.             {
  1796.               // forward
  1797.               memcpy(all_mvs[LIST_0][0][0][block_y][block_x], colocated->mv[refList][opic_block_y][opic_block_x], 2* sizeof(short));
  1798.               // backward
  1799.               memset(all_mvs[LIST_1][0][0][block_y][block_x], 0, 2* sizeof(short));
  1800.             }
  1801.             else
  1802.             {
  1803.               // forward
  1804.               all_mvs[LIST_0][mapped_idx][0][block_y][block_x][0] = (mv_scale * colocated->mv[refList][opic_block_y][opic_block_x][0] + 128) >> 8;
  1805.               all_mvs[LIST_0][mapped_idx][0][block_y][block_x][1] = (mv_scale * colocated->mv[refList][opic_block_y][opic_block_x][1] + 128) >> 8;
  1806.               // backward
  1807.               all_mvs[LIST_1][         0][0][block_y][block_x][0] = ((mv_scale - 256)* colocated->mv[refList][opic_block_y][opic_block_x][0] + 128) >> 8;
  1808.               all_mvs[LIST_1][         0][0][block_y][block_x][1] = ((mv_scale - 256)* colocated->mv[refList][opic_block_y][opic_block_x][1] + 128) >> 8;
  1809.             }
  1811.             // Test Level Limits if satisfied.
  1812.             if ( out_of_bounds_mvs(img, all_mvs[LIST_0][mapped_idx][0][block_y][block_x], Q_PEL)|| out_of_bounds_mvs(img, all_mvs[LIST_1][0][0][block_y][block_x], Q_PEL))
  1813.             {
  1814.               direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1;
  1815.               direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1;
  1816.               direct_pdir[pic_block_y][pic_block_x] = -1;
  1817.             }
  1818.             else
  1819.             {
  1820.               direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = mapped_idx;
  1821.               direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = 0;
  1822.               direct_pdir[pic_block_y][pic_block_x] = 2;
  1823.             }
  1824.           }
  1825.           else
  1826.           {
  1827.             direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1;
  1828.             direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1;
  1829.             direct_pdir[pic_block_y][pic_block_x] = -1;
  1830.           }
  1831.         }
  1832.         if (active_pps->weighted_bipred_idc == 1 && direct_pdir[pic_block_y][pic_block_x] == 2)
  1833.         {
  1834.           int weight_sum, i;
  1835.           short l0_refX = direct_ref_idx[LIST_0][pic_block_y][pic_block_x];
  1836.           short l1_refX = direct_ref_idx[LIST_1][pic_block_y][pic_block_x];
  1837.           for (i=0;i< (active_sps->chroma_format_idc == YUV400 ? 1 : 3); i++)
  1838.           {
  1839.             weight_sum = wbp_weight[0][l0_refX][l1_refX][i] + wbp_weight[1][l0_refX][l1_refX][i];
  1840.             if (weight_sum < -128 ||  weight_sum > 127)
  1841.             {
  1842.               direct_ref_idx[LIST_0][pic_block_y][pic_block_x] = -1;
  1843.               direct_ref_idx[LIST_1][pic_block_y][pic_block_x] = -1;
  1844.               direct_pdir           [pic_block_y][pic_block_x] = -1;
  1845.               break;
  1846.             }
  1847.           }
  1848.         }
  1849.       }
  1850.     }
  1851.   }
  1852. }