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

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

Audio

开发平台：

Visual C++

mc_prediction.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file mc_prediction.c
  5.  *
  6.  * brief
  7.  *    Functions for motion compensated prediction
  8.  *
  9.  * author
  10.  *      Main contributors (see contributors.h for copyright, 
  11.  *                         address and affiliation details)
  12.  *      - Alexis Michael Tourapis  <alexismt@ieee.org>
  13.  *
  14.  *************************************************************************************
  15.  */
  16. #include "global.h"
  17. #include "block.h"
  18. #include "mc_prediction.h"
  19. #include "mbuffer.h"
  20. #include "mb_access.h"
  21. #include "macroblock.h"
  23. extern StorablePicture *no_reference_picture;
  25. imgpel tmp_block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE];     //!< l0 prediction
  26. imgpel tmp_block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE];     //!< l1 prediction
  28. static const int COEF[6] = { 1, -5, 20, 20, -5, 1 };
  29. /*!
  30.  ************************************************************************
  31.  * brief
  32.  *    block single list prediction
  33.  ************************************************************************
  34.  */
  35. static inline void mc_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  36.                     int ver_block_size, 
  37.                     int hor_block_size,
  38.                     int ioff,
  39.                     imgpel block[MB_BLOCK_SIZE][MB_BLOCK_SIZE])
  40. {
  41.   static int jj;
  43.   if (hor_block_size == MB_BLOCK_SIZE)
  44.   {
  45.     memcpy(&(mb_pred[0][ioff]), &(block[0][0]), hor_block_size * ver_block_size * sizeof(imgpel));
  46.   }
  47.   else
  48.   {
  49.     for(jj = 0; jj < ver_block_size; jj++)
  50.     {
  51.       memcpy(&(mb_pred[jj][ioff]), &(block[jj][0]), hor_block_size * sizeof(imgpel));
  52.     }
  53.   }
  54. }
  56. /*!
  57.  ************************************************************************
  58.  * brief
  59.  *    block single list weighted prediction
  60.  ************************************************************************
  61.  */
  62. static inline void weighted_mc_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  63.                             int ver_block_size, 
  64.                             int hor_block_size,
  65.                             int ioff,
  66.                             imgpel block[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  67.                             int wp_scale,
  68.                             int wp_offset,
  69.                             int weight_denom,
  70.                             int color_clip)
  71. {
  72.   static int ii, jj;
  73.   static imgpel *mpr, *b0;
  74.   
  75.   for(jj=0;jj<ver_block_size;jj++)
  76.   {
  77.     mpr = &mb_pred[jj][ioff];
  78.     b0 = block[jj];
  79.     for(ii=0;ii<hor_block_size;ii++)
  80.       *(mpr++) = (imgpel) iClip1(color_clip, (rshift_rnd((wp_scale * *(b0++)), weight_denom)  + wp_offset ));
  81.   }
  82. }
  85. /*!
  86.  ************************************************************************
  87.  * brief
  88.  *    block biprediction
  89.  ************************************************************************
  90.  */
  91. static inline void bi_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE],  
  92.                                  imgpel block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  93.                                  imgpel block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  94.                                  int ver_block_size, 
  95.                                  int hor_block_size,
  96.                                  int ioff)
  97. {
  98.   static int ii, jj;
  99.   static imgpel *mpr, *b0, *b1;
  101.   for(jj = 0;jj < ver_block_size;jj++)
  102.   {
  103.     mpr = &mb_pred[jj][ioff];
  104.     b0 = block_l0[jj];
  105.     b1 = block_l1[jj];
  106.     for(ii = 0; ii < hor_block_size;ii++)
  107.       *(mpr++) = (imgpel) rshift_rnd_sf((*(b0++) + *(b1++)), 1);
  108.   }
  109. }
  111. /*!
  112.  ************************************************************************
  113.  * brief
  114.  *    block weighted biprediction
  115.  ************************************************************************
  116.  */
  117. static inline void weighted_bi_prediction(imgpel mb_pred[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  118.                                           imgpel block_l0[MB_BLOCK_SIZE][MB_BLOCK_SIZE], 
  119.                                           imgpel block_l1[MB_BLOCK_SIZE][MB_BLOCK_SIZE],
  120.                                           int ver_block_size, 
  121.                                           int hor_block_size,
  122.                                           int ioff,
  123.                                           int wp_scale_l0,
  124.                                           int wp_scale_l1,
  125.                                           int wp_offset,
  126.                                           int weight_denom,
  127.                                           int color_clip)
  128. {
  129.   static int ii, jj;
  130.   static imgpel *mpr, *b0, *b1;
  131.   
  132.   for(jj = 0; jj < ver_block_size; jj++)
  133.   {
  134.     mpr = &mb_pred[jj][ioff];    
  135.     b0  = block_l0[jj];
  136.     b1  = block_l1[jj];
  138.     for(ii=0;ii<hor_block_size;ii++)
  139.       *(mpr++) = (imgpel) iClip1(color_clip, (rshift_rnd((wp_scale_l0 * *(b0++) + wp_scale_l1 * *(b1++)), weight_denom) + wp_offset));
  140.   }
  141. }
  143. /*!
  144.  ************************************************************************
  145.  * brief
  146.  *    Interpolation of 1/4 subpixel
  147.  ************************************************************************
  148.  */ 
  149. void get_block_luma(ColorPlane pl, 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])
  150. {
  151.   static int tmp_res[21][21];
  152.   static int *tmp_line;
  153.   static imgpel *p0, *p1, *p2, *p3, *p4, *p5;
  154.   static int    *x0, *x1, *x2, *x3, *x4, *x5;  
  155.   
  156.   static imgpel **cur_imgY, *cur_lineY;
  157.   static int ipos_m2, ipos_m1, ipos, ipos_p1, ipos_p2, ipos_p3;
  158.   static imgpel *orig_line;
  159.   int tmp_pos;
  161.   int dx = (x_pos & 3), dy = (y_pos & 3);
  162.   int i, j, jj;
  163.   int shift_x  = dec_picture->size_x;
  164.   int maxold_x = dec_picture->size_x_m1;
  165.   int maxold_y = (dec_picture->motion.mb_field[img->current_mb_nr]) ? (dec_picture->size_y >> 1) - 1 : dec_picture->size_y_m1;
  166.   int result;
  167.   int pres_x;
  168.   int max_imgpel_value = img->max_imgpel_value_comp[pl];
  171.   if (curr_ref == no_reference_picture && img->framepoc < img->recovery_poc)
  172.   {
  173.     printf("list[ref_frame] is equal to 'no reference picture' before RAPn");
  175.     /* fill the block with sample value 128 */
  176.     for (j = 0; j < ver_block_size; j++)
  177.       for (i = 0; i < hor_block_size; i++)
  178.         block[j][i] = 128;
  179.     return;
  180.   }
  182.   if( IS_INDEPENDENT(img) )
  183.   {
  184.     switch( img->colour_plane_id )
  185.     {
  186.     case    0:
  187.       cur_imgY = curr_ref->imgY;
  188.       break;
  189.     case    1:
  190.       cur_imgY = curr_ref->imgUV[0];
  191.       break;
  192.     case    2:
  193.       cur_imgY = curr_ref->imgUV[1];
  194.       break;
  195.     }
  196.   }
  197.   else if (pl==PLANE_Y)
  198.   {
  199.     cur_imgY = curr_ref->imgY;
  200.   }
  201.   else
  202.   {
  203.     cur_imgY = curr_ref->imgUV[pl-1]; 
  204.   }
  206.   x_pos = x_pos >> 2;
  207.   y_pos = y_pos >> 2;
  209.   if ( (y_pos > 1) && (y_pos < maxold_y - 2 - ver_block_size) && (x_pos > 1) && (x_pos < maxold_x - 2 - hor_block_size))
  210.   {
  211.     cur_imgY = &cur_imgY[ y_pos];
  212.     if (dx == 0 && dy == 0)
  213.     {  /* fullpel position */
  214.       for (j = 0; j < ver_block_size; j++)
  215.       {        
  216.         memcpy(&(block[j][0]), &(cur_imgY[j][x_pos]), hor_block_size * sizeof(imgpel));
  217.       }
  218.     }
  219.     else
  220.     { /* other positions */
  222.       if (dy == 0)
  223.       { /* No vertical interpolation */
  224.         for (j = 0; j < ver_block_size; j++)
  225.         {
  226.           p0 = &cur_imgY[j][x_pos - 2];
  227.           p1 = p0 + 1;
  228.           p2 = p1 + 1;
  229.           p3 = p2 + 1;
  230.           p4 = p3 + 1;
  231.           p5 = p4 + 1;
  232.           orig_line = block[j];
  234.           for (i = 0; i < hor_block_size; i++)
  235.           {        
  236.             result  = (*(p0++) + *(p5++)) * COEF[0]
  237.                     + (*(p1++) + *(p4++)) * COEF[1]
  238.                     + (*(p2++) + *(p3++)) * COEF[2];
  240.             *orig_line++ = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  241.           }
  242.         }
  244.         if ((dx&1) == 1)
  245.         {          
  246.           for (j = 0; j < ver_block_size; j++)
  247.           {
  248.             cur_lineY = &(cur_imgY[j][x_pos + (dx >> 1)]);
  249.             orig_line = block[j];
  250.             for (i = 0; i < hor_block_size; i++)
  251.             {
  252.               *orig_line = (imgpel) ((*orig_line + *(cur_lineY++) + 1 ) >> 1);
  253.               orig_line++;
  254.             }
  255.           }
  256.         }
  257.       }
  258.       else if (dx == 0)
  259.       {  /* No horizontal interpolation */        
  260.         p0 = &(cur_imgY[ - 2][x_pos]);
  261.         for (j = 0; j < ver_block_size; j++)
  262.         {                  
  263.           p1 = p0 + shift_x;          
  264.           p2 = p1 + shift_x;
  265.           p3 = p2 + shift_x;
  266.           p4 = p3 + shift_x;
  267.           p5 = p4 + shift_x;
  268.           orig_line = block[j];
  270.           for (i = 0; i < hor_block_size; i++)
  271.           {
  272.             result  = (*(p0++) + *(p5++)) * COEF[0]
  273.                     + (*(p1++) + *(p4++)) * COEF[1]
  274.                     + (*(p2++) + *(p3++)) * COEF[2];
  276.             *orig_line++ = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  277.           }
  278.           p0 = p1 - hor_block_size;
  279.         }
  281.         if ((dy&1) == 1)
  282.         {
  283.           jj = (dy >> 1);
  284.           for (j = 0; j < ver_block_size; j++)
  285.           {
  286.             cur_lineY = &(cur_imgY[jj++][x_pos]);
  287.             orig_line = block[j];
  288.             for (i = 0; i < hor_block_size; i++)
  289.             {
  290.               *orig_line = (imgpel) ((*orig_line + *(cur_lineY++) + 1 ) >> 1);
  291.               orig_line++;
  292.             }
  293.           }
  294.         }
  295.       }
  296.       else if (dx == 2)
  297.       {  /* Vertical & horizontal interpolation */
  298.         jj = - 2;
  299.         for (j = 0; j < ver_block_size + 5; j++)
  300.         {
  301.           p0 = &cur_imgY[jj++][x_pos - 2];
  302.           p1 = p0 + 1;
  303.           p2 = p1 + 1;
  304.           p3 = p2 + 1;
  305.           p4 = p3 + 1;
  306.           p5 = p4 + 1;
  307.           orig_line = block[j];
  308.           tmp_line  = tmp_res[j];
  310.           for (i = 0; i < hor_block_size; i++)
  311.           {        
  312.             *(tmp_line++) = (*(p0++) + *(p5++)) * COEF[0]
  313.                           + (*(p1++) + *(p4++)) * COEF[1]
  314.                           + (*(p2++) + *(p3++)) * COEF[2];
  315.           }
  316.         }
  318.         for (j = 0; j < ver_block_size; j++)
  319.         {
  320.           x0 = tmp_res[j    ];
  321.           x1 = tmp_res[j + 1];
  322.           x2 = tmp_res[j + 2];
  323.           x3 = tmp_res[j + 3];
  324.           x4 = tmp_res[j + 4];
  325.           x5 = tmp_res[j + 5];
  326.           orig_line = block[j];
  328.           for (i = 0; i < hor_block_size; i++)
  329.           {
  330.             result  = (*x0++ + *x5++) * COEF[0]
  331.                     + (*x1++ + *x4++) * COEF[1]
  332.                     + (*x2++ + *x3++) * COEF[2];
  334.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result+512)>>10));
  335.           }
  336.         }
  338.         if ((dy&1) == 1)
  339.         {
  340.           jj = 2 + (dy>>1);
  341.           for (j = 0; j < ver_block_size; j++)
  342.           {            
  343.             tmp_line  = tmp_res[jj++];
  344.             orig_line = block[j];
  345.             for (i = 0; i < hor_block_size; i++)
  346.             {
  347.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16) >> 5)) + 1 )>> 1);
  348.               orig_line++;
  349.             }
  350.           }
  351.         }
  352.       }
  353.       else if (dy == 2)
  354.       {  /* Horizontal & vertical interpolation */
  355.         p0 = &(cur_imgY[ -2][x_pos - 2]);
  356.         for (j = 0; j < ver_block_size; j++)
  357.         {                    
  358.           p1 = p0 + shift_x;
  359.           p2 = p1 + shift_x;
  360.           p3 = p2 + shift_x;
  361.           p4 = p3 + shift_x;
  362.           p5 = p4 + shift_x;
  363.           tmp_line  = tmp_res[j];
  365.           for (i = 0; i < hor_block_size + 5; i++)
  366.           {
  367.             *(tmp_line++)  = (*(p0++) + *(p5++)) * COEF[0]
  368.                            + (*(p1++) + *(p4++)) * COEF[1]
  369.                            + (*(p2++) + *(p3++)) * COEF[2];
  370.           }
  371.           p0 = p1 - (hor_block_size + 5);
  372.         }
  374.         for (j = 0; j < ver_block_size; j++)
  375.         {
  376.           orig_line = block[j];
  377.           x0 = tmp_res[j];
  378.           x1 = x0 + 1;
  379.           x2 = x1 + 1;
  380.           x3 = x2 + 1;
  381.           x4 = x3 + 1;
  382.           x5 = x4 + 1;
  384.           for (i = 0; i < hor_block_size; i++)
  385.           {
  386.             result  = (*(x0++) + *(x5++)) * COEF[0]
  387.                     + (*(x1++) + *(x4++)) * COEF[1]
  388.                     + (*(x2++) + *(x3++)) * COEF[2];
  390.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result + 512)>>10));
  391.           }
  392.         }
  394.         if ((dx&1) == 1)
  395.         {
  396.           for (j = 0; j < ver_block_size; j++)
  397.           {
  398.             tmp_line  = &tmp_res[j][2 + (dx>>1)];
  399.             orig_line = block[j];
  400.             for (i = 0; i < hor_block_size; i++)
  401.             {
  402.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16)>>5))+1)>>1);
  403.               orig_line ++;
  404.             }
  405.           }
  406.         }
  407.       }
  408.       else
  409.       {  /* Diagonal interpolation */
  410.         jj = (dy == 1 ? 0 : 1);
  412.         for (j = 0; j < ver_block_size; j++)
  413.         {
  414.           p0 = &cur_imgY[jj++][x_pos - 2];
  415.           p1 = p0 + 1;
  416.           p2 = p1 + 1;
  417.           p3 = p2 + 1;
  418.           p4 = p3 + 1;
  419.           p5 = p4 + 1;
  421.           orig_line = block[j];
  423.           for (i = 0; i < hor_block_size; i++)
  424.           {        
  425.             result  = (*(p0++) + *(p5++)) * COEF[0]
  426.                     + (*(p1++) + *(p4++)) * COEF[1]
  427.                     + (*(p2++) + *(p3++)) * COEF[2];
  429.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  430.           }
  431.         }
  433.         p0 = &(cur_imgY[-2][(dx == 1 ? x_pos : x_pos + 1)]);
  434.         for (j = 0; j < ver_block_size; j++)
  435.         {        
  436.           p1 = p0 + shift_x;
  437.           p2 = p1 + shift_x;
  438.           p3 = p2 + shift_x;
  439.           p4 = p3 + shift_x;
  440.           p5 = p4 + shift_x;
  441.           orig_line = block[j];
  443.           for (i = 0; i < hor_block_size; i++)
  444.           {
  445.             result  = (*(p0++) + *(p5++)) * COEF[0]
  446.                     + (*(p1++) + *(p4++)) * COEF[1]
  447.                     + (*(p2++) + *(p3++)) * COEF[2];
  449.             *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((result + 16) >> 5)) + 1) >> 1);
  450.             orig_line++;
  451.           }
  452.           p0 = p1 - hor_block_size ;
  453.         }      
  454.       }
  455.     }
  456.   }
  457.   else // unsafe positions
  458.   {
  459.     if (dx == 0 && dy == 0)
  460.     {  /* fullpel position */
  461.       for (j = 0; j < ver_block_size; j++)
  462.       {
  463.         cur_lineY = cur_imgY[iClip3(0, maxold_y, y_pos + j)];
  464.         orig_line = block[j];
  465.         for (i = 0; i < hor_block_size; i++)
  466.         {
  467.           *(orig_line++) = cur_lineY[iClip3(0, maxold_x, x_pos + i )];
  468.         }
  469.       }
  470.     }
  471.     else
  472.     { /* other positions */
  474.       if (dy == 0)
  475.       { /* No vertical interpolation */
  476.         tmp_pos = x_pos - 2;
  477.         for (i = 0; i < hor_block_size; i++)
  478.         {        
  479.           ipos_m2 = iClip3(0, maxold_x, tmp_pos++);
  480.           ipos_m1 = iClip3(0, maxold_x, tmp_pos++);
  481.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  482.           ipos_p1 = iClip3(0, maxold_x, tmp_pos++);
  483.           ipos_p2 = iClip3(0, maxold_x, tmp_pos++);
  484.           ipos_p3 = iClip3(0, maxold_x, tmp_pos  );
  485.           tmp_pos -= 4;          
  487.           for (j = 0; j < ver_block_size; j++)
  488.           {
  489.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos+j)];
  491.             result  = (cur_lineY[ipos_m2] + cur_lineY[ipos_p3]) * COEF[0];
  492.             result += (cur_lineY[ipos_m1] + cur_lineY[ipos_p2]) * COEF[1];
  493.             result += (cur_lineY[ipos   ] + cur_lineY[ipos_p1]) * COEF[2];
  495.             block[j][i] = (imgpel) iClip1(max_imgpel_value, ((result + 16)>>5));
  496.           }
  497.         }
  499.         if ((dx&1) == 1)
  500.         {
  501.           for (j = 0; j < ver_block_size; j++)
  502.           {
  503.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos+j)];
  504.             orig_line = block[j];
  505.             for (i = 0; i < hor_block_size; i++)
  506.             {
  507.               *orig_line = (imgpel) ((*orig_line + cur_lineY[iClip3(0, maxold_x, x_pos + i + (dx >> 1))] + 1 ) >> 1);
  508.               orig_line++;
  509.             }
  510.           }
  511.         }
  512.       }
  513.       else if (dx == 0)
  514.       {  /* No horizontal interpolation */
  515.         tmp_pos = y_pos - 2;
  516.         for (j = 0; j < ver_block_size; j++)
  517.         { 
  518.           p0 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  519.           p1 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  520.           p2 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  521.           p3 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  522.           p4 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  523.           p5 = cur_imgY[iClip3(0, maxold_y, tmp_pos  )];
  524.           
  525.           tmp_pos -= 4;
  526.           orig_line = block[j];
  528.           for (i = 0; i < hor_block_size; i++)
  529.           {
  530.             pres_x = iClip3(0,maxold_x,x_pos+i);
  532.             result  = (p0[pres_x] + p5[pres_x]) * COEF[0];
  533.             result += (p1[pres_x] + p4[pres_x]) * COEF[1];
  534.             result += (p2[pres_x] + p3[pres_x]) * COEF[2];
  535.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result+16)>>5));
  536.           }
  537.         }
  539.         if ((dy&1) == 1)
  540.         {
  541.           for (j = 0; j < ver_block_size; j++)
  542.           {
  543.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos+j+(dy>>1))];
  544.             orig_line = block[j];
  545.             for (i = 0; i < hor_block_size; i++)
  546.             {
  547.               *orig_line = (imgpel) ((*orig_line + cur_lineY[iClip3(0, maxold_x, x_pos + i)] + 1 ) >> 1);
  548.               orig_line++;
  549.             }
  550.           }
  551.         }
  552.       }
  553.       else if (dx == 2)
  554.       {  /* Vertical & horizontal interpolation */
  555.         tmp_pos = x_pos - 2;
  556.         for (i = 0; i < hor_block_size; i++)
  557.         {        
  558.           ipos_m2 = iClip3(0, maxold_x, tmp_pos++);
  559.           ipos_m1 = iClip3(0, maxold_x, tmp_pos++);
  560.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  561.           ipos_p1 = iClip3(0, maxold_x, tmp_pos++);
  562.           ipos_p2 = iClip3(0, maxold_x, tmp_pos++);
  563.           ipos_p3 = iClip3(0, maxold_x, tmp_pos  );
  564.           tmp_pos -= 4;
  566.           for (j = 0; j < ver_block_size + 5; j++)
  567.           {
  568.             cur_lineY = cur_imgY[iClip3(0,maxold_y,y_pos + j - 2)];
  570.             tmp_res[j][i]  = (cur_lineY[ipos_m2] + cur_lineY[ipos_p3]) * COEF[0];
  571.             tmp_res[j][i] += (cur_lineY[ipos_m1] + cur_lineY[ipos_p2]) * COEF[1];
  572.             tmp_res[j][i] += (cur_lineY[ipos   ] + cur_lineY[ipos_p1]) * COEF[2];
  573.           }
  574.         }
  576.         for (j = 0; j < ver_block_size; j++)
  577.         {
  578.           x0 = tmp_res[j    ];
  579.           x1 = tmp_res[j + 1];
  580.           x2 = tmp_res[j + 2];
  581.           x3 = tmp_res[j + 3];
  582.           x4 = tmp_res[j + 4];
  583.           x5 = tmp_res[j + 5];
  584.           orig_line = block[j];
  586.           for (i = 0; i < hor_block_size; i++)
  587.           {
  588.             result  = (*x0++ + *x5++) * COEF[0]
  589.                     + (*x1++ + *x4++) * COEF[1]
  590.                     + (*x2++ + *x3++) * COEF[2];
  592.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result+512)>>10));
  593.           }
  594.         }
  596.         if ((dy&1) == 1)
  597.         {
  598.           for (j = 0; j < ver_block_size; j++)
  599.           {
  600.             tmp_line  = tmp_res[j + 2 + (dy>>1)];            
  601.             orig_line = block[j];
  602.             for (i = 0; i < hor_block_size; i++)
  603.             {
  604.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16) >> 5)) + 1 )>>1);
  605.               orig_line++;
  606.             }
  607.           }
  608.         }
  609.       }
  610.       else if (dy == 2)
  611.       {  /* Horizontal & vertical interpolation */
  613.         tmp_pos = y_pos - 2;
  614.         for (j = 0; j < ver_block_size; j++)
  615.         {
  616.           p0 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  617.           p1 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  618.           p2 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  619.           p3 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  620.           p4 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  621.           p5 = cur_imgY[iClip3(0, maxold_y, tmp_pos  )];
  623.           tmp_pos -= 4;
  625.           for (i = 0; i < hor_block_size + 5; i++)
  626.           {
  627.             pres_x = iClip3(0,maxold_x, x_pos + i - 2);
  628.             result  = (p0[pres_x] + p5[pres_x])*COEF[0]
  629.                     + (p1[pres_x] + p4[pres_x])*COEF[1]
  630.                     + (p2[pres_x] + p3[pres_x])*COEF[2];
  631.             tmp_res[j][i] = result;
  632.           }
  633.         }
  635.         for (j = 0; j < ver_block_size; j++)
  636.         {
  637.           orig_line = block[j];
  638.           tmp_line  = tmp_res[j];
  639.           x0 = tmp_res[j];
  640.           x1 = x0 + 1;
  641.           x2 = x1 + 1;
  642.           x3 = x2 + 1;
  643.           x4 = x3 + 1;
  644.           x5 = x4 + 1;
  646.           for (i = 0; i < hor_block_size; i++)
  647.           {
  648.             result  = (*(x0++) + *(x5++)) * COEF[0]
  649.                     + (*(x1++) + *(x4++)) * COEF[1]
  650.                     + (*(x2++) + *(x3++)) * COEF[2];
  652.             *(orig_line++) = (imgpel) iClip1(max_imgpel_value, ((result + 512)>>10));
  653.           }
  654.         }
  656.         if ((dx&1) == 1)
  657.         {
  658.           for (j = 0; j < ver_block_size; j++)
  659.           {
  660.             tmp_line  = &tmp_res[j][2 + (dx>>1)];
  661.             orig_line = block[j];            
  662.             for (i = 0; i < hor_block_size; i++)
  663.             {
  664.               *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((*(tmp_line++) + 16)>>5)) + 1)>> 1);
  665.               orig_line++;
  666.             }
  667.           }
  668.         }
  669.       }
  670.       else
  671.       {  /* Diagonal interpolation */
  672.         tmp_pos = x_pos - 2;
  673.         for (i = 0; i < hor_block_size; i++)
  674.         {
  675.           ipos_m2 = iClip3(0, maxold_x, tmp_pos++);
  676.           ipos_m1 = iClip3(0, maxold_x, tmp_pos++);
  677.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  678.           ipos_p1 = iClip3(0, maxold_x, tmp_pos++);
  679.           ipos_p2 = iClip3(0, maxold_x, tmp_pos++);
  680.           ipos_p3 = iClip3(0, maxold_x, tmp_pos  );
  681.           tmp_pos -= 4;
  683.           for (j = 0; j < ver_block_size; j++)
  684.           {
  685.             cur_lineY = cur_imgY[iClip3(0,maxold_y,(dy == 1 ? y_pos+j : y_pos+j+1))];
  687.             result  = (cur_lineY[ipos_m2] + cur_lineY[ipos_p3]) * COEF[0];
  688.             result += (cur_lineY[ipos_m1] + cur_lineY[ipos_p2]) * COEF[1];
  689.             result += (cur_lineY[ipos   ] + cur_lineY[ipos_p1]) * COEF[2];
  691.             block[j][i] = (imgpel) iClip1(max_imgpel_value, ((result+16)>>5));
  692.           }
  693.         }
  695.         tmp_pos = y_pos - 2;
  696.         for (j = 0; j < ver_block_size; j++)
  697.         {      
  698.           p0 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  699.           p1 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  700.           p2 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  701.           p3 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  702.           p4 = cur_imgY[iClip3(0, maxold_y, tmp_pos++)];
  703.           p5 = cur_imgY[iClip3(0, maxold_y, tmp_pos  )];
  705.           tmp_pos -= 4;
  706.           orig_line = block[j];
  708.           for (i = 0; i < hor_block_size; i++)
  709.           {
  710.             pres_x = dx == 1 ? x_pos+i : x_pos+i+1;
  711.             pres_x = iClip3(0, maxold_x, pres_x);
  713.             result  = (p0[pres_x] + p5[pres_x]) * COEF[0];
  714.             result += (p1[pres_x] + p4[pres_x]) * COEF[1];
  715.             result += (p2[pres_x] + p3[pres_x]) * COEF[2];
  717.             *orig_line = (imgpel) ((*orig_line + iClip1(max_imgpel_value, ((result+16)>>5)) + 1 ) >> 1);
  718.             orig_line++;
  719.           }
  720.         }      
  721.       }
  722.     }
  723.   }
  724. }
  726. void get_block_chroma(int uv, 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])
  727. {
  728.   int subpel_x    = img->mb_cr_size_x == 8 ? 7 : 3;
  729.   int subpel_y    = img->mb_cr_size_y == 8 ? 7 : 3;
  730.   int shiftpel_x  = img->mb_cr_size_x == 8 ? 3 : 2;
  731.   int shiftpel_y  = img->mb_cr_size_y == 8 ? 3 : 2;
  732.   int total_scale = shiftpel_x + shiftpel_y;
  734.   int dx = (x_pos & subpel_x);
  735.   int dy = (y_pos & subpel_y);
  736.   int dxcur = (subpel_x + 1 - dx);
  737.   int dycur = (subpel_y + 1 - dy);
  739.   int w00 = dxcur * dycur;
  740.   int w01 = dxcur * dy;
  741.   int w10 = dx * dycur;
  742.   int w11 = dx * dy;
  744.   int i, j;
  745.   int maxold_x = dec_picture->size_x_cr_m1;
  746.   int maxold_y = (dec_picture->motion.mb_field[img->current_mb_nr]) ? (dec_picture->size_y_cr >> 1) - 1 : dec_picture->size_y_cr_m1;
  747.   int result;
  748.   
  749.   static imgpel **cur_img, *blk_line;
  750.   static imgpel *cur_line, *cur_line_p1;
  751.   int tmp_pos;
  752.   static int ipos, ipos_p1;
  753.   int    max_imgpel_value = img->max_imgpel_value_comp[uv + 1];
  756.   if (curr_ref == no_reference_picture && img->framepoc < img->recovery_poc)
  757.   {
  758.     printf("list[ref_frame] is equal to 'no reference picture' before RAPn");
  760.     /* fill the block with sample value 128 */
  761.     for (j = 0; j < ver_block_size; j++)
  762.       for (i = 0; i < hor_block_size; i++)
  763.         block[j][i] = 128;
  764.     return;
  765.   }
  767.   cur_img = curr_ref->imgUV[uv];
  769.   x_pos = x_pos >> shiftpel_x;
  770.   y_pos = y_pos >> shiftpel_y;
  772.   if ((y_pos >= 0) && (y_pos < maxold_y - ver_block_size) && (x_pos >= 0) && (x_pos < maxold_x - hor_block_size))
  773.   {
  774.     if (dx == 0 && dy == 0)
  775.     {  /* fullpel position */
  776.       for (j = 0; j < ver_block_size; j++)
  777.       {        
  778.         memcpy(&(block[j][0]), &(cur_img[ y_pos + j ][x_pos]), hor_block_size * sizeof(imgpel));
  779.       }
  780.     }
  781.     else if (dx == 0)
  782.     { 
  783.       for (j = 0; j < ver_block_size; j++)
  784.       {
  785.         cur_line    = &cur_img[y_pos + j    ][x_pos];
  786.         cur_line_p1 = &cur_img[y_pos + j + 1][x_pos];
  787.         blk_line = block[j];
  789.         for (i = 0; i < hor_block_size; i++)
  790.         {
  791.           result = (w00 * *cur_line++ + w01 * *cur_line_p1++);
  792.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  793.         }
  794.       }
  795.     }
  796.     else if (dy == 0)
  797.     { 
  798.       for (j = 0; j < ver_block_size; j++)
  799.       {
  800.         cur_line    = &cur_img[y_pos + j][x_pos];
  801.         cur_line_p1 = cur_line + 1;
  802.         blk_line = block[j];
  804.         for (i = 0; i < hor_block_size; i++)
  805.         {
  806.           result = (w00 * *cur_line++ + w10 * *cur_line_p1++);
  807.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  808.         }
  809.       }
  810.     }
  811.     else
  812.     { /* other positions */
  813.       for (j = 0; j < ver_block_size; j++)
  814.       {
  815.         cur_line    = &cur_img[y_pos + j    ][x_pos];
  816.         cur_line_p1 = &cur_img[y_pos + j + 1][x_pos];
  817.         blk_line = block[j];
  819.         for (i = 0; i < hor_block_size; i++)
  820.         {
  821.           result  = (w00 * *(cur_line++) + w01 * *(cur_line_p1++));
  822.           result += (w10 * *(cur_line  ) + w11 * *(cur_line_p1  ));
  823.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  824.         }
  825.       }
  826.     }
  827.   }
  828.   else // unsafe positions
  829.   {
  830.     if (dx == 0 && dy == 0)
  831.     {  /* fullpel position */
  832.       for (j = 0; j < ver_block_size; j++)
  833.       {
  834.         cur_line = cur_img[iClip3(0, maxold_y, y_pos + j)];
  835.         blk_line = block[j];
  836.         for (i = 0; i < hor_block_size; i++)
  837.         {
  838.           *(blk_line++) = cur_line[iClip3(0, maxold_x, x_pos + i )];
  839.         }
  840.       }
  841.     }
  842.     else if (dx == 0)
  843.     { 
  844.       for (j = 0; j < ver_block_size; j++)
  845.       {
  846.         cur_line    = cur_img[iClip3(0, maxold_y, y_pos + j)];
  847.         cur_line_p1 = cur_img[iClip3(0, maxold_y, y_pos + j + 1)];
  848.         tmp_pos = x_pos;
  849.         blk_line = block[j];
  851.         for (i = 0; i < hor_block_size; i++)
  852.         {
  853.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  855.           result = (w00 * cur_line[ipos] + w01 * cur_line_p1[ipos]);
  856.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  857.         }
  858.       }      
  859.     }
  860.     else if (dy == 0)
  861.     { 
  862.       for (j = 0; j < ver_block_size; j++)
  863.       {
  864.         cur_line    = cur_img[iClip3(0, maxold_y, y_pos + j)];
  865.         tmp_pos = x_pos;
  866.         blk_line = block[j];
  868.         for (i = 0; i < hor_block_size; i++)
  869.         {
  870.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  871.           ipos_p1 = iClip3(0, maxold_x, tmp_pos  );
  873.           result = (w00 * cur_line[ipos   ] + w10 * cur_line[ipos_p1]);
  874.           *(blk_line++) = (imgpel)iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  875.         }
  876.       }      
  877.     }
  878.     else
  879.     { /* other positions */ 
  880.       for (j = 0; j < ver_block_size; j++)
  881.       {
  882.         cur_line    = cur_img[iClip3(0, maxold_y, y_pos + j)];
  883.         cur_line_p1 = cur_img[iClip3(0, maxold_y, y_pos + j + 1)];
  884.         tmp_pos = x_pos;
  885.         blk_line = block[j];
  887.         for (i = 0; i < hor_block_size; i++)
  888.         {
  889.           ipos    = iClip3(0, maxold_x, tmp_pos++);
  890.           ipos_p1 = iClip3(0, maxold_x, tmp_pos  );
  892.           result = (
  893.             w00 * cur_line   [ipos   ] + 
  894.             w10 * cur_line   [ipos_p1] +
  895.             w01 * cur_line_p1[ipos   ] +
  896.             w11 * cur_line_p1[ipos_p1]);
  897.           *(blk_line++) = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf(result, total_scale));
  898.         }
  899.       }      
  900.     }
  901.   }
  902. }
  905. void intra_cr_decoding(Macroblock *currMB, int yuv, ImageParameters *img, int smb)
  906. {
  907.   imgpel **curUV, *cur_img;
  908.   int (*m7UV)[16], *m7;
  909.   int uv;
  910.   int b8,b4;
  911.   int ioff, joff, ii, jj;
  913.   for(uv = 0; uv < 2; uv++)
  914.   {
  915.     Boolean lossless_qpprime = (Boolean) ((img->lossless_qpprime_flag == 1) &&((img->qp + dec_picture->chroma_qp_offset[uv] + img->bitdepth_chroma_qp_scale) == 0));
  916.     itrans_4x4 = (!lossless_qpprime) ? itrans4x4 : itrans4x4_ls;
  918.     curUV = dec_picture->imgUV[uv];
  919.     m7UV  = img->mb_rres[uv+1];
  920.     intrapred_chroma(img, currMB, uv);
  922.     if (!smb && (currMB->cbp >> 4))
  923.     {
  924.       for (b8 = 0; b8 < (img->num_uv_blocks); b8++)
  925.       {
  926.         for(b4 = 0; b4 < 4; b4++)
  927.         {
  928.           joff = subblk_offset_y[yuv][b8][b4];          
  929.           ioff = subblk_offset_x[yuv][b8][b4];          
  931.           itrans_4x4(img, (ColorPlane) (uv + 1), ioff, joff);
  933.           for(jj=joff; jj<joff + 4;jj++)
  934.           {
  935.             cur_img = &curUV[img->pix_c_y+jj][img->pix_c_x + ioff];
  936.             m7 = &m7UV[jj][ioff];
  938.             for(ii=0; ii<4;ii++)
  939.             {
  940.               *cur_img++ = (imgpel) *m7++;
  941.             }
  942.           }
  943.         }
  944.       }
  945.     }
  946.     else if ((currMB->cbp >> 4) == 0)
  947.     {
  948.       for (b8 = 0; b8 < (img->num_uv_blocks); b8++)
  949.       {
  950.         for(b4 = 0; b4 < 4; b4++)
  951.         {
  952.           joff = subblk_offset_y[yuv][b8][b4];
  953.           ioff = subblk_offset_x[yuv][b8][b4];          
  955.           for(jj = joff; jj < 4 + joff;jj++)
  956.             memcpy(&(curUV[img->pix_c_y + jj][img->pix_c_x + ioff]), &(img->mb_pred[uv + 1][jj][ioff]), BLOCK_SIZE * sizeof(imgpel));
  957.         }
  958.       }
  959.     }
  960.     else
  961.     {
  962.       itrans_sp_cr(img, uv);
  964.       for (joff  = 0; joff < 8; joff += 4)
  965.       {
  966.         for(ioff = 0; ioff < 8;ioff+=4)
  967.         {          
  968.           itrans_4x4(img, (ColorPlane) (uv + 1), ioff, joff);
  970.           for(jj = joff; jj < joff + 4; jj++)
  971.             for(ii = ioff; ii < ioff + 4; ii++)
  972.             {
  973.               curUV[img->pix_c_y+jj][ii + img->pix_c_x] = (imgpel) img->mb_rres[uv+1][jj][ii];
  974.             }
  975.         }
  976.       }
  977.     }
  978.   }
  979. }
  981. void prepare_direct_params(Macroblock *currMB, StorablePicture *dec_picture, ImageParameters *img, short pmvl0[2], short pmvl1[2],char *l0_rFrame, char *l1_rFrame)
  982. {
  983.   char l0_rFrameL, l0_rFrameU, l0_rFrameUL, l0_rFrameUR;
  984.   char l1_rFrameL, l1_rFrameU, l1_rFrameUL, l1_rFrameUR;
  985.   
  986.   PixelPos mb_left, mb_up, mb_upleft, mb_upright;
  988.   get4x4Neighbour(currMB, -1,  0, img->mb_size[IS_LUMA], &mb_left);
  989.   get4x4Neighbour(currMB,  0, -1, img->mb_size[IS_LUMA], &mb_up);
  990.   get4x4Neighbour(currMB, 16, -1, img->mb_size[IS_LUMA], &mb_upright);
  991.   get4x4Neighbour(currMB, -1, -1, img->mb_size[IS_LUMA], &mb_upleft);
  993.   if (!img->MbaffFrameFlag)
  994.   {
  995.     l0_rFrameL  = (char) (mb_left.available    ? dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x]       : -1);
  996.     l0_rFrameU  = (char) (mb_up.available      ? dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x]           : -1);
  997.     l0_rFrameUL = (char) (mb_upleft.available  ? dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x]   : -1);
  998.     l0_rFrameUR = (char) (mb_upright.available ? dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] : l0_rFrameUL);
  1000.     l1_rFrameL  = (char) (mb_left.available     ? dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x]      : -1);
  1001.     l1_rFrameU  = (char) (mb_up.available       ? dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x]          : -1);
  1002.     l1_rFrameUL = (char) (mb_upleft.available  ? dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x]   : -1);
  1003.     l1_rFrameUR = (char) (mb_upright.available ? dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] : l1_rFrameUL);
  1004.   }
  1005.   else
  1006.   {
  1007.     if (currMB->mb_field)
  1008.     {
  1009.       l0_rFrameL = (char) (mb_left.available 
  1010.         ? 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
  1011.         ? dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] 
  1012.         : dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] * 2: -1);
  1014.       l0_rFrameU = (char) (mb_up.available 
  1015.         ? 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
  1016.         ? dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] 
  1017.         : dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] * 2: -1);
  1019.        l0_rFrameUL = (char) (mb_upleft.available 
  1020.          ? 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
  1021.          ? dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] 
  1022.          : dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] *2: -1);
  1024.        l0_rFrameUR = (char) (mb_upright.available 
  1025.          ? 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 
  1026.          ? dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] 
  1027.          : dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] * 2: l0_rFrameUL);
  1029.        l1_rFrameL = (char) (mb_left.available 
  1030.          ? 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 
  1031.          ? dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] 
  1032.          : dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] * 2: -1);
  1034.        l1_rFrameU = (char) (mb_up.available 
  1035.          ? 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 
  1036.          ? dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] 
  1037.          : dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] * 2: -1);
  1039.        l1_rFrameUL = (char) (mb_upleft.available 
  1040.          ? 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 
  1041.          ? dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] 
  1042.          : dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] *2 : -1);
  1044.        l1_rFrameUR = (char) (mb_upright.available 
  1045.          ? 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
  1046.          ? dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] 
  1047.          : dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] * 2: l1_rFrameUL);
  1048.     }
  1049.     else
  1050.     {
  1051.       l0_rFrameL = (char) (mb_left.available 
  1052.         ? 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 
  1053.         ? dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x] >> 1 
  1054.         : dec_picture->motion.ref_idx[LIST_0][mb_left.pos_y][mb_left.pos_x]: -1);
  1056.       l0_rFrameU = (char) (mb_up.available 
  1057.         ? 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 
  1058.         ? dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] >> 1 
  1059.         : dec_picture->motion.ref_idx[LIST_0][mb_up.pos_y][mb_up.pos_x] : -1);
  1061.       l0_rFrameUL = (char) (mb_upleft.available 
  1062.         ? 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 
  1063.         ? dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x]>> 1 
  1064.         : dec_picture->motion.ref_idx[LIST_0][mb_upleft.pos_y][mb_upleft.pos_x] : -1);
  1066.       l0_rFrameUR = (char) (mb_upright.available 
  1067.         ? 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 
  1068.         ? dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] >> 1 
  1069.         : dec_picture->motion.ref_idx[LIST_0][mb_upright.pos_y][mb_upright.pos_x] : l0_rFrameUL);
  1071.       l1_rFrameL = (char) (mb_left.available 
  1072.         ? 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 
  1073.         ? dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] >> 1 
  1074.         : dec_picture->motion.ref_idx[LIST_1][mb_left.pos_y][mb_left.pos_x] : -1);
  1076.       l1_rFrameU = (char) (mb_up.available 
  1077.         ? 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 
  1078.         ? dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] >> 1 
  1079.         : dec_picture->motion.ref_idx[LIST_1][mb_up.pos_y][mb_up.pos_x] : -1);
  1081.       l1_rFrameUL = (char) (mb_upleft.available 
  1082.         ? 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 
  1083.         ? dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] >> 1 
  1084.         : dec_picture->motion.ref_idx[LIST_1][mb_upleft.pos_y][mb_upleft.pos_x] : -1);
  1086.       l1_rFrameUR = (char) (mb_upright.available 
  1087.         ? 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 
  1088.         ? dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] >> 1
  1089.         : dec_picture->motion.ref_idx[LIST_1][mb_upright.pos_y][mb_upright.pos_x] : l1_rFrameUL);
  1090.     }
  1091.   }
  1093.   *l0_rFrame = (char) ((l0_rFrameL >= 0 && l0_rFrameU >= 0)  ? imin(l0_rFrameL,l0_rFrameU) : imax(l0_rFrameL,l0_rFrameU));
  1094.   *l0_rFrame = (char) ((*l0_rFrame >= 0 && l0_rFrameUR >= 0) ? imin(*l0_rFrame,l0_rFrameUR): imax(*l0_rFrame,l0_rFrameUR));
  1096.   *l1_rFrame = (char) ((l1_rFrameL >= 0 && l1_rFrameU >= 0)  ? imin(l1_rFrameL,l1_rFrameU) : imax(l1_rFrameL,l1_rFrameU));
  1097.   *l1_rFrame = (char) ((*l1_rFrame >= 0 && l1_rFrameUR >= 0) ? imin(*l1_rFrame,l1_rFrameUR): imax(*l1_rFrame,l1_rFrameUR));
  1099.   if (*l0_rFrame >=0)
  1100.     SetMotionVectorPredictor (img, currMB, pmvl0, *l0_rFrame, LIST_0, dec_picture->motion.ref_idx, dec_picture->motion.mv, 0, 0, 16, 16);
  1102.   if (*l1_rFrame >=0)
  1103.     SetMotionVectorPredictor (img, currMB, pmvl1, *l1_rFrame, LIST_1, dec_picture->motion.ref_idx, dec_picture->motion.mv, 0, 0, 16, 16);
  1104. }
  1106. void check_motion_vector_range(ImageParameters *img, short mv_x, short mv_y)
  1107. {
  1108.   if (mv_x > 8191 || mv_x < -8192)
  1109.   {
  1110.     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);
  1111.     error("invalid stream: too big horizontal motion vector", 500);
  1112.   }
  1114.   if (mv_y > (img->max_mb_vmv_r - 1) || mv_y < (-img->max_mb_vmv_r))
  1115.   {
  1116.     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);
  1117.     error("invalid stream: too big vertical motion vector", 500);
  1118.   }
  1119. }
  1121. void perform_mc(ColorPlane pl, StorablePicture *dec_picture, ImageParameters *img, int pred_dir, int i, int j, int list_offset, int block_size_x, int block_size_y, int curr_mb_field)
  1122. {
  1123.   static int vec1_x=0, vec1_y=0, vec2_x=0, vec2_y=0;
  1124.   static int vec1_y_cr = 0, vec2_y_cr = 0;
  1125.   static int alpha_l0, alpha_l1, wp_offset;
  1126.   static const int mv_mul = 16; // 4 * 4
  1127.   int        max_imgpel_value = img->max_imgpel_value_comp[pl];
  1128.   
  1129.   int i4   = img->block_x + i;
  1130.   int j4   = img->block_y + j;
  1131.   int ioff = (i << 2);
  1132.   int joff = (j << 2);         
  1133.   
  1134.   assert (pred_dir<=2);
  1136.   if (pred_dir != 2)
  1137.   {
  1138.     //===== Single List Prediction =====
  1139.     short       ref_idx = dec_picture->motion.ref_idx[pred_dir][j4][i4];
  1140.     short       ref_idx_wp = ref_idx;
  1141.     short      ***mv_array = dec_picture->motion.mv[pred_dir];
  1142.     StorablePicture **list = listX[list_offset + pred_dir];
  1144.     check_motion_vector_range(img, mv_array[j4][i4][0], mv_array[j4][i4][1]);
  1146.     vec1_x = i4 * mv_mul + mv_array[j4][i4][0];
  1147.     vec1_y = (img->block_y_aff + j) * mv_mul + mv_array[j4][i4][1];
  1149.     get_block_luma (pl, list[ref_idx], vec1_x, vec1_y, block_size_x, block_size_y, img, tmp_block_l0); 
  1151.     if (img->apply_weights)
  1152.     {
  1153.       if (curr_mb_field && ((active_pps->weighted_pred_flag&&(img->type==P_SLICE|| img->type == SP_SLICE))||
  1154.          (active_pps->weighted_bipred_idc==1 && (img->type==B_SLICE))))
  1155.       {
  1156.         ref_idx_wp >>=1;
  1157.       }
  1159.       alpha_l0  = img->wp_weight[pred_dir][ref_idx_wp][0];
  1160.       wp_offset = img->wp_offset[pred_dir][ref_idx_wp][0];
  1162.       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);
  1163.     }
  1164.     else
  1165.     {
  1166.       mc_prediction(&img->mb_pred[pl][joff], block_size_y, block_size_x, ioff, tmp_block_l0); 
  1167.     }
  1169.     if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444) ) 
  1170.     {
  1171.       int uv;
  1173.       int ioff_cr = (img->mb_cr_size_x == MB_BLOCK_SIZE) ? ioff : ioff >> 1;
  1174.       int joff_cr = (img->mb_cr_size_y == MB_BLOCK_SIZE) ? joff : joff >> 1;
  1175.       int block_size_x_cr = img->mb_cr_size_x == MB_BLOCK_SIZE ? block_size_x : block_size_x >> 1;
  1176.       int block_size_y_cr = img->mb_cr_size_y == MB_BLOCK_SIZE ? block_size_y : block_size_y >> 1;
  1178.       vec1_y_cr = vec1_y + ((active_sps->chroma_format_idc == 1)? list[ref_idx]->chroma_vector_adjustment : 0);
  1180.       for(uv=0;uv<2;uv++)
  1181.       {
  1182.         get_block_chroma (uv, list[ref_idx], vec1_x, vec1_y_cr, block_size_x_cr, block_size_y_cr, img, tmp_block_l0);
  1184.         if (img->apply_weights)
  1185.         {
  1186.           alpha_l0  = img->wp_weight[pred_dir][ref_idx_wp][uv + 1];
  1187.           wp_offset = img->wp_offset[pred_dir][ref_idx_wp][uv + 1];
  1189.           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]);
  1190.         }
  1191.         else
  1192.         {
  1193.           mc_prediction(&img->mb_pred[uv + 1][joff_cr], block_size_y_cr, block_size_x_cr, ioff_cr, tmp_block_l0);
  1194.         }
  1195.       }
  1196.     }
  1197.   }
  1198.   else
  1199.   {
  1200.     //===== BI-PREDICTION =====
  1201.     short ***l0_mv_array = dec_picture->motion.mv[LIST_0];
  1202.     short ***l1_mv_array = dec_picture->motion.mv[LIST_1];
  1204.     short l0_refframe = dec_picture->motion.ref_idx[LIST_0][j4][i4];
  1205.     short l1_refframe = dec_picture->motion.ref_idx[LIST_1][j4][i4];
  1206.     short l0_ref_idx  = l0_refframe;
  1207.     short l1_ref_idx  = l1_refframe;
  1209.     check_motion_vector_range(img, l0_mv_array[j4][i4][0], l0_mv_array[j4][i4][1]);
  1210.     check_motion_vector_range(img, l1_mv_array[j4][i4][0], l1_mv_array[j4][i4][1]);
  1211.     vec1_x = i4 * mv_mul + l0_mv_array[j4][i4][0];
  1212.     vec2_x = i4 * mv_mul + l1_mv_array[j4][i4][0];
  1214.     vec1_y = (img->block_y_aff + j) * mv_mul + l0_mv_array[j4][i4][1];
  1215.     vec2_y = (img->block_y_aff + j) * mv_mul + l1_mv_array[j4][i4][1];
  1217.     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);  
  1218.     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);  
  1220.     if(img->apply_weights)
  1221.     {
  1222.       int wt_list_offset = (active_pps->weighted_bipred_idc==2)? list_offset : 0;
  1224.       // This code existed in the original. Seems pointless but copying it here for reference and in case temporal direct breaks.
  1225.       // if (mv_mode==0 && img->direct_spatial_mv_pred_flag==0 ) l1_ref_idx=0;    
  1226.       if (((active_pps->weighted_pred_flag&&(img->type==P_SLICE|| img->type == SP_SLICE))||
  1227.         (active_pps->weighted_bipred_idc==1 && (img->type==B_SLICE))) && curr_mb_field)
  1228.       {
  1229.         l0_ref_idx >>=1;
  1230.         l1_ref_idx >>=1;
  1231.       }
  1233.       alpha_l0  =   img->wbp_weight[LIST_0 + wt_list_offset][l0_ref_idx][l1_ref_idx][0];
  1234.       alpha_l1  =   img->wbp_weight[LIST_1 + wt_list_offset][l0_ref_idx][l1_ref_idx][0];
  1235.       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);
  1237.       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);
  1238.     }
  1239.     else
  1240.     { 
  1241.       bi_prediction(&img->mb_pred[pl][joff], tmp_block_l0, tmp_block_l1, block_size_y, block_size_x, ioff); 
  1242.     }
  1244.     if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444) ) 
  1245.     {
  1246.       int uv;
  1248.       int ioff_cr = img->mb_cr_size_x == MB_BLOCK_SIZE ? ioff : ioff >> 1;
  1249.       int joff_cr = img->mb_cr_size_y == MB_BLOCK_SIZE ? joff : joff >> 1;
  1250.       int block_size_x_cr = img->mb_cr_size_x == MB_BLOCK_SIZE ? block_size_x : block_size_x >> 1;
  1251.       int block_size_y_cr = img->mb_cr_size_y == MB_BLOCK_SIZE ? block_size_y : block_size_y >> 1;
  1253.       vec1_y_cr = vec1_y + ((active_sps->chroma_format_idc == 1)? listX[LIST_0 + list_offset][l0_refframe]->chroma_vector_adjustment : 0);
  1254.       vec2_y_cr = vec2_y + ((active_sps->chroma_format_idc == 1)? listX[LIST_1 + list_offset][l1_refframe]->chroma_vector_adjustment : 0);
  1256.       for(uv=0;uv<2;uv++)
  1257.       {
  1258.         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);
  1259.         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);
  1261.         if(img->apply_weights)
  1262.         {
  1263.           int wt_list_offset = (active_pps->weighted_bipred_idc==2)? list_offset : 0;
  1265.           alpha_l0  =   img->wbp_weight[LIST_0 + wt_list_offset][l0_ref_idx][l1_ref_idx][uv + 1];
  1266.           alpha_l1  =   img->wbp_weight[LIST_1 + wt_list_offset][l0_ref_idx][l1_ref_idx][uv + 1];
  1267.           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);
  1269.           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]);
  1270.         }
  1271.         else
  1272.         {
  1273.           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);
  1274.         }
  1275.       }
  1276.     }      
  1277.   }
  1278. }