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

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

Audio

开发平台：

Visual C++

errdo_mc_prediction.c：源码内容
  1. /*!
  2.  *************************************************************************************
  3.  * file errdo_mc_prediction.c
  4.  *
  5.  * brief
  6.  *    Functions for motion compensated prediction
  7.  *
  8.  * author
  9.  *      Main contributors (see contributors.h for copyright, 
  10.  *                         address and affiliation details)
  11.  *      - Alexis Michael Tourapis  <alexismt@ieee.org>
  12.  *      - Modified for encoder from ldecod/src/mc_prediction.c 
  13.  *          by Peshala V. Pahalawatta <pesh@ieee.org>
  14.  *************************************************************************************
  15.  */
  16. #include "global.h"
  17. #include "mbuffer.h"
  18. #include "mb_access.h"
  19. #include "macroblock.h"
  20. #include "errdo_mc_prediction.h"
  22. //extern StorablePicture *no_reference_picture;
  24. #if defined(USEMMX) 
  25. #if defined(_MSC_VER) || defined(__INTEL_COMPILER) // ICC  
  26. __declspec(align(16)) imgpel tmp_block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
  27. __declspec(align(16)) imgpel tmp_block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
  28. # else  
  29. imgpel tmp_block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE]      __attribute__ ((aligned (16)));
  30. imgpel tmp_block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE]      __attribute__ ((aligned (16)));
  31. # endif
  32. #else
  33. imgpel tmp_block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE];     //!< l0 prediction
  34. imgpel tmp_block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE];     //!< l1 prediction
  35. #endif
  37. static const int COEF[6] = { 1, -5, 20, 20, -5, 1 };
  38. /*!
  39.  ************************************************************************
  40.  * brief
  41.  *    block single list prediction
  42.  ************************************************************************
  43.  */
  44. static inline void mc_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  45.                     int ver_block_size, 
  46.                     int hor_block_size,
  47.                     int ioff,
  48.                     imgpel block[MB_BLOCK_SIZE][MB_BLOCK_SIZE])
  49. {
  50.   static int jj;
  52.   if (hor_block_size == MB_BLOCK_SIZE)
  53.   {
  54.     memcpy(&(mb_pred[0][ioff]), &(block[0][0]), hor_block_size * ver_block_size * sizeof(imgpel));
  55.   }
  56.   else
  57.   {
  58.     for(jj = 0; jj < ver_block_size; jj++)
  59.     {
  60.       memcpy(&(mb_pred[jj][ioff]), &(block[jj][0]), hor_block_size * sizeof(imgpel));
  61.     }
  62.   }
  63. }
  65. /*!
  66.  ************************************************************************
  67.  * brief
  68.  *    block single list weighted prediction
  69.  ************************************************************************
  70.  */
  71. static inline void weighted_mc_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  72.                             int ver_block_size, 
  73.                             int hor_block_size,
  74.                             int ioff,
  75.                             imgpel block[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  76.                             int wp_scale,
  77.                             int wp_offset,
  78.                             int weight_denom,
  79.                             int color_clip)
  80. {
  81.   static int ii, jj;
  82.   static imgpel *mpr, *b0;
  83.   
  84.   for(jj=0;jj<ver_block_size;jj++)
  85.   {
  86.     mpr = &mb_pred[jj][ioff];
  87.     b0 = block[jj];
  88.     for(ii=0;ii<hor_block_size;ii++)
  89.       *(mpr++) = (imgpel) iClip1(color_clip, (rshift_rnd((wp_scale * *(b0++)), weight_denom)  + wp_offset ));
  90.   }
  91. }
  94. /*!
  95.  ************************************************************************
  96.  * brief
  97.  *    block biprediction
  98.  ************************************************************************
  99.  */
  100. static inline void bi_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE],  
  101.                                  imgpel block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  102.                                  imgpel block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  103.                                  int ver_block_size, 
  104.                                  int hor_block_size,
  105.                                  int ioff)
  106. {
  107.   static int ii, jj;
  108.   static imgpel *mpr, *b0, *b1;
  110.   for(jj = 0;jj < ver_block_size;jj++)
  111.   {
  112.     mpr = &mb_pred[jj][ioff];
  113.     b0 = block_l0[jj];
  114.     b1 = block_l1[jj];
  115.     for(ii = 0; ii < hor_block_size;ii++)
  116.       *(mpr++) = (imgpel) rshift_rnd_sf((*(b0++) + *(b1++)), 1);
  117.   }
  118. }
  120. /*!
  121.  ************************************************************************
  122.  * brief
  123.  *    block weighted biprediction
  124.  ************************************************************************
  125.  */
  126. static inline void weighted_bi_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  127.                                           imgpel block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  128.                                           imgpel block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  129.                                           int ver_block_size, 
  130.                                           int hor_block_size,
  131.                                           int ioff,
  132.                                           int wp_scale_l0,
  133.                                           int wp_scale_l1,
  134.                                           int wp_offset,
  135.                                           int weight_denom,
  136.                                           int color_clip)
  137. {
  138.   static int ii, jj;
  139.   static imgpel *mpr, *b0, *b1;
  140.   
  141.   for(jj = 0; jj < ver_block_size; jj++)
  142.   {
  143.     mpr = &mb_pred[jj][ioff];    
  144.     b0  = block_l0[jj];
  145.     b1  = block_l1[jj];
  147.     for(ii=0;ii<hor_block_size;ii++)
  148.       *(mpr++) = (imgpel) iClip1(color_clip, (rshift_rnd((wp_scale_l0 * *(b0++) + wp_scale_l1 * *(b1++)), weight_denom) + wp_offset));
  149.   }
  150. }
  152. void get_block_luma(int decoder, ColorPlane pl, StorablePicture* dec_picture, StorablePicture *curr_ref, int x_pos, int y_pos, int hor_block_size, int ver_block_size, ImageParameters *img, imgpel block[MB_BLOCK_SIZE][MB_BLOCK_SIZE])
  153. {
  154.   static int tmp_res[21][21];
  155.   static int *tmp_line;
  156.   static imgpel *p0, *p1, *p2, *p3, *p4, *p5;
  157.   static int    *x0, *x1, *x2, *x3, *x4, *x5;  
  158.   
  159.   static imgpel **cur_imgY, *cur_lineY;
  160.   static int ipos_m2, ipos_m1, ipos, ipos_p1, ipos_p2, ipos_p3;
  161.   static imgpel *orig_line;
  162.   int tmp_pos;
  164.   int dx = (x_pos & 3), dy = (y_pos & 3);
  165.   int i, j, jj;
  166.   int shift_x  = dec_picture->size_x;
  167.   int maxold_x = dec_picture->size_x - 1;
  168.   int maxold_y = (dec_picture->motion.mb_field[img->current_mb_nr]) ? (dec_picture->size_y >> 1) - 1 : dec_picture->size_y - 1;
  169.   int result;
  170.   int pres_x;
  171.   int max_imgpel_value = img->max_imgpel_value_comp[pl];
  174.   if( IS_INDEPENDENT(params) )
  175.   {
  176.     cur_imgY = curr_ref->p_dec_img[img->colour_plane_id][decoder];
  177.   }
  178.   else
  179.   {
  180.     cur_imgY = curr_ref->p_dec_img[pl][decoder];
  181.   }
  183.   x_pos = x_pos >> 2;
  184.   y_pos = y_pos >> 2;
  186.   if ( (y_pos > 1) && (y_pos < maxold_y - 2 - ver_block_size) && (x_pos > 1) && (x_pos < maxold_x - 2 - hor_block_size))
  187.   {
  188.     cur_imgY = &cur_imgY[ y_pos];
  189.     if (dx == 0 && dy == 0)
  190.     {  /* fullpel position */
  191.       for (j = 0; j < ver_block_size; j++)
  192.       {        
  193.         memcpy(&(block[j][0]), &(cur_imgY[j][x_pos]), hor_block_size * sizeof(imgpel));
  194.       }
  195.     }
  196.     else
  197.     { /* other positions */
  199.       if (dy == 0)
  200.       { /* No vertical interpolation */
  201.         for (j = 0; j < ver_block_size; j++)
  202.         {
  203.           p0 = &cur_imgY[j][x_pos - 2];
  204.           p1 = p0 + 1;
  205.           p2 = p1 + 1;
  206.           p3 = p2 + 1;
  207.           p4 = p3 + 1;
  208.           p5 = p4 + 1;
  209.           orig_line = block[j];
  211.           for (i = 0; i < hor_block_size; i++)
  212.           {        
  213.             result  = (*(p0++) + *(p5++)) * COEF[0]
  214.                     + (*(p1++) + *(p4++)) * COEF[1]
  215.                     + (*(p2++) + *(p3++)) * COEF[2];
  217.             *orig_line++ = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  218.           }
  219.         }
  221.         if ((dx&1) == 1)
  222.         {          
  223.           for (j = 0; j < ver_block_size; j++)
  224.           {
  225.             cur_lineY = &(cur_imgY[j][x_pos + (dx >> 1)]);
  226.             orig_line = block[j];
  227.             for (i = 0; i < hor_block_size; i++)
  228.             {
  229.               *orig_line = (imgpel) ((*orig_line + *(cur_lineY++) + 1 ) >> 1);
  230.               orig_line++;
  231.             }
  232.           }
  233.         }
  234.       }
  235.       else if (dx == 0)
  236.       {  /* No horizontal interpolation */        
  237.         p0 = &(cur_imgY[ - 2][x_pos]);
  238.         for (j = 0; j < ver_block_size; j++)
  239.         {                  
  240.           p1 = p0 + shift_x;          
  241.           p2 = p1 + shift_x;
  242.           p3 = p2 + shift_x;
  243.           p4 = p3 + shift_x;
  244.           p5 = p4 + shift_x;
  245.           orig_line = block[j];
  247.           for (i = 0; i < hor_block_size; i++)
  248.           {
  249.             result  = (*(p0++) + *(p5++)) * COEF[0]
  250.                     + (*(p1++) + *(p4++)) * COEF[1]
  251.                     + (*(p2++) + *(p3++)) * COEF[2];
  253.             *orig_line++ = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  254.           }
  255.           p0 = p1 - hor_block_size;
  256.         }
  258.         if ((dy&1) == 1)
  259.         {
  260.           jj = (dy >> 1);
  261.           for (j = 0; j < ver_block_size; j++)
  262.           {
  263.             cur_lineY = &(cur_imgY[jj++][x_pos]);
  264.             orig_line = block[j];
  265.             for (i = 0; i < hor_block_size; i++)
  266.             {
  267.               *orig_line = (imgpel) ((*orig_line + *(cur_lineY++) + 1 ) >> 1);
  268.               orig_line++;
  269.             }
  270.           }
  271.         }
  272.       }
  273.       else if (dx == 2)
  274.       {  /* Vertical & horizontal interpolation */
  275.         jj = - 2;
  276.         for (j = 0; j < ver_block_size + 5; j++)
  277.         {
  278.           p0 = &cur_imgY[jj++][x_pos - 2];
  279.           p1 = p0 + 1;
  280.           p2 = p1 + 1;
  281.           p3 = p2 + 1;
  282.           p4 = p3 + 1;
  283.           p5 = p4 + 1;
  284.           orig_line = block[j];
  285.           tmp_line  = tmp_res[j];
  287.           for (i = 0; i < hor_block_size; i++)
  288.           {        
  289.             *(tmp_line++) = (*(p0++) + *(p5++)) * COEF[0]
  290.                           + (*(p1++) + *(p4++)) * COEF[1]
  291.                           + (*(p2++) + *(p3++)) * COEF[2];
  292.           }
  293.         }
  295.         for (j = 0; j < ver_block_size; j++)
  296.         {
  297.           x0 = tmp_res[j    ];
  298.           x1 = tmp_res[j + 1];
  299.           x2 = tmp_res[j + 2];
  300.           x3 = tmp_res[j + 3];
  301.           x4 = tmp_res[j + 4];
  302.           x5 = tmp_res[j + 5];
  303.           orig_line = block[j];
  305.           for (i = 0; i < hor_block_size; i++)
  306.           {
  307.             result  = (*x0++ + *x5++) * COEF[0]
  308.                     + (*x1++ + *x4++) * COEF[1]
  309.                     + (*x2++ + *x3++) * COEF[2];
  311.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result+512)>>10));
  312.           }
  313.         }
  315.         if ((dy&1) == 1)
  316.         {
  317.           jj = 2 + (dy>>1);
  318.           for (j = 0; j < ver_block_size; j++)
  319.           {            
  320.             tmp_line  = tmp_res[jj++];
  321.             orig_line = block[j];
  322.             for (i = 0; i < hor_block_size; i++)
  323.             {
  324.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16) >> 5)) + 1 )>> 1);
  325.               orig_line++;
  326.             }
  327.           }
  328.         }
  329.       }
  330.       else if (dy == 2)
  331.       {  /* Horizontal & vertical interpolation */
  332.         p0 = &(cur_imgY[ -2][x_pos - 2]);
  333.         for (j = 0; j < ver_block_size; j++)
  334.         {                    
  335.           p1 = p0 + shift_x;
  336.           p2 = p1 + shift_x;
  337.           p3 = p2 + shift_x;
  338.           p4 = p3 + shift_x;
  339.           p5 = p4 + shift_x;
  340.           tmp_line  = tmp_res[j];
  342.           for (i = 0; i < hor_block_size + 5; i++)
  343.           {
  344.             *(tmp_line++)  = (*(p0++) + *(p5++)) * COEF[0]
  345.                            + (*(p1++) + *(p4++)) * COEF[1]
  346.                            + (*(p2++) + *(p3++)) * COEF[2];
  347.           }
  348.           p0 = p1 - (hor_block_size + 5);
  349.         }
  351.         for (j = 0; j < ver_block_size; j++)
  352.         {
  353.           orig_line = block[j];
  354.           x0 = tmp_res[j];
  355.           x1 = x0 + 1;
  356.           x2 = x1 + 1;
  357.           x3 = x2 + 1;
  358.           x4 = x3 + 1;
  359.           x5 = x4 + 1;
  361.           for (i = 0; i < hor_block_size; i++)
  362.           {
  363.             result  = (*(x0++) + *(x5++)) * COEF[0]
  364.                     + (*(x1++) + *(x4++)) * COEF[1]
  365.                     + (*(x2++) + *(x3++)) * COEF[2];
  367.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result + 512)>>10));
  368.           }
  369.         }
  371.         if ((dx&1) == 1)
  372.         {
  373.           for (j = 0; j < ver_block_size; j++)
  374.           {
  375.             tmp_line  = &tmp_res[j][2 + (dx>>1)];
  376.             orig_line = block[j];
  377.             for (i = 0; i < hor_block_size; i++)
  378.             {
  379.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16)>>5))+1)>>1);
  380.               orig_line ++;
  381.             }
  382.           }
  383.         }
  384.       }
  385.       else
  386.       {  /* Diagonal interpolation */
  387.         jj = (dy == 1 ? 0 : 1);
  389.         for (j = 0; j < ver_block_size; j++)
  390.         {
  391.           p0 = &cur_imgY[jj++][x_pos - 2];
  392.           p1 = p0 + 1;
  393.           p2 = p1 + 1;
  394.           p3 = p2 + 1;
  395.           p4 = p3 + 1;
  396.           p5 = p4 + 1;
  398.           orig_line = block[j];
  400.           for (i = 0; i < hor_block_size; i++)
  401.           {        
  402.             result  = (*(p0++) + *(p5++)) * COEF[0]
  403.                     + (*(p1++) + *(p4++)) * COEF[1]
  404.                     + (*(p2++) + *(p3++)) * COEF[2];
  406.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  407.           }
  408.         }
  410.         p0 = &(cur_imgY[-2][(dx == 1 ? x_pos : x_pos + 1)]);
  411.         for (j = 0; j < ver_block_size; j++)
  412.         {        
  413.           p1 = p0 + shift_x;
  414.           p2 = p1 + shift_x;
  415.           p3 = p2 + shift_x;
  416.           p4 = p3 + shift_x;
  417.           p5 = p4 + shift_x;
  418.           orig_line = block[j];
  420.           for (i = 0; i < hor_block_size; i++)
  421.           {
  422.             result  = (*(p0++) + *(p5++)) * COEF[0]
  423.                     + (*(p1++) + *(p4++)) * COEF[1]
  424.                     + (*(p2++) + *(p3++)) * COEF[2];
  426.             *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((result + 16) >> 5)) + 1) >> 1);
  427.             orig_line++;
  428.           }
  429.           p0 = p1 - hor_block_size ;
  430.         }      
  431.       }
  432.     }
  433.   }
  434.   else // unsafe positions
  435.   {
  436.     if (dx == 0 && dy == 0)
  437.     {  /* fullpel position */
  438.       for (j = 0; j < ver_block_size; j++)
  439.       {
  440.         cur_lineY = cur_imgY[iClip3(0, maxold_y, y_pos + j)];
  441.         orig_line = block[j];
  442.         for (i = 0; i < hor_block_size; i++)
  443.         {
  444.           *(orig_line++) = cur_lineY[iClip3(0, maxold_x, x_pos + i )];
  445.         }
  446.       }
  447.     }
  448.     else
  449.     { /* other positions */
  451.       if (dy == 0)
  452.       { /* No vertical interpolation */
  453.         tmp_pos = x_pos - 2;
  454.         for (i = 0; i < hor_block_size; i++)
  455.         {        
  456.           ipos_m2 = iClip3(0, maxold_x, tmp_pos++);
  457.           ipos_m1 = iClip3(0, maxold_x, tmp_pos++);
  458.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  459.           ipos_p1 = iClip3(0, maxold_x, tmp_pos++);
  460.           ipos_p2 = iClip3(0, maxold_x, tmp_pos++);
  461.           ipos_p3 = iClip3(0, maxold_x, tmp_pos  );
  462.           tmp_pos -= 4;          
  464.           for (j = 0; j < ver_block_size; j++)
  465.           {
  466.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos+j)];
  468.             result  = (cur_lineY[ipos_m2] + cur_lineY[ipos_p3]) * COEF[0];
  469.             result += (cur_lineY[ipos_m1] + cur_lineY[ipos_p2]) * COEF[1];
  470.             result += (cur_lineY[ipos   ] + cur_lineY[ipos_p1]) * COEF[2];
  472.             block[j][i] = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  473.           }
  474.         }
  476.         if ((dx&1) == 1)
  477.         {
  478.           for (j = 0; j < ver_block_size; j++)
  479.           {
  480.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos+j)];
  481.             orig_line = block[j];
  482.             for (i = 0; i < hor_block_size; i++)
  483.             {
  484.               *orig_line = (imgpel) ((*orig_line + cur_lineY[iClip3(0, maxold_x, x_pos + i + (dx >> 1))] + 1 ) >> 1);
  485.               orig_line++;
  486.             }
  487.           }
  488.         }
  489.       }
  490.       else if (dx == 0)
  491.       {  /* No horizontal interpolation */
  492.         tmp_pos = y_pos - 2;
  493.         for (j = 0; j < ver_block_size; j++)
  494.         { 
  495.           p0 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  496.           p1 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  497.           p2 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  498.           p3 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  499.           p4 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  500.           p5 = cur_imgY[iClip3(0, maxold_y, tmp_pos  )];
  501.           
  502.           tmp_pos -= 4;
  503.           orig_line = block[j];
  505.           for (i = 0; i < hor_block_size; i++)
  506.           {
  507.             pres_x = iClip3(0,maxold_x,x_pos+i);
  509.             result  = (p0[pres_x] + p5[pres_x]) * COEF[0];
  510.             result += (p1[pres_x] + p4[pres_x]) * COEF[1];
  511.             result += (p2[pres_x] + p3[pres_x]) * COEF[2];
  512.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result+16)>>5));
  513.           }
  514.         }
  516.         if ((dy&1) == 1)
  517.         {
  518.           for (j = 0; j < ver_block_size; j++)
  519.           {
  520.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos+j+(dy>>1))];
  521.             orig_line = block[j];
  522.             for (i = 0; i < hor_block_size; i++)
  523.             {
  524.               *orig_line = (imgpel) ((*orig_line + cur_lineY[iClip3(0, maxold_x, x_pos + i)] + 1 ) >> 1);
  525.               orig_line++;
  526.             }
  527.           }
  528.         }
  529.       }
  530.       else if (dx == 2)
  531.       {  /* Vertical & horizontal interpolation */
  532.         tmp_pos = x_pos - 2;
  533.         for (i = 0; i < hor_block_size; i++)
  534.         {        
  535.           ipos_m2 = iClip3(0, maxold_x, tmp_pos++);
  536.           ipos_m1 = iClip3(0, maxold_x, tmp_pos++);
  537.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  538.           ipos_p1 = iClip3(0, maxold_x, tmp_pos++);
  539.           ipos_p2 = iClip3(0, maxold_x, tmp_pos++);
  540.           ipos_p3 = iClip3(0, maxold_x, tmp_pos  );
  541.           tmp_pos -= 4;
  543.           for (j = 0; j < ver_block_size + 5; j++)
  544.           {
  545.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos + j - 2)];
  547.             tmp_res[j][i]  = (cur_lineY[ipos_m2] + cur_lineY[ipos_p3]) * COEF[0];
  548.             tmp_res[j][i] += (cur_lineY[ipos_m1] + cur_lineY[ipos_p2]) * COEF[1];
  549.             tmp_res[j][i] += (cur_lineY[ipos   ] + cur_lineY[ipos_p1]) * COEF[2];
  550.           }
  551.         }
  553.         for (j = 0; j < ver_block_size; j++)
  554.         {
  555.           x0 = tmp_res[j    ];
  556.           x1 = tmp_res[j + 1];
  557.           x2 = tmp_res[j + 2];
  558.           x3 = tmp_res[j + 3];
  559.           x4 = tmp_res[j + 4];
  560.           x5 = tmp_res[j + 5];
  561.           orig_line = block[j];
  563.           for (i = 0; i < hor_block_size; i++)
  564.           {
  565.             result  = (*x0++ + *x5++) * COEF[0]
  566.                     + (*x1++ + *x4++) * COEF[1]
  567.                     + (*x2++ + *x3++) * COEF[2];
  569.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result+512)>>10));
  570.           }
  571.         }
  573.         if ((dy&1) == 1)
  574.         {
  575.           for (j = 0; j < ver_block_size; j++)
  576.           {
  577.             tmp_line  = tmp_res[j + 2 + (dy>>1)];            
  578.             orig_line = block[j];
  579.             for (i = 0; i < hor_block_size; i++)
  580.             {
  581.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16) >> 5)) + 1 )>>1);
  582.               orig_line++;
  583.             }
  584.           }
  585.         }
  586.       }
  587.       else if (dy == 2)
  588.       {  /* Horizontal & vertical interpolation */
  590.         tmp_pos = y_pos - 2;
  591.         for (j = 0; j < ver_block_size; j++)
  592.         {
  593.           p0 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  594.           p1 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  595.           p2 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  596.           p3 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  597.           p4 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  598.           p5 = cur_imgY[iClip3(0, maxold_y, tmp_pos  )];
  600.           tmp_pos -= 4;
  602.           for (i = 0; i < hor_block_size + 5; i++)
  603.           {
  604.             pres_x = iClip3(0,maxold_x, x_pos + i - 2);
  605.             result  = (p0[pres_x] + p5[pres_x])*COEF[0]
  606.                     + (p1[pres_x] + p4[pres_x])*COEF[1]
  607.                     + (p2[pres_x] + p3[pres_x])*COEF[2];
  608.             tmp_res[j][i] = result;
  609.           }
  610.         }
  612.         for (j = 0; j < ver_block_size; j++)
  613.         {
  614.           orig_line = block[j];
  615.           tmp_line  = tmp_res[j];
  616.           x0 = tmp_res[j];
  617.           x1 = x0 + 1;
  618.           x2 = x1 + 1;
  619.           x3 = x2 + 1;
  620.           x4 = x3 + 1;
  621.           x5 = x4 + 1;
  623.           for (i = 0; i < hor_block_size; i++)
  624.           {
  625.             result  = (*(x0++) + *(x5++)) * COEF[0]
  626.                     + (*(x1++) + *(x4++)) * COEF[1]
  627.                     + (*(x2++) + *(x3++)) * COEF[2];
  629.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result + 512)>>10));
  630.           }
  631.         }
  633.         if ((dx&1) == 1)
  634.         {
  635.           for (j = 0; j < ver_block_size; j++)
  636.           {
  637.             tmp_line  = &tmp_res[j][2 + (dx>>1)];
  638.             orig_line = block[j];            
  639.             for (i = 0; i < hor_block_size; i++)
  640.             {
  641.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16)>>5)) + 1)>> 1);
  642.               orig_line++;
  643.             }
  644.           }
  645.         }
  646.       }
  647.       else
  648.       {  /* Diagonal interpolation */
  649.         tmp_pos = x_pos - 2;
  650.         for (i = 0; i < hor_block_size; i++)
  651.         {
  652.           ipos_m2 = iClip3(0, maxold_x, tmp_pos++);
  653.           ipos_m1 = iClip3(0, maxold_x, tmp_pos++);
  654.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  655.           ipos_p1 = iClip3(0, maxold_x, tmp_pos++);
  656.           ipos_p2 = iClip3(0, maxold_x, tmp_pos++);
  657.           ipos_p3 = iClip3(0, maxold_x, tmp_pos  );
  658.           tmp_pos -= 4;
  660.           for (j = 0; j < ver_block_size; j++)
  661.           {
  662.             cur_lineY = cur_imgY[iClip3(0,maxold_y,(dy == 1 ? y_pos+j : y_pos+j+1))];
  664.             result  = (cur_lineY[ipos_m2] + cur_lineY[ipos_p3]) * COEF[0];
  665.             result += (cur_lineY[ipos_m1] + cur_lineY[ipos_p2]) * COEF[1];
  666.             result += (cur_lineY[ipos   ] + cur_lineY[ipos_p1]) * COEF[2];
  668.             block[j][i] = (imgpel) iClip1(max_imgpel_value, ((result+16)>>5));
  669.           }
  670.         }
  672.         tmp_pos = y_pos - 2;
  673.         for (j = 0; j < ver_block_size; j++)
  674.         {      
  675.           p0 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  676.           p1 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  677.           p2 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  678.           p3 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  679.           p4 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  680.           p5 = cur_imgY[iClip3(0, maxold_y, tmp_pos  )];
  682.           tmp_pos -= 4;
  683.           orig_line = block[j];
  685.           for (i = 0; i < hor_block_size; i++)
  686.           {
  687.             pres_x = dx == 1 ? x_pos+i : x_pos+i+1;
  688.             pres_x = iClip3(0, maxold_x, pres_x);
  690.             result  = (p0[pres_x] + p5[pres_x]) * COEF[0];
  691.             result += (p1[pres_x] + p4[pres_x]) * COEF[1];
  692.             result += (p2[pres_x] + p3[pres_x]) * COEF[2];
  694.             *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((result+16)>>5)) + 1 ) >> 1);
  695.             orig_line++;
  696.           }
  697.         }      
  698.       }
  699.     }
  700.   }
  701. }
  703. void get_block_chroma(int decoder, int uv, StorablePicture* dec_picture, StorablePicture *curr_ref, int x_pos, int y_pos, int hor_block_size, int ver_block_size, ImageParameters *img, imgpel block[MB_BLOCK_SIZE][MB_BLOCK_SIZE])
  704. {
  705.   int subpel_x    = img->mb_cr_size_x == 8 ? 7 : 3;
  706.   int subpel_y    = img->mb_cr_size_y == 8 ? 7 : 3;
  707.   int shiftpel_x  = img->mb_cr_size_x == 8 ? 3 : 2;
  708.   int shiftpel_y  = img->mb_cr_size_y == 8 ? 3 : 2;
  709.   int total_scale = shiftpel_x + shiftpel_y;
  711.   int dx = (x_pos & subpel_x);
  712.   int dy = (y_pos & subpel_y);
  713.   int dxcur = (subpel_x + 1 - dx);
  714.   int dycur = (subpel_y + 1 - dy);
  716.   int w00 = dxcur * dycur;
  717.   int w01 = dxcur * dy;
  718.   int w10 = dx * dycur;
  719.   int w11 = dx * dy;
  721.   int i, j;
  722.   int maxold_x = dec_picture->size_x_cr - 1;
  723.   int maxold_y = (dec_picture->motion.mb_field[img->current_mb_nr]) ? (dec_picture->size_y_cr >> 1) - 1 : dec_picture->size_y_cr - 1;
  724.   int result;
  725.   
  726.   static imgpel **cur_img, *blk_line;
  727.   static imgpel *cur_line, *cur_line_p1;
  728.   int tmp_pos;
  729.   static int ipos, ipos_p1;
  730.   int    max_imgpel_value = img->max_imgpel_value_comp[uv + 1];
  732. #if 0
  733.   if (curr_ref == no_reference_picture && img->framepoc < img->recovery_poc)
  734.   {
  735.     printf("list[ref_frame] is equal to 'no reference picture' before RAPn");
  737.     /* fill the block with sample value 128 */
  738.     for (j = 0; j < ver_block_size; j++)
  739.       for (i = 0; i < hor_block_size; i++)
  740.         block[j][i] = 128;
  741.     return;
  742.   }
  743. #endif
  745.   cur_img = curr_ref->p_dec_img[uv+1][decoder];
  747.   x_pos = x_pos >> shiftpel_x;
  748.   y_pos = y_pos >> shiftpel_y;
  750.   if ((y_pos >= 0) && (y_pos < maxold_y - ver_block_size) && (x_pos >= 0) && (x_pos < maxold_x - hor_block_size))
  751.   {
  752.     if (dx == 0 && dy == 0)
  753.     {  /* fullpel position */
  754.       for (j = 0; j < ver_block_size; j++)
  755.       {        
  756.         memcpy(&(block[j][0]), &(cur_img[ y_pos + j ][x_pos]), hor_block_size * sizeof(imgpel));
  757.       }
  758.     }
  759.     else if (dx == 0)
  760.     { 
  761.       for (j = 0; j < ver_block_size; j++)
  762.       {
  763.         cur_line    = &cur_img[y_pos + j    ][x_pos];
  764.         cur_line_p1 = &cur_img[y_pos + j + 1][x_pos];
  765.         blk_line = block[j];
  767.         for (i = 0; i < hor_block_size; i++)
  768.         {
  769.           result = (w00 * *cur_line++ + w01 * *cur_line_p1++);
  770.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  771.         }
  772.       }
  773.     }
  774.     else if (dy == 0)
  775.     { 
  776.       for (j = 0; j < ver_block_size; j++)
  777.       {
  778.         cur_line    = &cur_img[y_pos + j][x_pos];
  779.         cur_line_p1 = cur_line + 1;
  780.         blk_line = block[j];
  782.         for (i = 0; i < hor_block_size; i++)
  783.         {
  784.           result = (w00 * *cur_line++ + w10 * *cur_line_p1++);
  785.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  786.         }
  787.       }
  788.     }
  789.     else
  790.     { /* other positions */
  791.       for (j = 0; j < ver_block_size; j++)
  792.       {
  793.         cur_line    = &cur_img[y_pos + j    ][x_pos];
  794.         cur_line_p1 = &cur_img[y_pos + j + 1][x_pos];
  795.         blk_line = block[j];
  797.         for (i = 0; i < hor_block_size; i++)
  798.         {
  799.           result  = (w00 * *(cur_line++) + w01 * *(cur_line_p1++));
  800.           result += (w10 * *(cur_line  ) + w11 * *(cur_line_p1  ));
  801.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  802.         }
  803.       }
  804.     }
  805.   }
  806.   else // unsafe positions
  807.   {
  808.     if (dx == 0 && dy == 0)
  809.     {  /* fullpel position */
  810.       for (j = 0; j < ver_block_size; j++)
  811.       {
  812.         cur_line = cur_img[iClip3(0, maxold_y, y_pos + j)];
  813.         blk_line = block[j];
  814.         for (i = 0; i < hor_block_size; i++)
  815.         {
  816.           *(blk_line++) = cur_line[iClip3(0, maxold_x, x_pos + i )];
  817.         }
  818.       }
  819.     }
  820.     else if (dx == 0)
  821.     { 
  822.       for (j = 0; j < ver_block_size; j++)
  823.       {
  824.         cur_line    = cur_img[iClip3(0, maxold_y, y_pos + j)];
  825.         cur_line_p1 = cur_img[iClip3(0, maxold_y, y_pos + j + 1)];
  826.         tmp_pos = x_pos;
  827.         blk_line = block[j];
  829.         for (i = 0; i < hor_block_size; i++)
  830.         {
  831.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  833.           result = (w00 * cur_line[ipos] + w01 * cur_line_p1[ipos]);
  834.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  835.         }
  836.       }      
  837.     }
  838.     else if (dy == 0)
  839.     { 
  840.       for (j = 0; j < ver_block_size; j++)
  841.       {
  842.         cur_line    = cur_img[iClip3(0, maxold_y, y_pos + j)];
  843.         tmp_pos = x_pos;
  844.         blk_line = block[j];
  846.         for (i = 0; i < hor_block_size; i++)
  847.         {
  848.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  849.           ipos_p1 = iClip3(0, maxold_x, tmp_pos  );
  851.           result = (w00 * cur_line[ipos   ] + w10 * cur_line[ipos_p1]);
  852.           *(blk_line++) = (imgpel)iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  853.         }
  854.       }      
  855.     }
  856.     else
  857.     { /* other positions */ 
  858.       for (j = 0; j < ver_block_size; j++)
  859.       {
  860.         cur_line    = cur_img[iClip3(0, maxold_y, y_pos + j)];
  861.         cur_line_p1 = cur_img[iClip3(0, maxold_y, y_pos + j + 1)];
  862.         tmp_pos = x_pos;
  863.         blk_line = block[j];
  865.         for (i = 0; i < hor_block_size; i++)
  866.         {
  867.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  868.           ipos_p1 = iClip3(0, maxold_x, tmp_pos  );
  870.           result = (
  871.             w00 * cur_line   [ipos   ] + 
  872.             w10 * cur_line   [ipos_p1] +
  873.             w01 * cur_line_p1[ipos   ] +
  874.             w11 * cur_line_p1[ipos_p1]);
  875.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  876.         }
  877.       }      
  878.     }
  879.   }
  880. }
  882. #if 0
  883. void intra_cr_decoding(Macroblock *currMB, int yuv, ImageParameters *img, int smb)
  884. {
  885.   imgpel **curUV, *cur_img;
  886.   int (*m7UV)[16], *m7;
  887.   int uv;
  888.   int b8,b4;
  889.   int ioff, joff, ii, jj;
  891.   for(uv = 0; uv < 2; uv++)
  892.   {
  893.     Boolean lossless_qpprime = (Boolean) ((img->lossless_qpprime_flag == 1) &&((img->qp + dec_picture->chroma_qp_offset[uv] + img->bitdepth_chroma_qp_scale) == 0));
  894.     itrans_4x4 = (!lossless_qpprime) ? itrans4x4 : itrans4x4_ls;
  896.     curUV = dec_picture->imgUV[uv];
  897.     m7UV  = img->mb_rres[uv+1];
  898.     intrapred_chroma(img, currMB, uv);
  900.     if (!smb && (currMB->cbp >> 4))
  901.     {
  902.       for (b8 = 0; b8 < (img->num_uv_blocks); b8++)
  903.       {
  904.         for(b4 = 0; b4 < 4; b4++)
  905.         {
  906.           joff = subblk_offset_y[yuv][b8][b4];          
  907.           ioff = subblk_offset_x[yuv][b8][b4];          
  909.           itrans_4x4(img, (ColorPlane) (uv + 1), ioff, joff);
  911.           for(jj=joff; jj<joff + 4;jj++)
  912.           {
  913.             cur_img = &curUV[img->pix_c_y+jj][img->pix_c_x + ioff];
  914.             m7 = &m7UV[jj][ioff];
  916.             for(ii=0; ii<4;ii++)
  917.             {
  918.               *cur_img++ = (imgpel) *m7++;
  919.             }
  920.           }
  921.         }
  922.       }
  923.     }
  924.     else if ((currMB->cbp >> 4) == 0)
  925.     {
  926.       for (b8 = 0; b8 < (img->num_uv_blocks); b8++)
  927.       {
  928.         for(b4 = 0; b4 < 4; b4++)
  929.         {
  930.           joff = subblk_offset_y[yuv][b8][b4];
  931.           ioff = subblk_offset_x[yuv][b8][b4];          
  933.           for(jj = joff; jj < 4 + joff;jj++)
  934.             memcpy(&(curUV[img->pix_c_y + jj][img->pix_c_x + ioff]), &(img->mb_pred[uv + 1][jj][ioff]), BLOCK_SIZE * sizeof(imgpel));
  935.         }
  936.       }
  937.     }
  938.     else
  939.     {
  940.       itrans_sp_cr(img, uv);
  942.       for (joff  = 0; joff < 8; joff += 4)
  943.       {
  944.         for(ioff = 0; ioff < 8;ioff+=4)
  945.         {          
  946.           itrans_4x4(img, (ColorPlane) (uv + 1), ioff, joff);
  948.           for(jj = joff; jj < joff + 4; jj++)
  949.             for(ii = ioff; ii < ioff + 4; ii++)
  950.             {
  951.               curUV[img->pix_c_y+jj][ii + img->pix_c_x] = (imgpel) img->mb_rres[uv+1][jj][ii];
  952.             }
  953.         }
  954.       }
  955.     }
  956.   }
  957. }
  959. void prepare_direct_params(Macroblock *currMB, StorablePicture *dec_picture, ImageParameters *img, short pmvl0[2], short pmvl1[2],char *l0_rFrame, char *l1_rFrame)
  960. {
  961.   char l0_rFrameL, l0_rFrameU, l0_rFrameUL, l0_rFrameUR;
  962.   char l1_rFrameL, l1_rFrameU, l1_rFrameUL, l1_rFrameUR;
  963.   
  964.   PixelPos mb_left, mb_up, mb_upleft, mb_upright;
  966.   get4x4Neighbour(currMB, -1,  0, img->mb_size[IS_LUMA], &mb_left);
  967.   get4x4Neighbour(currMB,  0, -1, img->mb_size[IS_LUMA], &mb_up);
  968.   get4x4Neighbour(currMB, 16, -1, img->mb_size[IS_LUMA], &mb_upright);
  969.   get4x4Neighbour(currMB, -1, -1, img->mb_size[IS_LUMA], &mb_upleft);
  971.   if (!img->MbaffFrameFlag)
  972.   {
  973.     l0_rFrameL  = (char) (mb_left.available    ? dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x]       : -1);
  974.     l0_rFrameU  = (char) (mb_up.available      ? dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x]           : -1);
  975.     l0_rFrameUL = (char) (mb_upleft.available  ? dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x]   : -1);
  976.     l0_rFrameUR = (char) (mb_upright.available ? dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] : l0_rFrameUL);
  978.     l1_rFrameL  = (char) (mb_left.available     ? dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x]      : -1);
  979.     l1_rFrameU  = (char) (mb_up.available       ? dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x]          : -1);
  980.     l1_rFrameUL = (char) (mb_upleft.available  ? dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x]   : -1);
  981.     l1_rFrameUR = (char) (mb_upright.available ? dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] : l1_rFrameUL);
  982.   }
  983.   else
  984.   {
  985.     if (currMB->mb_field)
  986.     {
  987.       l0_rFrameL = (char) (mb_left.available 
  988.         ? img->mb_data[mb_left.mb_addr].mb_field  || dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] < 0
  989.         ? dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] 
  990.         : dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] * 2: -1);
  992.       l0_rFrameU = (char) (mb_up.available 
  993.         ? img->mb_data[mb_up.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] < 0
  994.         ? dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] 
  995.         : dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] * 2: -1);
  997.        l0_rFrameUL = (char) (mb_upleft.available 
  998.          ? img->mb_data[mb_upleft.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] < 0
  999.          ? dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] 
  1000.          : dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] *2: -1);
  1002.        l0_rFrameUR = (char) (mb_upright.available 
  1003.          ? img->mb_data[mb_upright.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] < 0 
  1004.          ? dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] 
  1005.          : dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] * 2: l0_rFrameUL);
  1007.        l1_rFrameL = (char) (mb_left.available 
  1008.          ? img->mb_data[mb_left.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x]  < 0 
  1009.          ? dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] 
  1010.          : dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] * 2: -1);
  1012.        l1_rFrameU = (char) (mb_up.available 
  1013.          ? img->mb_data[mb_up.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x]  < 0 
  1014.          ? dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] 
  1015.          : dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] * 2: -1);
  1017.        l1_rFrameUL = (char) (mb_upleft.available 
  1018.          ? img->mb_data[mb_upleft.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x]  < 0 
  1019.          ? dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] 
  1020.          : dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] *2 : -1);
  1022.        l1_rFrameUR = (char) (mb_upright.available 
  1023.          ? img->mb_data[mb_upright.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] < 0
  1024.          ? dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] 
  1025.          : dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] * 2: l1_rFrameUL);
  1026.     }
  1027.     else
  1028.     {
  1029.       l0_rFrameL = (char) (mb_left.available 
  1030.         ? img->mb_data[mb_left.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x]  < 0 
  1031.         ? dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] >> 1 
  1032.         : dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x]: -1);
  1034.       l0_rFrameU = (char) (mb_up.available 
  1035.         ? img->mb_data[mb_up.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] < 0 
  1036.         ? dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] >> 1 
  1037.         : dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] : -1);
  1039.       l0_rFrameUL = (char) (mb_upleft.available 
  1040.         ? img->mb_data[mb_upleft.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] < 0 
  1041.         ? dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x]>> 1 
  1042.         : dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] : -1);
  1044.       l0_rFrameUR = (char) (mb_upright.available 
  1045.         ? img->mb_data[mb_upright.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] < 0 
  1046.         ? dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] >> 1 
  1047.         : dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] : l0_rFrameUL);
  1049.       l1_rFrameL = (char) (mb_left.available 
  1050.         ? img->mb_data[mb_left.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] < 0 
  1051.         ? dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] >> 1 
  1052.         : dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] : -1);
  1054.       l1_rFrameU = (char) (mb_up.available 
  1055.         ? img->mb_data[mb_up.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] < 0 
  1056.         ? dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] >> 1 
  1057.         : dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] : -1);
  1059.       l1_rFrameUL = (char) (mb_upleft.available 
  1060.         ? img->mb_data[mb_upleft.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] < 0 
  1061.         ? dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] >> 1 
  1062.         : dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] : -1);
  1064.       l1_rFrameUR = (char) (mb_upright.available 
  1065.         ? img->mb_data[mb_upright.mb_addr].mb_field || dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] < 0 
  1066.         ? dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] >> 1
  1067.         : dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] : l1_rFrameUL);
  1068.     }
  1069.   }
  1071.   *l0_rFrame = (char) ((l0_rFrameL >= 0 && l0_rFrameU >= 0)  ? imin(l0_rFrameL,l0_rFrameU) : imax(l0_rFrameL,l0_rFrameU));
  1072.   *l0_rFrame = (char) ((*l0_rFrame >= 0 && l0_rFrameUR >= 0) ? imin(*l0_rFrame,l0_rFrameUR): imax(*l0_rFrame,l0_rFrameUR));
  1074.   *l1_rFrame = (char) ((l1_rFrameL >= 0 && l1_rFrameU >= 0)  ? imin(l1_rFrameL,l1_rFrameU) : imax(l1_rFrameL,l1_rFrameU));
  1075.   *l1_rFrame = (char) ((*l1_rFrame >= 0 && l1_rFrameUR >= 0) ? imin(*l1_rFrame,l1_rFrameUR): imax(*l1_rFrame,l1_rFrameUR));
  1077.   if (*l0_rFrame >=0)
  1078.     SetMotionVectorPredictor (img, currMB, pmvl0, *l0_rFrame, LIST_0, dec_picture->motion.ref_idx, dec_picture->motion.mv, 0, 0, 16, 16);
  1080.   if (*l1_rFrame >=0)
  1081.     SetMotionVectorPredictor (img, currMB, pmvl1, *l1_rFrame, LIST_1, dec_picture->motion.ref_idx, dec_picture->motion.mv, 0, 0, 16, 16);
  1082. }
  1084. void check_motion_vector_range(ImageParameters *img, short mv_x, short mv_y)
  1085. {
  1086.   if (mv_x > 8191 || mv_x < -8192)
  1087.   {
  1088.     fprintf(stderr,"ERROR! Horizontal motion vector %d is out of allowed range {-8192, 8191} in picture %d, macroblock %dn", mv_x, img->number, img->current_mb_nr);
  1089.     error("invalid stream: too big horizontal motion vector", 500);
  1090.   }
  1092.   if (mv_y > (img->max_mb_vmv_r - 1) || mv_y < (-img->max_mb_vmv_r))
  1093.   {
  1094.     fprintf(stderr,"ERROR! Vertical motion vector %d is out of allowed range {%d, %d} in picture %d, macroblock %dn", mv_y, (-img->max_mb_vmv_r), (img->max_mb_vmv_r - 1), img->number, img->current_mb_nr);
  1095.     error("invalid stream: too big vertical motion vector", 500);
  1096.   }
  1097. }
  1098. #endif
  1100. void perform_mc(int decoder, ColorPlane pl, StorablePicture *dec_picture, ImageParameters *img, int pred_dir, int l0_mode, int l1_mode, int i, int j, int list_offset, int block_size_x, int block_size_y, int curr_mb_field)
  1101. {
  1102.   static int vec1_x=0, vec1_y=0;
  1103. #if 0
  1104.   static int vec2_x=0, vec2_y=0;
  1105.   static int vec1_y_cr = 0, vec2_y_cr = 0;
  1106.   static int alpha_l0, alpha_l1, wp_offset;
  1107.   int        max_imgpel_value = img->max_imgpel_value_comp[pl];
  1108. #endif
  1109.   static const int mv_mul = 16; // 4 * 4
  1111.   
  1112.   int i4   = img->block_x + i;
  1113.   int j4   = img->block_y + j;
  1114.   int ioff = (i << 2);
  1115.   int joff = (j << 2);         
  1116.   
  1117.   assert (pred_dir<=2);
  1119.   if (pred_dir != 2)
  1120.   {
  1121.     //===== Single List Prediction =====
  1122.     short       ref_idx = dec_picture->motion.ref_idx[pred_dir][j4][i4];
  1123.     //short       ref_idx_wp = ref_idx;
  1124.     short      ***mv_array = img->all_mv[pred_dir][ref_idx][l0_mode];
  1125.     StorablePicture **list = listX[list_offset + pred_dir];
  1127.     //check_motion_vector_range(img, mv_array[j4][i4][0], mv_array[j4][i4][1]);
  1129.     vec1_x = i4 * mv_mul + mv_array[j][i][0];
  1130.     //vec1_y = (img->block_y_aff + j) * mv_mul + mv_array[j4][i4][1];
  1131.     vec1_y = j4 * mv_mul + mv_array[j][i][1];
  1133.     get_block_luma (decoder, pl, dec_picture, list[ref_idx], vec1_x, vec1_y, block_size_x, block_size_y, img, tmp_block_l0); 
  1135. #if 0 //Currently not used
  1136.     if (img->apply_weights)
  1137.     {
  1138.       if (curr_mb_field && ((active_pps->weighted_pred_flag&&(img->type==P_SLICE|| img->type == SP_SLICE))||
  1139.          (active_pps->weighted_bipred_idc==1 && (img->type==B_SLICE))))
  1140.       {
  1141.         ref_idx_wp >>=1;
  1142.       }
  1144.       alpha_l0  = img->wp_weight[pred_dir][ref_idx_wp][0];
  1145.       wp_offset = img->wp_offset[pred_dir][ref_idx_wp][0];
  1147.       weighted_mc_prediction(&img->mb_pred[pl][joff], block_size_y, block_size_x, ioff, tmp_block_l0, alpha_l0, wp_offset, img->luma_log2_weight_denom, max_imgpel_value);
  1148.     }
  1149.     else
  1150. #endif
  1151.     {
  1152.       mc_prediction(&img->mb_pred[pl][joff], block_size_y, block_size_x, ioff, tmp_block_l0); 
  1153.     }
  1155. #if 0
  1156.     if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444) ) 
  1157.     {
  1158.       int uv;
  1160.       int ioff_cr = (img->mb_cr_size_x == MB_BLOCK_SIZE) ? ioff : ioff >> 1;
  1161.       int joff_cr = (img->mb_cr_size_y == MB_BLOCK_SIZE) ? joff : joff >> 1;
  1162.       int block_size_x_cr = img->mb_cr_size_x == MB_BLOCK_SIZE ? block_size_x : block_size_x >> 1;
  1163.       int block_size_y_cr = img->mb_cr_size_y == MB_BLOCK_SIZE ? block_size_y : block_size_y >> 1;
  1165.       vec1_y_cr = vec1_y + ((active_sps->chroma_format_idc == 1)? list[ref_idx]->chroma_vector_adjustment : 0);
  1167.       for(uv=0;uv<2;uv++)
  1168.       {
  1169.         get_block_chroma (uv, list[ref_idx], vec1_x, vec1_y_cr, block_size_x_cr, block_size_y_cr, img, tmp_block_l0);
  1171.         if (img->apply_weights)
  1172.         {
  1173.           alpha_l0  = img->wp_weight[pred_dir][ref_idx_wp][uv + 1];
  1174.           wp_offset = img->wp_offset[pred_dir][ref_idx_wp][uv + 1];
  1176.           weighted_mc_prediction(&img->mb_pred[uv + 1][joff_cr], block_size_y_cr, block_size_x_cr, ioff_cr, tmp_block_l0, alpha_l0, wp_offset, img->chroma_log2_weight_denom, img->max_imgpel_value_comp[uv + 1]);
  1177.         }
  1178.         else
  1179.         {
  1180.           mc_prediction(&img->mb_pred[uv + 1][joff_cr], block_size_y_cr, block_size_x_cr, ioff_cr, tmp_block_l0);
  1181.         }
  1182.       }
  1183.     }
  1184. #endif
  1185.   }
  1186.   else
  1187.   {
  1188. #if 0
  1189.     //===== BI-PREDICTION =====
  1190.     short ***l0_mv_array = dec_picture->motion.mv[LIST_0];
  1191.     short ***l1_mv_array = dec_picture->motion.mv[LIST_1];
  1193.     short l0_refframe = dec_picture->motion.ref_idx[LIST_0][j4][i4];
  1194.     short l1_refframe = dec_picture->motion.ref_idx[LIST_1][j4][i4];
  1195.     short l0_ref_idx  = l0_refframe;
  1196.     short l1_ref_idx  = l1_refframe;
  1198.     check_motion_vector_range(img, l0_mv_array[j4][i4][0], l0_mv_array[j4][i4][1]);
  1199.     check_motion_vector_range(img, l1_mv_array[j4][i4][0], l1_mv_array[j4][i4][1]);
  1200.     vec1_x = i4 * mv_mul + l0_mv_array[j4][i4][0];
  1201.     vec2_x = i4 * mv_mul + l1_mv_array[j4][i4][0];
  1203.     vec1_y = (img->block_y_aff + j) * mv_mul + l0_mv_array[j4][i4][1];
  1204.     vec2_y = (img->block_y_aff + j) * mv_mul + l1_mv_array[j4][i4][1];
  1206.     get_block_luma(pl, listX[LIST_0 + list_offset][l0_refframe], vec1_x, vec1_y, block_size_x, block_size_y, img, tmp_block_l0);  
  1207.     get_block_luma(pl, listX[LIST_1 + list_offset][l1_refframe], vec2_x, vec2_y, block_size_x, block_size_y, img, tmp_block_l1);  
  1209.     if(img->apply_weights)
  1210.     {
  1211.       int wt_list_offset = (active_pps->weighted_bipred_idc==2)? list_offset : 0;
  1213.       // This code existed in the original. Seems pointless but copying it here for reference and in case temporal direct breaks.
  1214.       // if (mv_mode==0 && img->direct_spatial_mv_pred_flag==0 ) l1_ref_idx=0;    
  1215.       if (((active_pps->weighted_pred_flag&&(img->type==P_SLICE|| img->type == SP_SLICE))||
  1216.         (active_pps->weighted_bipred_idc==1 && (img->type==B_SLICE))) && curr_mb_field)
  1217.       {
  1218.         l0_ref_idx >>=1;
  1219.         l1_ref_idx >>=1;
  1220.       }
  1222.       alpha_l0  =   img->wbp_weight[LIST_0 + wt_list_offset][l0_ref_idx][l1_ref_idx][0];
  1223.       alpha_l1  =   img->wbp_weight[LIST_1 + wt_list_offset][l0_ref_idx][l1_ref_idx][0];
  1224.       wp_offset = ((img->wp_offset [LIST_0 + wt_list_offset][l0_ref_idx][0] + img->wp_offset[LIST_1 + wt_list_offset][l1_ref_idx][0] + 1) >>1);
  1226.       weighted_bi_prediction(&img->mb_pred[pl][joff], tmp_block_l0, tmp_block_l1, block_size_y, block_size_x, ioff, alpha_l0, alpha_l1, wp_offset, (img->luma_log2_weight_denom + 1), max_imgpel_value);
  1227.     }
  1228.     else
  1229.     { 
  1230.       bi_prediction(&img->mb_pred[pl][joff], tmp_block_l0, tmp_block_l1, block_size_y, block_size_x, ioff); 
  1231.     }
  1233.     if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444) ) 
  1234.     {
  1235.       int uv;
  1237.       int ioff_cr = img->mb_cr_size_x == MB_BLOCK_SIZE ? ioff : ioff >> 1;
  1238.       int joff_cr = img->mb_cr_size_y == MB_BLOCK_SIZE ? joff : joff >> 1;
  1239.       int block_size_x_cr = img->mb_cr_size_x == MB_BLOCK_SIZE ? block_size_x : block_size_x >> 1;
  1240.       int block_size_y_cr = img->mb_cr_size_y == MB_BLOCK_SIZE ? block_size_y : block_size_y >> 1;
  1242.       vec1_y_cr = vec1_y + ((active_sps->chroma_format_idc == 1)? listX[LIST_0 + list_offset][l0_refframe]->chroma_vector_adjustment : 0);
  1243.       vec2_y_cr = vec2_y + ((active_sps->chroma_format_idc == 1)? listX[LIST_1 + list_offset][l1_refframe]->chroma_vector_adjustment : 0);
  1245.       for(uv=0;uv<2;uv++)
  1246.       {
  1247.         get_block_chroma (uv, listX[LIST_0 + list_offset][l0_refframe], vec1_x, vec1_y_cr, block_size_x_cr, block_size_y_cr, img, tmp_block_l0);
  1248.         get_block_chroma (uv, listX[LIST_1 + list_offset][l1_refframe], vec2_x, vec2_y_cr, block_size_x_cr, block_size_y_cr, img, tmp_block_l1);
  1250.         if(img->apply_weights)
  1251.         {
  1252.           int wt_list_offset = (active_pps->weighted_bipred_idc==2)? list_offset : 0;
  1254.           alpha_l0  =   img->wbp_weight[LIST_0 + wt_list_offset][l0_ref_idx][l1_ref_idx][uv + 1];
  1255.           alpha_l1  =   img->wbp_weight[LIST_1 + wt_list_offset][l0_ref_idx][l1_ref_idx][uv + 1];
  1256.           wp_offset = ((img->wp_offset [LIST_0 + wt_list_offset][l0_ref_idx][uv + 1] + img->wp_offset[LIST_1 + wt_list_offset][l1_ref_idx][uv + 1] + 1) >>1);
  1258.           weighted_bi_prediction(&img->mb_pred[uv+1][joff_cr], tmp_block_l0, tmp_block_l1, block_size_y_cr, block_size_x_cr, ioff_cr, alpha_l0, alpha_l1, wp_offset, (img->chroma_log2_weight_denom + 1), img->max_imgpel_value_comp[uv + 1]);
  1259.         }
  1260.         else
  1261.         {
  1262.           bi_prediction(&img->mb_pred[uv + 1][joff_cr], tmp_block_l0, tmp_block_l1, block_size_y_cr, block_size_x_cr, ioff_cr);
  1263.         }
  1264.       }
  1265.     }
  1266. #endif
  1267.   }
  1268. }
  1270. void perform_mc_concealment(int decoder, ColorPlane pl, StorablePicture *dec_picture, ImageParameters *img, int pred_dir, int i, int j, int block_size_x, int block_size_y)
  1271. {
  1272.   static int vec1_x=0, vec1_y=0;
  1273.   static const int mv_mul = 16; // 4 * 4
  1274.   
  1275.   int i4   = img->block_x + i;
  1276.   int j4   = img->block_y + j;
  1277.   int ioff = (i << 2);
  1278.   int joff = (j << 2);         
  1279.   
  1280.   assert (pred_dir<=2);
  1282.   if (pred_dir != 2)
  1283.   {
  1284.     //===== Single List Prediction =====
  1285.     short       ref_idx = dec_picture->motion.ref_idx[pred_dir][j4][i4];
  1286.     short      ***mv_array = dec_picture->motion.mv[pred_dir];
  1287.     StorablePicture **list = listX[pred_dir];
  1289.     vec1_x = i4 * mv_mul + mv_array[j4][i4][0];
  1290.     vec1_y = j4 * mv_mul + mv_array[j4][i4][1];
  1292.     get_block_luma (decoder, pl, dec_picture, list[ref_idx], vec1_x, vec1_y, block_size_x, block_size_y, img, tmp_block_l0); 
  1293.     mc_prediction(&img->mb_pred[pl][joff], block_size_y, block_size_x, ioff, tmp_block_l0); 
  1294.   }
  1295. }