me_umhexsmp.h
上传用户:hjq518
上传日期:2021-12-09
资源大小:5084k
文件大小:10k
源码类别:

Audio

开发平台:

Visual C++

  1. /*!
  2.  *************************************************************************************
  3.  *
  4.  * file me_umhexsmp.h
  5.  *
  6.  * brief
  7.  *   Fast integer pixel and sub pixel motion estimation
  8.  *   Improved and simplified from the original UMHexagonS algorithms
  9.  *   See JVT-P021 for details
  10.  *
  11.  * author
  12.  *    Main contributors: (see contributors.h for copyright, address and affiliation details)
  13.  *    - Zhibo Chen                      <chenzhibo@tsinghua.org.cn>
  14.  *    - JianFeng Xu                     <fenax@video.mdc.tsinghua.edu.cn>
  15.  *    - Wenfang Fu                      <fwf@video.mdc.tsinghua.edu.cn>
  16.  *
  17.  *    - Xiaoquan Yi                     <xyi@engr.scu.edu>
  18.  *    - Jun Zhang                       <jzhang2@engr.scu.edu>
  19.  *
  20.  * date
  21.  *    6. Nov. 2006
  22.  *************************************************************************************
  23.  */
  24. #ifndef _ME_UMHEXSMP_H_
  25. #define _ME_UMHEXSMP_H_
  26. #include "mbuffer.h"
  27. unsigned short  SymmetricalCrossSearchThreshold1;
  28. unsigned short  SymmetricalCrossSearchThreshold2;
  29. unsigned short  ConvergeThreshold;
  30. unsigned short  SubPelThreshold1;
  31. unsigned short  SubPelThreshold3;
  32. byte  **smpUMHEX_SearchState;          //state for fractional pel search
  33. int  ***smpUMHEX_l0_cost;       //store SAD information needed for forward median and uplayer prediction
  34. int  ***smpUMHEX_l1_cost;       //store SAD information needed for backward median and uplayer prediction
  35. byte   *smpUMHEX_flag_intra;
  36. int     smpUMHEX_flag_intra_SAD;
  37. int     smpUMHEX_pred_SAD_uplayer;     // Up layer SAD prediction
  38. short   smpUMHEX_pred_MV_uplayer_X;    // Up layer MV predictor X-component
  39. short   smpUMHEX_pred_MV_uplayer_Y;    // Up layer MV predictor Y-component
  40. void    smpUMHEX_init(void);
  41. int     smpUMHEX_get_mem(void);
  42. void    smpUMHEX_free_mem(void);
  43. void    smpUMHEX_decide_intrabk_SAD(void);
  44. void    smpUMHEX_skip_intrabk_SAD(int, int);
  45. void    smpUMHEX_setup(short, int, int, int, int, short ******);
  46. int                                     //  ==> minimum motion cost after search
  47. smpUMHEXIntegerPelBlockMotionSearch (Macroblock *currMB,      // <--  current Macroblock
  48.                                      imgpel   *orig_pic,      // <--  not used
  49.                                      short     ref,           // <--  reference frame (0... or -1 (backward))
  50.                                      int       list,          // <--  reference picture list
  51.                                      int       list_offset,   // <--  MBAFF list offset
  52.                                      char   ***refPic,        // <--  reference array
  53.                                      short ****tmp_mv,        // <--  mv array
  54.                                      int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  55.                                      int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  56.                                      int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  57.                                      short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  58.                                      short     mv[2],         //  --> motion vector (x|y) - in pel units
  59.                                      int       search_range,  // <--  1-d search range in pel units
  60.                                      int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  61.                                      int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  62.                                      int       apply_weights
  63.                                      );
  64. int                                     //  ==> minimum motion cost after search
  65. smpUMHEXSubPelBlockMotionSearch  (
  66.                imgpel* orig_pic,        // <--  original pixel values for the AxB block
  67.                short     ref,           // <--  reference frame (0... or -1 (backward))
  68.                int       list,          // <--  reference picture list
  69.                int       list_offset,   // <--  MBAFF list offset
  70.                int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  71.                int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  72.                int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  73.                short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  74.                short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  75.                int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  76.                int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  77.                int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  78.                int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  79.                int       apply_weights
  80.                );
  81. int                                               //  ==> minimum motion cost after search
  82. smpUMHEXFullSubPelBlockMotionSearch (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  83.                          short     ref,           // <--  reference frame (0... or -1 (backward))
  84.                          int       list,          // <--  reference picture list
  85.                          int       list_offset,   // <--  MBAFF list offset
  86.                          int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  87.                          int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  88.                          int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  89.                          short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  90.                          short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  91.                          int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  92.                          int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  93.                          int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  94.                          int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  95.                          int       apply_weights
  96.                          );
  97. int                                                                 //  ==> minimum motion cost after search
  98. smpUMHEXBipredIntegerPelBlockMotionSearch (Macroblock *currMB,      // <--  current Macroblock
  99.                                            imgpel* cur_pic,         // <--  original pixel values for the AxB block
  100.                                            short     ref,           // <--  reference frame (0... or -1 (backward))
  101.                                            int       list,          // <--  Current reference list
  102.                                            int       list_offset,   // <--  MBAFF list offset
  103.                                            char   ***refPic,        // <--  reference array
  104.                                            short ****tmp_mv,        // <--  mv array
  105.                                            int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  106.                                            int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  107.                                            int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  108.                                            short     pred_mv1[2],   // <--  motion vector predictor (x|y) in sub-pel units
  109.                                            short     pred_mv2[2],   // <--  motion vector predictor (x|y) in sub-pel units
  110.                                            short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  111.                                            short     s_mv[2],       // <--> in: search center (x|y) / out: motion vector (x|y) - in pel units
  112.                                            int       search_range,  // <--  1-d search range in pel units
  113.                                            int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  114.                                            int       iteration_no,  // <--  bi pred iteration number
  115.                                            int       lambda_factor, // <--  lagrangian parameter for determining motion cost
  116.                                            int       apply_weights
  117.                                            );
  118. int                                                   //  ==> minimum motion cost after search
  119. smpUMHEXSubPelBlockME (imgpel*   orig_pic,      // <--  original pixel values for the AxB block
  120.                     short     ref,           // <--  reference frame (0... or -1 (backward))
  121.                     int       list,
  122.                     int       list_offset,   // <--  MBAFF list offset
  123.                     int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
  124.                     int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
  125.                     int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
  126.                     short     pred_mv[2],    // <--  motion vector predictor (x|y) in sub-pel units
  127.                     short     mv[2],         // <--> in: search center (x|y) / out: motion vector (x|y) - in sub-pel units
  128.                     int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
  129.                     int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
  130.                     int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
  131.                     int*      lambda,
  132.                     int       apply_weights
  133.                     );
  134. #endif