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

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

Audio

开发平台：

Visual C++

me_distortion.c：源码内容
  2. /*!
  3. *************************************************************************************
  4. * file me_distortion.c
  5. *
  6. * brief
  7. *    Motion estimation error calculation functions
  8. *
  9. * author
  10. *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11. *      - Alexis Michael Tourapis <alexis.tourapis@dolby.com>
  12. *      - Athanasios Leontaris    <aleon@dolby.com>
  13. *
  14. *************************************************************************************
  15. */
  17. #include "contributors.h"
  19. #include <limits.h>
  21. #include "global.h"
  22. #include "image.h"
  23. #include "memalloc.h"
  24. #include "mb_access.h"
  25. #include "refbuf.h"
  26. #include "mv-search.h"
  27. #include "me_distortion.h"
  31. // Define Global Parameters
  32. // Luma
  33. imgpel *(*get_line[2]) (imgpel****, int, int);
  34. imgpel *(*get_line1[2]) (imgpel****, int, int);
  35. imgpel *(*get_line2[2]) (imgpel****, int, int);
  36. // Chroma
  37. imgpel *(*get_crline[2]) (imgpel****, int, int);
  38. imgpel *(*get_crline1[2]) (imgpel****, int, int);
  39. imgpel *(*get_crline2[2]) (imgpel****, int, int);
  40. // Access method (fast/safe or unconstrained)
  41. int ref_access_method;
  42. int bipred1_access_method;
  43. int bipred2_access_method;
  45. SubImageContainer ref_pic_sub;
  46. SubImageContainer ref_pic1_sub;
  47. SubImageContainer ref_pic2_sub;
  49. short weight1, weight2, offsetBi;
  50. short weight1_cr[2], weight2_cr[2], offsetBi_cr[2];
  51. int weight_luma, weight_cr[2], offset_luma, offset_cr[2];
  52. short img_width, img_height;
  53. int test8x8transform;
  54. int ChromaMEEnable;
  56. // temp storage of pixel difference values prior to applying Hadamard Transform (4x4 or 8x8)
  57. static int diff[MB_PIXELS];
  58. // Hadamard related arrays
  59. static int m[16], d[16];
  60. static int m1[8][8], m2[8][8], m3[8][8];
  61. static imgpel *src_line, *ref_line, *ref1_line, *ref2_line;
  63. int (*computeUniPred[6])(imgpel* , int , int , int , int , int);
  64. int (*computeBiPred) (imgpel* , int , int , int , int , int, int , int);
  65. int (*computeBiPred1[3])(imgpel* , int , int , int , int , int, int , int);
  66. int (*computeBiPred2[3])(imgpel* , int , int , int , int , int, int , int);
  68. /*!
  69.  ***********************************************************************
  70.  * brief
  71.  *    Calculate SA(T)D
  72.  ***********************************************************************
  73.  */
  74. int distortion4x4(int* diff)
  75. {
  76.   int distortion = 0, k, *byte_sse;
  78.   switch(params->ModeDecisionMetric)
  79.   {
  80.   case ERROR_SAD:
  81.     for (k = 0; k < 16; k++)
  82.     {
  83.       distortion += byte_abs [diff [k]];
  84.     }
  85.     break;
  86.   case ERROR_SSE:
  87.     byte_sse = img->quad;
  88.     for (k = 0; k < 16; k++)
  89.     {
  90.       distortion += byte_sse [diff [k]];
  91.     }
  92.     break;
  93.   case ERROR_SATD :
  94.   default:
  95.     distortion = HadamardSAD4x4( diff );
  96.     break;
  97.   }
  99.   return distortion;
  100. }
  102. /*!
  103.  ***********************************************************************
  104.  * brief
  105.  *    Calculate SA(T)D for 8x8
  106.  ***********************************************************************
  107.  */
  108. int distortion8x8(int* diff)
  109. {
  110.   int distortion = 0, k, *byte_sse;
  112.   switch(params->ModeDecisionMetric)
  113.   {
  114.   case ERROR_SAD:
  115.     for (k = 0; k < 64; k++)
  116.     {
  117.       distortion += byte_abs [diff [k]];
  118.     }
  119.     break;
  120.   case ERROR_SSE:
  121.     byte_sse = img->quad;
  122.     for (k = 0; k < 64; k++)
  123.     {
  124.       distortion += byte_sse [diff [k]];
  125.     }
  126.     break;
  127.   case ERROR_SATD :
  128.   default:
  129.     distortion = HadamardSAD8x8( diff );
  130.     break;
  131.   }
  133.   return distortion;
  134. }
  136. /*!
  137.  ***********************************************************************
  138.  * brief
  139.  *    Calculate SA(T)D for 8x8
  140.  ***********************************************************************
  141.  */
  142. int HadamardMB (int c_diff[MB_PIXELS], int blocktype)
  143. {
  144.   int sad=0;
  146.   switch(blocktype)
  147.   {
  148.     //16x16
  149.   case 1:
  150.     sad  = HadamardSAD8x8( c_diff     );
  151.     sad += HadamardSAD8x8(&c_diff[ 64]);
  152.     sad += HadamardSAD8x8(&c_diff[128]);
  153.     sad += HadamardSAD8x8(&c_diff[192]);
  154.     break;
  155.     //16x8 8x16
  156.   case 2:
  157.   case 3:
  158.     sad  = HadamardSAD8x8( c_diff    );
  159.     sad += HadamardSAD8x8(&c_diff[64]);
  160.     break;
  161.     //8x8
  162.   case 4:
  163.     sad  = HadamardSAD8x8(c_diff);
  164.     break;
  165.     //8x4 4x8
  166.   default:
  167.     sad=-1;
  168.     break;
  169.   }
  171.   return sad;
  172. }
  174. /*!
  175. ***********************************************************************
  176. * brief
  177. *    Calculate 4x4 Hadamard-Transformed SAD
  178. ***********************************************************************
  179. */
  180. int HadamardSAD4x4 (int* diff)
  181. {
  182.   int k, satd = 0;
  184.   /*===== hadamard transform =====*/
  185.   m[ 0] = diff[ 0] + diff[12];
  186.   m[ 1] = diff[ 1] + diff[13];
  187.   m[ 2] = diff[ 2] + diff[14];
  188.   m[ 3] = diff[ 3] + diff[15];
  189.   m[ 4] = diff[ 4] + diff[ 8];
  190.   m[ 5] = diff[ 5] + diff[ 9];
  191.   m[ 6] = diff[ 6] + diff[10];
  192.   m[ 7] = diff[ 7] + diff[11];
  193.   m[ 8] = diff[ 4] - diff[ 8];
  194.   m[ 9] = diff[ 5] - diff[ 9];
  195.   m[10] = diff[ 6] - diff[10];
  196.   m[11] = diff[ 7] - diff[11];
  197.   m[12] = diff[ 0] - diff[12];
  198.   m[13] = diff[ 1] - diff[13];
  199.   m[14] = diff[ 2] - diff[14];
  200.   m[15] = diff[ 3] - diff[15];
  202.   d[ 0] = m[ 0] + m[ 4];
  203.   d[ 1] = m[ 1] + m[ 5];
  204.   d[ 2] = m[ 2] + m[ 6];
  205.   d[ 3] = m[ 3] + m[ 7];
  206.   d[ 4] = m[ 8] + m[12];
  207.   d[ 5] = m[ 9] + m[13];
  208.   d[ 6] = m[10] + m[14];
  209.   d[ 7] = m[11] + m[15];
  210.   d[ 8] = m[ 0] - m[ 4];
  211.   d[ 9] = m[ 1] - m[ 5];
  212.   d[10] = m[ 2] - m[ 6];
  213.   d[11] = m[ 3] - m[ 7];
  214.   d[12] = m[12] - m[ 8];
  215.   d[13] = m[13] - m[ 9];
  216.   d[14] = m[14] - m[10];
  217.   d[15] = m[15] - m[11];
  219.   m[ 0] = d[ 0] + d[ 3];
  220.   m[ 1] = d[ 1] + d[ 2];
  221.   m[ 2] = d[ 1] - d[ 2];
  222.   m[ 3] = d[ 0] - d[ 3];
  223.   m[ 4] = d[ 4] + d[ 7];
  224.   m[ 5] = d[ 5] + d[ 6];
  225.   m[ 6] = d[ 5] - d[ 6];
  226.   m[ 7] = d[ 4] - d[ 7];
  227.   m[ 8] = d[ 8] + d[11];
  228.   m[ 9] = d[ 9] + d[10];
  229.   m[10] = d[ 9] - d[10];
  230.   m[11] = d[ 8] - d[11];
  231.   m[12] = d[12] + d[15];
  232.   m[13] = d[13] + d[14];
  233.   m[14] = d[13] - d[14];
  234.   m[15] = d[12] - d[15];
  236.   d[ 0] = m[ 0] + m[ 1];
  237.   d[ 1] = m[ 0] - m[ 1];
  238.   d[ 2] = m[ 2] + m[ 3];
  239.   d[ 3] = m[ 3] - m[ 2];
  240.   d[ 4] = m[ 4] + m[ 5];
  241.   d[ 5] = m[ 4] - m[ 5];
  242.   d[ 6] = m[ 6] + m[ 7];
  243.   d[ 7] = m[ 7] - m[ 6];
  244.   d[ 8] = m[ 8] + m[ 9];
  245.   d[ 9] = m[ 8] - m[ 9];
  246.   d[10] = m[10] + m[11];
  247.   d[11] = m[11] - m[10];
  248.   d[12] = m[12] + m[13];
  249.   d[13] = m[12] - m[13];
  250.   d[14] = m[14] + m[15];
  251.   d[15] = m[15] - m[14];
  253.   //===== sum up =====
  254.   // Table lookup is faster than abs macro
  255.   for (k=0; k<16; ++k)
  256.   {
  257.     satd += byte_abs [d [k]];
  258.   }
  261.   return ((satd+1)>>1);
  262. }
  264. /*!
  265. ***********************************************************************
  266. * brief
  267. *    Calculate 8x8 Hadamard-Transformed SAD
  268. ***********************************************************************
  269. */
  270. int HadamardSAD8x8 (int* diff)
  271. {
  272.   int i, j, jj, sad=0;
  274.   //horizontal
  275.   for (j=0; j < 8; j++)
  276.   {
  277.     jj = j << 3;
  278.     m2[j][0] = diff[jj  ] + diff[jj+4];
  279.     m2[j][1] = diff[jj+1] + diff[jj+5];
  280.     m2[j][2] = diff[jj+2] + diff[jj+6];
  281.     m2[j][3] = diff[jj+3] + diff[jj+7];
  282.     m2[j][4] = diff[jj  ] - diff[jj+4];
  283.     m2[j][5] = diff[jj+1] - diff[jj+5];
  284.     m2[j][6] = diff[jj+2] - diff[jj+6];
  285.     m2[j][7] = diff[jj+3] - diff[jj+7];
  287.     m1[j][0] = m2[j][0] + m2[j][2];
  288.     m1[j][1] = m2[j][1] + m2[j][3];
  289.     m1[j][2] = m2[j][0] - m2[j][2];
  290.     m1[j][3] = m2[j][1] - m2[j][3];
  291.     m1[j][4] = m2[j][4] + m2[j][6];
  292.     m1[j][5] = m2[j][5] + m2[j][7];
  293.     m1[j][6] = m2[j][4] - m2[j][6];
  294.     m1[j][7] = m2[j][5] - m2[j][7];
  296.     m2[j][0] = m1[j][0] + m1[j][1];
  297.     m2[j][1] = m1[j][0] - m1[j][1];
  298.     m2[j][2] = m1[j][2] + m1[j][3];
  299.     m2[j][3] = m1[j][2] - m1[j][3];
  300.     m2[j][4] = m1[j][4] + m1[j][5];
  301.     m2[j][5] = m1[j][4] - m1[j][5];
  302.     m2[j][6] = m1[j][6] + m1[j][7];
  303.     m2[j][7] = m1[j][6] - m1[j][7];
  304.   }
  306.   //vertical
  307.   for (i=0; i < 8; i++)
  308.   {
  309.     m3[0][i] = m2[0][i] + m2[4][i];
  310.     m3[1][i] = m2[1][i] + m2[5][i];
  311.     m3[2][i] = m2[2][i] + m2[6][i];
  312.     m3[3][i] = m2[3][i] + m2[7][i];
  313.     m3[4][i] = m2[0][i] - m2[4][i];
  314.     m3[5][i] = m2[1][i] - m2[5][i];
  315.     m3[6][i] = m2[2][i] - m2[6][i];
  316.     m3[7][i] = m2[3][i] - m2[7][i];
  318.     m1[0][i] = m3[0][i] + m3[2][i];
  319.     m1[1][i] = m3[1][i] + m3[3][i];
  320.     m1[2][i] = m3[0][i] - m3[2][i];
  321.     m1[3][i] = m3[1][i] - m3[3][i];
  322.     m1[4][i] = m3[4][i] + m3[6][i];
  323.     m1[5][i] = m3[5][i] + m3[7][i];
  324.     m1[6][i] = m3[4][i] - m3[6][i];
  325.     m1[7][i] = m3[5][i] - m3[7][i];
  327.     m2[0][i] = m1[0][i] + m1[1][i];
  328.     m2[1][i] = m1[0][i] - m1[1][i];
  329.     m2[2][i] = m1[2][i] + m1[3][i];
  330.     m2[3][i] = m1[2][i] - m1[3][i];
  331.     m2[4][i] = m1[4][i] + m1[5][i];
  332.     m2[5][i] = m1[4][i] - m1[5][i];
  333.     m2[6][i] = m1[6][i] + m1[7][i];
  334.     m2[7][i] = m1[6][i] - m1[7][i];
  335.   }
  336.   for (j=0; j < 8; j++)
  337.     for (i=0; i < 8; i++) 
  338.       sad += iabs (m2[j][i]);
  340.   return ((sad+2)>>2);
  341. }
  343. /*!
  344. ************************************************************************
  345. * brief
  346. *    SAD computation
  347. ************************************************************************
  348. */
  349. int computeSAD(imgpel* src_pic,
  350.                int blocksize_y,
  351.                int blocksize_x,
  352.                int min_mcost,
  353.                int cand_x,
  354.                int cand_y)
  355. {
  356.   int mcost = 0;
  357.   int y,x;
  358.   int pad_size_x = img_padded_size_x - blocksize_x;
  360.   src_line = src_pic;
  361.   ref_line = get_line[ref_access_method] (ref_pic_sub.luma, cand_y, cand_x);
  362.   for (y=0; y<blocksize_y; y++)
  363.   {
  364.     for (x = 0; x < blocksize_x; x+=4)
  365.     {
  366.       mcost += byte_abs[ *src_line++ - *ref_line++ ];
  367.       mcost += byte_abs[ *src_line++ - *ref_line++ ];
  368.       mcost += byte_abs[ *src_line++ - *ref_line++ ];
  369.       mcost += byte_abs[ *src_line++ - *ref_line++ ];
  370.     }
  371.     if (mcost >= min_mcost) return mcost;
  372.     ref_line += pad_size_x;
  373.   }
  374.   if ( ChromaMEEnable ) 
  375.   {
  376.     // calculate chroma conribution to motion compensation error
  377.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  378.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  379.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  380.     int k;
  381.     int mcr_cost = 0; // chroma me cost
  383.     for (k=0; k < 2; k++)
  384.     {
  385.       src_line = src_pic + (256 << k);
  386.       ref_line = get_crline[ref_access_method] ( ref_pic_sub.crcb[k], cand_y, cand_x);
  387.       mcr_cost = 0;
  389.       for (y=0; y<blocksize_y_cr; y++)
  390.       {
  391.         for (x = 0; x < blocksize_x_cr; x += 2)
  392.         {
  393.           mcr_cost += byte_abs[ *src_line++ - *ref_line++ ];
  394.           mcr_cost += byte_abs[ *src_line++ - *ref_line++ ];
  395.         }
  396.         ref_line += cr_pad_size_x;
  397.       }
  398.       mcost += params->ChromaMEWeight * mcr_cost;
  399.       if (mcost >= min_mcost) return mcost;
  400.     }
  401.   }
  403.   return mcost;
  404. }
  406. /*!
  407. ************************************************************************
  408. * brief
  409. *    SAD computation for weighted samples
  410. ************************************************************************
  411. */
  412. int computeSADWP(imgpel* src_pic,
  413.                int blocksize_y,
  414.                int blocksize_x,
  415.                int min_mcost,
  416.                int cand_x,
  417.                int cand_y)
  418. {
  419.   int mcost = 0;
  420.   int y, x;
  421.   int weighted_pel;
  422.   int pad_size_x = img_padded_size_x - blocksize_x;
  424.   src_line = src_pic;
  425.   ref_line = get_line[ref_access_method] (ref_pic_sub.luma, cand_y, cand_x);
  426.   for (y=0; y<blocksize_y; y++)
  427.   {
  428.     for (x = 0; x < blocksize_x; x+=4)
  429.     {
  430.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  431.       mcost += byte_abs[ *src_line++ -  weighted_pel ];
  432.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  433.       mcost += byte_abs[ *src_line++ -  weighted_pel ];
  434.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  435.       mcost += byte_abs[ *src_line++ -  weighted_pel ];
  436.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  437.       mcost += byte_abs[ *src_line++ -  weighted_pel ];
  438.     }
  439.     if (mcost >= min_mcost) return mcost;
  440.     ref_line += pad_size_x;
  441.   }
  442.   if ( ChromaMEEnable ) 
  443.   {
  444.     // calculate chroma conribution to motion compensation error
  445.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  446.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  447.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  448.     int k;
  449.     int mcr_cost = 0;
  450.     int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  452.     for (k=0; k < 2; k++)
  453.     {
  454.       mcr_cost = 0;
  455.       src_line = src_pic + (256 << k);
  456.       ref_line = get_crline[ref_access_method] ( ref_pic_sub.crcb[k], cand_y, cand_x);
  457.       for (y=0; y<blocksize_y_cr; y++)
  458.       {
  459.         for (x = 0; x < blocksize_x_cr; x+=2)
  460.         {
  461.           weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *ref_line++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  462.           mcr_cost += byte_abs[ *src_line++ -  weighted_pel ];
  463.           weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *ref_line++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  464.           mcr_cost += byte_abs[ *src_line++ -  weighted_pel ];
  465.         }
  466.         ref_line += cr_pad_size_x;
  467.       }
  468.       mcost += params->ChromaMEWeight * mcr_cost;
  469.       if (mcost >= min_mcost) return mcost;
  470.     }
  471.   }
  473.   return mcost;
  474. }
  476. /*!
  477. ************************************************************************
  478. * brief
  479. *    BiPred SAD computation (no weights)
  480. ************************************************************************
  481. */
  482. int computeBiPredSAD1(imgpel* src_pic,
  483.                       int blocksize_y,
  484.                       int blocksize_x,
  485.                       int min_mcost,
  486.                       int cand_x1, int cand_y1,
  487.                       int cand_x2, int cand_y2)
  488. {
  489.   int mcost = 0;
  490.   int bi_diff;
  491.   int y,x;
  492.   int pad_size_x = img_padded_size_x - blocksize_x;
  494.   src_line   = src_pic;
  495.   ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, cand_y2, cand_x2);
  496.   ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, cand_y1, cand_x1);
  498.   for (y = 0; y < blocksize_y; y++)
  499.   {
  500.     for (x = 0; x < blocksize_x; x+=4)
  501.     {
  502.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  503.       mcost += byte_abs[bi_diff];
  504.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  505.       mcost += byte_abs[bi_diff];
  506.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  507.       mcost += byte_abs[bi_diff];
  508.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  509.       mcost += byte_abs[bi_diff];
  510.     }
  511.     if (mcost >= min_mcost) return mcost;
  512.     ref2_line += pad_size_x;
  513.     ref1_line += pad_size_x;
  514.   }
  516.   if ( ChromaMEEnable ) 
  517.   {
  518.     // calculate chroma conribution to motion compensation error
  519.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  520.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  521.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  522.     int k;
  523.     int mcr_cost = 0;
  525.     for (k=0; k<2; k++)
  526.     {
  527.       mcr_cost = 0;
  528.       src_line = src_pic + (256 << k);
  529.       ref2_line = get_crline[bipred2_access_method] ( ref_pic2_sub.crcb[k], cand_y2, cand_x2);
  530.       ref1_line = get_crline[bipred1_access_method] ( ref_pic1_sub.crcb[k], cand_y1, cand_x1);      
  532.       for (y=0; y<blocksize_y_cr; y++)
  533.       {
  534.         for (x = 0; x < blocksize_x_cr; x+=2)
  535.         {
  536.           bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  537.           mcr_cost += byte_abs[bi_diff];
  538.           bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  539.           mcr_cost += byte_abs[bi_diff];
  540.         }        
  541.         ref2_line += cr_pad_size_x;
  542.         ref1_line += cr_pad_size_x;
  543.       }
  544.       mcost += params->ChromaMEWeight * mcr_cost;
  545.       if (mcost >= min_mcost) return mcost;
  546.     }
  547.   }
  548.   return mcost;
  549. }
  551. /*!
  552. ************************************************************************
  553. * brief
  554. *    BiPred SAD computation (with weights)
  555. ************************************************************************
  556. */
  557. int computeBiPredSAD2(imgpel* src_pic,
  558.                       int blocksize_y,
  559.                       int blocksize_x,
  560.                       int min_mcost,
  561.                       int cand_x1, int cand_y1,
  562.                       int cand_x2, int cand_y2)
  563. {
  564.   int mcost = 0;
  565.   int bi_diff;
  566.   int denom = luma_log_weight_denom + 1;
  567.   int lround = 2 * wp_luma_round;
  568.   int y,x;
  569.   int weighted_pel, pixel1, pixel2;
  570.   int pad_size_x = img_padded_size_x - blocksize_x;
  572.   src_line   = src_pic;
  573.   ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, cand_y2, cand_x2);
  574.   ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, cand_y1, cand_x1);
  576.   for (y=0; y<blocksize_y; y++)
  577.   {
  578.     for (x = 0; x < blocksize_x; x+=4)
  579.     {
  580.       pixel1 = weight1 * (*ref1_line++);
  581.       pixel2 = weight2 * (*ref2_line++);
  582.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  583.       bi_diff = (*src_line++) - weighted_pel;
  584.       mcost += byte_abs[bi_diff];
  586.       pixel1 = weight1 * (*ref1_line++);
  587.       pixel2 = weight2 * (*ref2_line++);
  588.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  589.       bi_diff = (*src_line++) - weighted_pel;
  590.       mcost += byte_abs[bi_diff];
  592.       pixel1 = weight1 * (*ref1_line++);
  593.       pixel2 = weight2 * (*ref2_line++);
  594.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  595.       bi_diff = (*src_line++) - weighted_pel;
  596.       mcost += byte_abs[bi_diff];
  598.       pixel1 = weight1 * (*ref1_line++);
  599.       pixel2 = weight2 * (*ref2_line++);
  600.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  601.       bi_diff = (*src_line++) - weighted_pel;
  602.       mcost += byte_abs[bi_diff];
  603.     }
  604.     if (mcost >= min_mcost) return mcost;
  605.     ref2_line += pad_size_x;
  606.     ref1_line += pad_size_x;
  607.   }
  609.   if ( ChromaMEEnable ) 
  610.   {
  611.     // calculate chroma conribution to motion compensation error
  612.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  613.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  614.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  615.     int k;
  616.     int mcr_cost = 0;
  617.     int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  619.     for (k=0; k<2; k++)
  620.     {
  621.       mcr_cost = 0;
  622.       src_line = src_pic + (256 << k);
  623.       ref2_line = get_crline[bipred2_access_method] ( ref_pic2_sub.crcb[k], cand_y2, cand_x2);
  624.       ref1_line = get_crline[bipred1_access_method] ( ref_pic1_sub.crcb[k], cand_y1, cand_x1);
  626.       for (y=0; y<blocksize_y_cr; y++)
  627.       {
  628.         for (x = 0; x < blocksize_x_cr; x+=2)
  629.         {
  630.           pixel1 = weight1_cr[k] * (*ref1_line++);
  631.           pixel2 = weight2_cr[k] * (*ref2_line++);
  632.           weighted_pel =  iClip1( max_imgpel_value_uv, ((pixel1 + pixel2 + lround) >> denom) + offsetBi_cr[k]);
  633.           bi_diff = (*src_line++) - weighted_pel;
  634.           mcr_cost += byte_abs[bi_diff];
  636.           pixel1 = weight1_cr[k] * (*ref1_line++);
  637.           pixel2 = weight2_cr[k] * (*ref2_line++);
  638.           weighted_pel =  iClip1( max_imgpel_value_uv, ((pixel1 + pixel2 + lround) >> denom) + offsetBi_cr[k]);
  639.           bi_diff = (*src_line++) - weighted_pel;
  640.           mcr_cost += byte_abs[bi_diff];
  641.         }
  642.         ref2_line += cr_pad_size_x;
  643.         ref1_line += cr_pad_size_x;
  644.       }
  645.       mcost += params->ChromaMEWeight * mcr_cost;
  646.       if (mcost >= min_mcost) return mcost;
  647.       
  648.     }
  649.   }
  650.   return mcost;
  651. }
  653. /*!
  654.  ************************************************************************
  655.  * brief
  656.  *    SAD computation _with_ Hadamard Transform
  657.  ************************************************************************
  658. */
  659. int computeSATD(imgpel* src_pic,
  660.                 int blocksize_y,
  661.                 int blocksize_x,
  662.                 int min_mcost,
  663.                 int cand_x,
  664.                 int cand_y)
  665. {
  666.   int mcost = 0;
  667.   int y, x, y4, *d;
  668.   int src_size_x, src_size_mul;
  669.   imgpel *src_tmp = src_pic;
  671.   if ( !test8x8transform )
  672.   { // 4x4 TRANSFORM
  673.     src_size_x = blocksize_x - BLOCK_SIZE;
  674.     src_size_mul = blocksize_x * BLOCK_SIZE;
  675.     for (y = cand_y; y < cand_y + (blocksize_y<<2); y += (BLOCK_SIZE_SP))
  676.     {
  677.       for (x=0; x<blocksize_x; x += BLOCK_SIZE)
  678.       {
  679.         d    = diff;
  680.         ref_line = get_line[ref_access_method] (ref_pic_sub.luma, y, cand_x + (x<<2));
  681.         src_line = src_tmp + x;
  682.         for (y4 = 0; y4 < BLOCK_SIZE; y4++ )
  683.         {
  684.           *d++ = *src_line++ - *ref_line++ ;
  685.           *d++ = *src_line++ - *ref_line++ ;
  686.           *d++ = *src_line++ - *ref_line++ ;
  687.           *d++ = *src_line++ - *ref_line++ ;
  689.           ref_line += img_padded_size_x_m4x4;
  690.           src_line += src_size_x;
  691.         }
  692.         if ((mcost += HadamardSAD4x4 (diff)) > min_mcost) return mcost;
  693.       }
  694.       src_tmp += src_size_mul;
  695.     }
  696.   }
  697.   else
  698.   { // 8x8 TRANSFORM
  699.     src_size_x = (blocksize_x - BLOCK_SIZE_8x8);
  700.     src_size_mul = blocksize_x * BLOCK_SIZE_8x8;
  701.     for (y = cand_y; y < cand_y + (blocksize_y<<2); y += (BLOCK_SIZE_8x8_SP) )
  702.     {
  703.       for (x=0; x<blocksize_x; x += BLOCK_SIZE_8x8 )
  704.       {
  705.         d = diff;
  706.         ref_line  = get_line[ref_access_method] (ref_pic_sub.luma, y, cand_x + (x<<2));
  707.         src_line = src_tmp + x;
  708.         for (y4 = 0; y4 < BLOCK_SIZE_8x8; y4++ )
  709.         {
  710.           *d++ = *src_line++ - *ref_line++ ;
  711.           *d++ = *src_line++ - *ref_line++ ;
  712.           *d++ = *src_line++ - *ref_line++ ;
  713.           *d++ = *src_line++ - *ref_line++ ;
  714.           *d++ = *src_line++ - *ref_line++ ;
  715.           *d++ = *src_line++ - *ref_line++ ;
  716.           *d++ = *src_line++ - *ref_line++ ;
  717.           *d++ = *src_line++ - *ref_line++ ;
  719.           ref_line += img_padded_size_x_m8x8;
  720.           src_line += src_size_x;
  721.         }
  722.         if ((mcost += HadamardSAD8x8 (diff)) > min_mcost) return mcost;
  723.       }
  724.       src_tmp += src_size_mul;
  725.     }
  726.   }
  727.   return mcost;
  728. }
  730. /*!
  731.  ************************************************************************
  732.  * brief
  733.  *    SAD computation of weighted samples _with_ Hadamard Transform
  734.  ************************************************************************
  735. */
  736. int computeSATDWP(imgpel* src_pic,
  737.                 int blocksize_y,
  738.                 int blocksize_x,
  739.                 int min_mcost,
  740.                 int cand_x,
  741.                 int cand_y)
  742. {
  743.   int mcost = 0;
  744.   int y, x, y4, *d;
  745.   int weighted_pel;
  746.   int src_size_x, src_size_mul;
  747.   imgpel *src_tmp = src_pic;
  749.   if ( !test8x8transform )
  750.   { // 4x4 TRANSFORM
  751.     src_size_x = (blocksize_x - BLOCK_SIZE);
  752.     src_size_mul = blocksize_x * BLOCK_SIZE;
  753.     for (y = cand_y; y < cand_y + (blocksize_y<<2); y += (BLOCK_SIZE_SP))
  754.     {
  755.       for (x=0; x<blocksize_x; x += BLOCK_SIZE)
  756.       {
  757.         d    = diff;
  758.         ref_line = get_line[ref_access_method] (ref_pic_sub.luma, y, cand_x + (x<<2));
  759.         src_line = src_tmp + x;
  760.         for (y4 = 0; y4 < BLOCK_SIZE; y4++ )
  761.         {
  762.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  763.           *d++ = *src_line++ - weighted_pel;
  764.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  765.           *d++ = *src_line++ - weighted_pel;
  766.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  767.           *d++ = *src_line++ - weighted_pel;
  768.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  769.           *d++ = *src_line++ - weighted_pel;
  771.           ref_line += img_padded_size_x_m4x4;
  772.           src_line += src_size_x;
  773.         }
  774.         if ((mcost += HadamardSAD4x4 (diff)) > min_mcost) return mcost;
  775.       }
  776.       src_tmp += src_size_mul;
  777.     }
  778.   }
  779.   else
  780.   { // 8x8 TRANSFORM
  781.     src_size_x = (blocksize_x - BLOCK_SIZE_8x8);
  782.     src_size_mul = blocksize_x * BLOCK_SIZE_8x8;
  783.     for (y = cand_y; y < cand_y + (blocksize_y<<2); y += (BLOCK_SIZE_8x8_SP) )
  784.     {
  785.       for (x=0; x<blocksize_x; x += BLOCK_SIZE_8x8 )
  786.       {
  787.         d = diff;
  788.         ref_line  = get_line[ref_access_method] (ref_pic_sub.luma, y, cand_x + (x<<2));
  789.         src_line = src_tmp + x;
  790.         for (y4 = 0; y4 < BLOCK_SIZE_8x8; y4++ )
  791.         {
  792.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  793.           *d++ = *src_line++ - weighted_pel;
  794.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  795.           *d++ = *src_line++ - weighted_pel;
  796.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  797.           *d++ = *src_line++ - weighted_pel;
  798.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  799.           *d++ = *src_line++ - weighted_pel;
  800.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  801.           *d++ = *src_line++ - weighted_pel;
  802.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  803.           *d++ = *src_line++ - weighted_pel;
  804.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  805.           *d++ = *src_line++ - weighted_pel;
  806.           weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  807.           *d++ = *src_line++ - weighted_pel;
  809.           ref_line += img_padded_size_x_m8x8;
  810.           src_line += src_size_x;
  811.         }
  812.         if ((mcost += HadamardSAD8x8 (diff)) > min_mcost) return mcost;
  813.       }
  814.       src_tmp += src_size_mul;
  815.     }
  816.   }
  817.   return mcost;
  818. }
  820. /*!
  821.  ************************************************************************
  822.  * brief
  823.  *    BiPred (w/o weights) SATD computation
  824.  ************************************************************************
  825. */
  826. int computeBiPredSATD1(imgpel* src_pic,
  827.                        int blocksize_y,
  828.                        int blocksize_x,
  829.                        int min_mcost,
  830.                        int cand_x1, int cand_y1,
  831.                        int cand_x2, int cand_y2)
  832. {
  833.   int mcost = 0;
  834.   int y, x, y4, *d;
  835.   int src_size_x, src_size_mul;
  836.   imgpel *src_tmp = src_pic;
  838.   if ( !test8x8transform )
  839.   { // 4x4 TRANSFORM
  840.     src_size_x = (blocksize_x - BLOCK_SIZE);
  841.     src_size_mul = blocksize_x * BLOCK_SIZE;
  842.     for (y=0; y<(blocksize_y<<2); y += (BLOCK_SIZE_SP))
  843.     {
  844.       for (x=0; x<blocksize_x; x += BLOCK_SIZE)
  845.       {
  846.         d    = diff;
  847.         src_line   = src_tmp + x;
  848.         ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, cand_y2 + y, cand_x2 + (x<<2));
  849.         ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, cand_y1 + y, cand_x1 + (x<<2));
  850.         for (y4 = 0; y4 < BLOCK_SIZE; y4++ )
  851.         {
  852.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  853.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  854.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  855.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  857.           ref1_line += img_padded_size_x_m4x4;
  858.           ref2_line += img_padded_size_x_m4x4;
  859.           src_line  += src_size_x;
  860.         }
  861.         if ((mcost += HadamardSAD4x4 (diff)) > min_mcost) return mcost;
  862.       }
  863.       src_tmp += src_size_mul;
  864.     }
  865.   }
  866.   else
  867.   { // 8x8 TRANSFORM
  868.     src_size_x = (blocksize_x - BLOCK_SIZE_8x8);
  869.     src_size_mul = blocksize_x * BLOCK_SIZE_8x8;
  870.     for (y=0; y<blocksize_y; y += BLOCK_SIZE_8x8 )
  871.     {
  872.       int y_pos2 = cand_y2 + (y<<2);
  873.       int y_pos1 = cand_y1 + (y<<2);
  874.       for (x=0; x<blocksize_x; x += BLOCK_SIZE_8x8 )
  875.       {
  876.         d = diff;
  877.         src_line   = src_tmp + x;
  878.         ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, y_pos2, cand_x2 + (x<<2));
  879.         ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, y_pos1, cand_x1 + (x<<2));
  880.         for (y4 = 0; y4 < BLOCK_SIZE_8x8; y4++ )
  881.         {
  882.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  883.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  884.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  885.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  886.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  887.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  888.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  889.           *d++ = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  891.           ref1_line += img_padded_size_x_m8x8;
  892.           ref2_line += img_padded_size_x_m8x8;
  893.           src_line += src_size_x;
  894.         }
  895.         if ((mcost += HadamardSAD8x8 (diff)) > min_mcost) return mcost;
  896.       }
  897.       src_tmp += src_size_mul;
  898.     }
  899.   }
  900.   return mcost;
  901. }
  903. /*!
  904. ************************************************************************
  905. * brief
  906. *    BiPred (w/ weights) SATD computation
  907. ************************************************************************
  908. */
  909. int computeBiPredSATD2(imgpel* src_pic,
  910.                        int blocksize_y,
  911.                        int blocksize_x,
  912.                        int min_mcost,
  913.                        int cand_x1, int cand_y1,
  914.                        int cand_x2, int cand_y2)
  915. {
  916.   int mcost = 0;
  917.   int y, x, y4, *d;
  918.   int weighted_pel, pixel1, pixel2;
  919.   int denom = luma_log_weight_denom + 1;
  920.   int lround = 2 * wp_luma_round;
  921.   int src_size_x, src_size_mul;
  922.   imgpel *src_tmp = src_pic;
  924.   if ( !test8x8transform )
  925.   { // 4x4 TRANSFORM
  926.     src_size_x = (blocksize_x - BLOCK_SIZE);
  927.     src_size_mul = blocksize_x * BLOCK_SIZE;
  928.     for (y=0; y<(blocksize_y<<2); y += BLOCK_SIZE_SP)
  929.     {
  930.       for (x=0; x<blocksize_x; x += BLOCK_SIZE)
  931.       {
  932.         d    = diff;
  933.         src_line   = src_tmp + x;
  934.         ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, cand_y2 + y, cand_x2 + (x<<2));
  935.         ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, cand_y1 + y, cand_x1 + (x<<2));
  936.         for (y4 = 0; y4 < BLOCK_SIZE; y4++ )
  937.         {
  938.           // 0
  939.           pixel1 = weight1 * (*ref1_line++);
  940.           pixel2 = weight2 * (*ref2_line++);
  941.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  942.           *d++ =  (*src_line++) - weighted_pel;
  943.           // 1
  944.           pixel1 = weight1 * (*ref1_line++);
  945.           pixel2 = weight2 * (*ref2_line++);
  946.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  947.           *d++ =  (*src_line++) - weighted_pel;
  948.           // 2
  949.           pixel1 = weight1 * (*ref1_line++);
  950.           pixel2 = weight2 * (*ref2_line++);
  951.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  952.           *d++ =  (*src_line++) - weighted_pel;
  953.           // 3
  954.           pixel1 = weight1 * (*ref1_line++);
  955.           pixel2 = weight2 * (*ref2_line++);
  956.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  957.           *d++ =  (*src_line++) - weighted_pel;
  959.           ref1_line += img_padded_size_x_m4x4;
  960.           ref2_line += img_padded_size_x_m4x4;
  961.           src_line  += src_size_x;
  962.         }
  963.         if ((mcost += HadamardSAD4x4 (diff)) > min_mcost) return mcost;
  964.       }
  965.       src_tmp += src_size_mul;
  966.     }
  967.   }
  968.   else
  969.   { // 8x8 TRANSFORM
  970.     src_size_x = (blocksize_x - BLOCK_SIZE_8x8);
  971.     src_size_mul = blocksize_x * BLOCK_SIZE_8x8;
  972.     for (y=0; y<blocksize_y; y += BLOCK_SIZE_8x8 )
  973.     {
  974.       int y_pos2 = cand_y2 + (y<<2);
  975.       int y_pos1 = cand_y1 + (y<<2);
  976.       for (x=0; x<blocksize_x; x += BLOCK_SIZE_8x8 )
  977.       {
  978.         d = diff;
  979.         src_line   = src_tmp + x;
  980.         ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, y_pos2, cand_x2 + (x<<2));
  981.         ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, y_pos1, cand_x1 + (x<<2));
  982.         for (y4 = 0; y4 < BLOCK_SIZE_8x8; y4++ )
  983.         {
  984.           // 0
  985.           pixel1 = weight1 * (*ref1_line++);
  986.           pixel2 = weight2 * (*ref2_line++);
  987.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  988.           *d++ =  (*src_line++) - weighted_pel;
  989.           // 1
  990.           pixel1 = weight1 * (*ref1_line++);
  991.           pixel2 = weight2 * (*ref2_line++);
  992.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  993.           *d++ =  (*src_line++) - weighted_pel;
  994.           // 2
  995.           pixel1 = weight1 * (*ref1_line++);
  996.           pixel2 = weight2 * (*ref2_line++);
  997.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  998.           *d++ =  (*src_line++) - weighted_pel;
  999.           // 3
  1000.           pixel1 = weight1 * (*ref1_line++);
  1001.           pixel2 = weight2 * (*ref2_line++);
  1002.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1003.           *d++ =  (*src_line++) - weighted_pel;
  1004.           // 4
  1005.           pixel1 = weight1 * (*ref1_line++);
  1006.           pixel2 = weight2 * (*ref2_line++);
  1007.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1008.           *d++ =  (*src_line++) - weighted_pel;
  1009.           // 5
  1010.           pixel1 = weight1 * (*ref1_line++);
  1011.           pixel2 = weight2 * (*ref2_line++);
  1012.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1013.           *d++ =  (*src_line++) - weighted_pel;
  1014.           // 6
  1015.           pixel1 = weight1 * (*ref1_line++);
  1016.           pixel2 = weight2 * (*ref2_line++);
  1017.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1018.           *d++ =  (*src_line++) - weighted_pel;
  1019.           // 7
  1020.           pixel1 = weight1 * (*ref1_line++);
  1021.           pixel2 = weight2 * (*ref2_line++);
  1022.           weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1023.           *d++ =  (*src_line) - weighted_pel;
  1025.           ref1_line += img_padded_size_x_m8x8;
  1026.           ref2_line += img_padded_size_x_m8x8;
  1027.           src_line  += src_size_x;
  1028.         }
  1029.         if ((mcost += HadamardSAD8x8 (diff)) > min_mcost) return mcost;
  1030.       }
  1031.       src_tmp += src_size_mul;
  1032.     }
  1033.   }
  1034.   return mcost;
  1035. }
  1037. /*!
  1038. ************************************************************************
  1039. * brief
  1040. *    SSE computation
  1041. ************************************************************************
  1042. */
  1044. int computeSSE(imgpel* src_pic,
  1045.                int blocksize_y,
  1046.                int blocksize_x,
  1047.                int min_mcost,
  1048.                int cand_x,
  1049.                int cand_y)
  1050. {
  1051.   int mcost = 0;
  1052.   int y,x;
  1053.   int *byte_sse = img->quad;
  1054.   int pad_size_x = img_padded_size_x - blocksize_x;
  1056.   src_line = src_pic;
  1057.   ref_line = get_line[ref_access_method] (ref_pic_sub.luma, cand_y, cand_x);
  1058.   for (y=0; y<blocksize_y; y++)
  1059.   {
  1060.     for (x = 0; x < blocksize_x; x+=4)
  1061.     {
  1062.       mcost += byte_sse[ *src_line++ - *ref_line++ ];
  1063.       mcost += byte_sse[ *src_line++ - *ref_line++ ];
  1064.       mcost += byte_sse[ *src_line++ - *ref_line++ ];
  1065.       mcost += byte_sse[ *src_line++ - *ref_line++ ];
  1066.     }
  1067.     if (mcost >= min_mcost) return mcost;
  1068.     ref_line += pad_size_x;
  1069.   }
  1071.   if ( ChromaMEEnable ) 
  1072.   {
  1073.     // calculate chroma conribution to motion compensation error
  1074.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  1075.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  1076.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  1077.     int k;
  1078.     int mcr_cost = 0;
  1080.     for (k=0; k<2; k++)
  1081.     {
  1082.       mcr_cost = 0;
  1083.       src_line = src_pic + (256 << k);
  1084.       ref_line = get_crline[ref_access_method] ( ref_pic_sub.crcb[k], cand_y, cand_x);
  1085.       for (y=0; y<blocksize_y_cr; y++)
  1086.       {
  1087.         for (x = 0; x < blocksize_x_cr; x+=2)
  1088.         {
  1089.           mcr_cost += byte_sse[ *src_line++ - *ref_line++ ];
  1090.           mcr_cost += byte_sse[ *src_line++ - *ref_line++ ];
  1091.         }
  1092.         ref_line += cr_pad_size_x;
  1093.       }
  1094.       mcost += params->ChromaMEWeight * mcr_cost;
  1095.       if (mcost >= min_mcost) return mcost;
  1096.     }
  1097.   }
  1099.   return mcost;
  1100. }
  1103. /*!
  1104. ************************************************************************
  1105. * brief
  1106. *    SSE computation of weighted samples
  1107. ************************************************************************
  1108. */
  1110. int computeSSEWP(imgpel* src_pic,
  1111.                int blocksize_y,
  1112.                int blocksize_x,
  1113.                int min_mcost,
  1114.                int cand_x,
  1115.                int cand_y)
  1116. {
  1117.   int mcost = 0;
  1118.   int y,x;
  1119.   int weighted_pel;
  1120.   int *byte_sse = img->quad;
  1121.   int pad_size_x = img_padded_size_x - blocksize_x;
  1123.   src_line = src_pic;
  1124.   ref_line = get_line[ref_access_method] (ref_pic_sub.luma, cand_y, cand_x);
  1125.   for (y=0; y<blocksize_y; y++)
  1126.   {
  1127.     for (x = 0; x < blocksize_x; x+=4)
  1128.     {
  1129.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  1130.       mcost += byte_sse[ *src_line++ - weighted_pel ];
  1131.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  1132.       mcost += byte_sse[ *src_line++ - weighted_pel ];
  1133.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  1134.       mcost += byte_sse[ *src_line++ - weighted_pel ];
  1135.       weighted_pel = iClip1( img->max_imgpel_value, ((weight_luma * *ref_line++  + wp_luma_round) >> luma_log_weight_denom) + offset_luma);
  1136.       mcost += byte_sse[ *src_line++ - weighted_pel ];
  1137.     }
  1138.     if (mcost >= min_mcost) return mcost;
  1139.     ref_line += pad_size_x;
  1140.   }
  1142.   if ( ChromaMEEnable ) 
  1143.   {
  1144.     // calculate chroma conribution to motion compensation error
  1145.     // These could be made global to reduce computations
  1146.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  1147.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  1148.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  1149.     int k;
  1150.     int mcr_cost = 0;
  1151.     int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  1153.     for (k=0; k<2; k++)
  1154.     {
  1155.       mcr_cost = 0;
  1156.       src_line = src_pic + (256 << k);
  1157.       ref_line = get_crline[ref_access_method] ( ref_pic_sub.crcb[k], cand_y, cand_x);
  1158.       for (y=0; y<blocksize_y_cr; y++)
  1159.       {
  1161.         for (x = 0; x < blocksize_x_cr; x+=2)
  1162.         {
  1163.           weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *ref_line++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  1164.           mcr_cost += byte_sse[ *src_line++ - weighted_pel ];
  1165.           weighted_pel = iClip1( max_imgpel_value_uv, ((weight_cr[k] * *ref_line++  + wp_chroma_round) >> chroma_log_weight_denom) + offset_cr[k]);
  1166.           mcr_cost += byte_sse[ *src_line++ - weighted_pel ];
  1167.         }        
  1168.         ref_line += cr_pad_size_x;
  1169.       }
  1170.       mcost += params->ChromaMEWeight * mcr_cost;
  1171.       if (mcost >= min_mcost) return mcost;
  1172.     }
  1173.   }
  1175.   return mcost;
  1176. }
  1178. /*!
  1179. ************************************************************************
  1180. * brief
  1181. *    BiPred SSE computation (no weights)
  1182. ************************************************************************
  1183. */
  1184. int computeBiPredSSE1(imgpel* src_pic,
  1185.                       int blocksize_y,
  1186.                       int blocksize_x,
  1187.                       int min_mcost,
  1188.                       int cand_x1, int cand_y1,
  1189.                       int cand_x2, int cand_y2)
  1190. {
  1191.   int mcost = 0;
  1192.   int bi_diff;
  1193.   int y,x;
  1194.   int *byte_sse = img->quad;
  1195.   int pad_size_x = img_padded_size_x - blocksize_x;
  1197.   src_line   = src_pic;
  1198.   ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, cand_y2, cand_x2);
  1199.   ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, cand_y1, cand_x1);
  1201.   for (y = 0; y < blocksize_y; y++)
  1202.   {
  1203.     for (x = 0; x < blocksize_x; x+=4)
  1204.     {
  1205.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  1206.       mcost += byte_sse[bi_diff];
  1207.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  1208.       mcost += byte_sse[bi_diff];
  1209.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  1210.       mcost += byte_sse[bi_diff];
  1211.       bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  1212.       mcost += byte_sse[bi_diff];
  1213.     }
  1215.     if (mcost >= min_mcost) return mcost;
  1216.     ref2_line += pad_size_x;
  1217.     ref1_line += pad_size_x;
  1218.   }
  1220.   if ( ChromaMEEnable ) 
  1221.   {
  1222.     // calculate chroma conribution to motion compensation error
  1223.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  1224.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  1225.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  1226.     int k;
  1227.     int mcr_cost = 0;
  1229.     for (k=0; k<2; k++)
  1230.     {
  1231.       mcr_cost = 0;
  1232.       src_line = src_pic + (256 << k);
  1233.       ref2_line = get_crline[bipred2_access_method] ( ref_pic2_sub.crcb[k], cand_y2, cand_x2);
  1234.       ref1_line = get_crline[bipred1_access_method] ( ref_pic1_sub.crcb[k], cand_y1, cand_x1);
  1236.       for (y=0; y<blocksize_y_cr; y++)
  1237.       {
  1238.         for (x = 0; x < blocksize_x_cr; x+=2)
  1239.         {
  1240.           bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  1241.           mcr_cost += byte_sse[bi_diff];
  1242.           bi_diff = (*src_line++) - ((*ref1_line++ + *ref2_line++ + 1)>>1);
  1243.           mcr_cost += byte_sse[bi_diff];
  1244.         }        
  1245.         ref2_line += cr_pad_size_x;
  1246.         ref1_line += cr_pad_size_x;
  1247.       }
  1248.       mcost += params->ChromaMEWeight * mcr_cost;
  1249.       if (mcost >= min_mcost) return mcost;
  1250.     }
  1251.   }
  1253.   return mcost;
  1254. }
  1257. /*!
  1258. ************************************************************************
  1259. * brief
  1260. *    BiPred SSE computation (with weights)
  1261. ************************************************************************
  1262. */
  1263. int computeBiPredSSE2(imgpel* src_pic,
  1264.                       int blocksize_y,
  1265.                       int blocksize_x,
  1266.                       int min_mcost,
  1267.                       int cand_x1, int cand_y1,
  1268.                       int cand_x2, int cand_y2)
  1269. {
  1270.   int mcost = 0;
  1271.   int bi_diff;
  1272.   int denom = luma_log_weight_denom + 1;
  1273.   int lround = 2 * wp_luma_round;
  1274.   int y,x;
  1275.   int weighted_pel, pixel1, pixel2;
  1276.   int pad_size_x = img_padded_size_x - blocksize_x;
  1278.   src_line   = src_pic;
  1279.   ref2_line  = get_line[bipred2_access_method] (ref_pic2_sub.luma, cand_y2, cand_x2);
  1280.   ref1_line  = get_line[bipred1_access_method] (ref_pic1_sub.luma, cand_y1, cand_x1);
  1281.   for (y=0; y<blocksize_y; y++)
  1282.   {
  1283.     for (x = 0; x < blocksize_x; x+=4)
  1284.     {
  1285.       pixel1 = weight1 * (*ref1_line++);
  1286.       pixel2 = weight2 * (*ref2_line++);
  1287.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1288.       bi_diff = (*src_line++) - weighted_pel;
  1289.       mcost += bi_diff * bi_diff;
  1291.       pixel1 = weight1 * (*ref1_line++);
  1292.       pixel2 = weight2 * (*ref2_line++);
  1293.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1294.       bi_diff = (*src_line++) - weighted_pel;
  1295.       mcost += bi_diff * bi_diff;
  1297.       pixel1 = weight1 * (*ref1_line++);
  1298.       pixel2 = weight2 * (*ref2_line++);
  1299.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1300.       bi_diff = (*src_line++) - weighted_pel;
  1301.       mcost += bi_diff * bi_diff;
  1303.       pixel1 = weight1 * (*ref1_line++);
  1304.       pixel2 = weight2 * (*ref2_line++);
  1305.       weighted_pel =  iClip1( img->max_imgpel_value, ((pixel1 + pixel2 + lround) >> denom) + offsetBi);
  1306.       bi_diff = (*src_line++) - weighted_pel;
  1307.       mcost += bi_diff * bi_diff;
  1308.     }
  1309.     if (mcost >= min_mcost) return mcost;
  1310.     ref2_line += pad_size_x;
  1311.     ref1_line += pad_size_x;
  1312.   }
  1314.   if ( ChromaMEEnable ) 
  1315.   {
  1316.     // calculate chroma conribution to motion compensation error
  1317.     int blocksize_x_cr = blocksize_x >> shift_cr_x;
  1318.     int blocksize_y_cr = blocksize_y >> shift_cr_y;
  1319.     int cr_pad_size_x = img_cr_padded_size_x - blocksize_x_cr;
  1320.     int k;
  1321.     int mcr_cost = 0;
  1322.     int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  1324.     for (k=0; k<2; k++)
  1325.     {
  1326.       mcr_cost = 0;
  1327.       src_line = src_pic + (256 << k);
  1328.       ref2_line = get_crline[bipred2_access_method] ( ref_pic2_sub.crcb[k], cand_y2, cand_x2);
  1329.       ref1_line = get_crline[bipred1_access_method] ( ref_pic1_sub.crcb[k], cand_y1, cand_x1);
  1331.       for (y=0; y<blocksize_y_cr; y++)
  1332.       {
  1333.         for (x = 0; x < blocksize_x_cr; x+=2)
  1334.         {
  1335.           pixel1 = weight1_cr[k] * (*ref1_line++);
  1336.           pixel2 = weight2_cr[k] * (*ref2_line++);
  1337.           weighted_pel =  iClip1( max_imgpel_value_uv, ((pixel1 + pixel2 + lround) >> denom) + offsetBi_cr[k]);
  1338.           bi_diff = (*src_line++) - weighted_pel;
  1339.           mcr_cost += bi_diff * bi_diff;
  1341.           pixel1 = weight1_cr[k] * (*ref1_line++);
  1342.           pixel2 = weight2_cr[k] * (*ref2_line++);
  1343.           weighted_pel =  iClip1( max_imgpel_value_uv, ((pixel1 + pixel2 + lround) >> denom) + offsetBi_cr[k]);
  1344.           bi_diff = (*src_line++) - weighted_pel;
  1345.           mcr_cost += bi_diff * bi_diff;
  1346.         }        
  1347.         ref2_line += cr_pad_size_x;
  1348.         ref1_line += cr_pad_size_x;
  1349.       }
  1350.       mcost += params->ChromaMEWeight * mcr_cost;
  1351.       if (mcost >= min_mcost) return mcost;
  1352.     }
  1353.   }
  1355.   return mcost;
  1356. }