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

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

Audio

开发平台：

Visual C++

mc_prediction.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file mc_prediction.c
  5.  *
  6.  * brief
  7.  *    Motion Compensation
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Alexis Michael Tourapis         <alexismt@ieee.org>
  12.  *
  13.  *************************************************************************************
  14.  */
  16. #include "contributors.h"
  18. #include <stdlib.h>
  19. #include <assert.h>
  20. #include <limits.h>
  21. #include <memory.h>
  22. #include <math.h>
  24. #include "global.h"
  26. #include "macroblock.h"
  27. #include "mc_prediction.h"
  28. #include "refbuf.h"
  29. #include "image.h"
  30. #include "mb_access.h"
  32. static int diff  [16];
  33. static imgpel l0_pred[MB_PIXELS];
  34. static imgpel l1_pred[MB_PIXELS];
  37. static const unsigned char subblk_offset_x[3][8][4] =
  38. {
  39.   { 
  40.     {0, 4, 0, 4},
  41.     {0, 4, 0, 4},
  42.     {0, 0, 0, 0},
  43.     {0, 0, 0, 0},
  44.     {0, 0, 0, 0},
  45.     {0, 0, 0, 0},
  46.     {0, 0, 0, 0},
  47.     {0, 0, 0, 0}, 
  48.   },
  49.   { 
  50.     {0, 4, 0, 4},
  51.     {0, 4, 0, 4},
  52.     {0, 4, 0, 4},
  53.     {0, 4, 0, 4},
  54.     {0, 0, 0, 0},
  55.     {0, 0, 0, 0},
  56.     {0, 0, 0, 0},
  57.     {0, 0, 0, 0}, 
  58.   },
  59.   { 
  60.     {0, 4, 0, 4},
  61.     {8,12, 8,12},
  62.     {0, 4, 0, 4},
  63.     {8,12, 8,12},
  64.     {0, 4, 0, 4},
  65.     {8,12, 8,12},
  66.     {0, 4, 0, 4},
  67.     {8,12, 8,12}  
  68.   }
  69. };
  71. static const unsigned char subblk_offset_y[3][8][4] =
  72. {
  73.   { 
  74.     {0, 0, 4, 4},
  75.     {0, 0, 4, 4},
  76.     {0, 0, 0, 0},
  77.     {0, 0, 0, 0},
  78.     {0, 0, 0, 0},
  79.     {0, 0, 0, 0},
  80.     {0, 0, 0, 0},
  81.     {0, 0, 0, 0}, 
  82.   },
  83.   { 
  84.     {0, 0, 4, 4},
  85.     {8, 8,12,12},
  86.     {0, 0, 4, 4},
  87.     {8, 8,12,12},
  88.     {0, 0, 0, 0},
  89.     {0, 0, 0, 0},
  90.     {0, 0, 0, 0},
  91.     {0, 0, 0, 0},
  92.   },
  93.   {
  94.     {0, 0, 4, 4},
  95.     {0, 0, 4, 4},
  96.     {8, 8,12,12},
  97.     {8, 8,12,12},
  98.     {0, 0, 4, 4},
  99.     {0, 0, 4, 4},
  100.     {8, 8,12,12},
  101.     {8, 8,12,12} 
  102.   }
  103. };
  105. /*!
  106.  ************************************************************************
  107.  * brief
  108.  *    Predict Luma block
  109.  ************************************************************************
  110.  */
  111. static inline void OneComponentLumaPrediction ( imgpel*   mpred,       //!< array of prediction values (row by row)
  112.                                                int    pic_pix_x,      //!< motion shifted horizontal coordinate of block
  113.                                                int    pic_pix_y,      //!< motion shifted vertical   coordinate of block
  114.                                                int    block_size_x,   //!< horizontal block size
  115.                                                int    block_size_y,   //!< vertical block size
  116.                                                StorablePicture *list //!< reference picture list
  117.                                                )
  118. {
  119.   int     j;
  120.   imgpel *ref_line = UMVLine4X (list->p_curr_img_sub, pic_pix_y, pic_pix_x);
  122.   width_pad  = list->size_x_pad;
  123.   height_pad = list->size_y_pad;
  125.   for (j = 0; j < block_size_y; j++) 
  126.   {
  127.     memcpy(mpred, ref_line, block_size_x * sizeof(imgpel));
  128.     ref_line += img_padded_size_x;
  129.     mpred += block_size_x;
  130.   }  
  131. }
  134. /*!
  135.  ************************************************************************
  136.  * brief
  137.  *    Predict one Luma block
  138.  ************************************************************************
  139.  */
  140. void LumaPrediction ( Macroblock* currMB,//!< Current Macroblock
  141.                      int   block_x,     //!< relative horizontal block coordinate of block
  142.                      int   block_y,     //!< relative vertical   block coordinate of block
  143.                      int   block_size_x,//!< relative horizontal block coordinate of block
  144.                      int   block_size_y,//!< relative vertical   block coordinate of block
  145.                      int   p_dir,       //!< prediction direction (0=list0, 1=list1, 2=bipred)
  146.                      int   l0_mode,     //!< list0 prediction mode (1-7, 0=DIRECT if l1_mode=0)
  147.                      int   l1_mode,     //!< list1 prediction mode (1-7, 0=DIRECT if l0_mode=0)
  148.                      short l0_ref_idx,  //!< reference frame for list0 prediction (-1: Intra4x4 pred. with l0_mode)
  149.                      short l1_ref_idx,   //!< reference frame for list1 prediction 
  150.                      short bipred_me     //!< use bi prediction mv (0=no bipred, 1 = use set 1, 2 = use set 2)
  151.                      )
  152. {
  153.   int  i, j;
  154.   int  block_x4     = block_x + block_size_x;
  155.   int  block_y4     = block_y + block_size_y;
  156.   int  pic_opix_x   = ((img->opix_x + block_x) << 2) + IMG_PAD_SIZE_TIMES4;
  157.   int  pic_opix_y   = ((img->opix_y + block_y) << 2) + IMG_PAD_SIZE_TIMES4;
  158.   int  bx           = block_x >> 2;
  159.   int  by           = block_y >> 2;
  160.   imgpel* l0pred    = l0_pred;
  161.   imgpel* l1pred    = l1_pred;  
  162.   short****** mv_array = img->all_mv;
  163.   short   *curr_mv = NULL;
  164.   imgpel (*mb_pred)[16] = img->mb_pred[0];
  166.   int  apply_weights = ( (active_pps->weighted_pred_flag  && (img->type== P_SLICE || img->type == SP_SLICE)) ||
  167.     (active_pps->weighted_bipred_idc && (img->type== B_SLICE)));
  169.   if (bipred_me && l0_ref_idx == 0 && l1_ref_idx == 0 && p_dir == 2 && is_bipred_enabled(l0_mode) && is_bipred_enabled(l1_mode))
  170.     mv_array = img->bipred_mv[bipred_me - 1]; 
  172.   switch (p_dir)
  173.   {
  174.   case 0:
  175.     curr_mv = mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx];
  176.     OneComponentLumaPrediction (l0_pred, pic_opix_x + curr_mv[0], pic_opix_y + curr_mv[1], block_size_x, block_size_y, listX[LIST_0 + currMB->list_offset][l0_ref_idx]);
  177.     break;
  178.   case 1:
  179.     curr_mv = mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx];
  180.     OneComponentLumaPrediction (l1_pred, pic_opix_x + curr_mv[0], pic_opix_y + curr_mv[1], block_size_x, block_size_y, listX[LIST_1 + currMB->list_offset][l1_ref_idx]);
  181.     break;
  182.   case 2:
  183.     curr_mv = mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx];
  184.     OneComponentLumaPrediction (l0_pred, pic_opix_x + curr_mv[0], pic_opix_y + curr_mv[1], block_size_x, block_size_y, listX[LIST_0 + currMB->list_offset][l0_ref_idx]);
  185.     curr_mv = mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx];
  186.     OneComponentLumaPrediction (l1_pred, pic_opix_x + curr_mv[0], pic_opix_y + curr_mv[1], block_size_x, block_size_y, listX[LIST_1 + currMB->list_offset][l1_ref_idx]);
  187.     break;
  188.   default:
  189.     break;
  190.   }
  192.   if (apply_weights)
  193.   {
  194.     if (p_dir==2)
  195.     {
  196.       int wbp0 = wbp_weight[0][l0_ref_idx][l1_ref_idx][0];
  197.       int wbp1 = wbp_weight[1][l0_ref_idx][l1_ref_idx][0];
  198.       int offset = (wp_offset[0][l0_ref_idx][0] + wp_offset[1][l1_ref_idx][0] + 1)>>1;
  199.       int wp_round = 2 * wp_luma_round;
  200.       int weight_denom = luma_log_weight_denom + 1;
  201.       for   (j=block_y; j<block_y4; j++)
  202.         for (i=block_x; i<block_x4; i++)  
  203.           mb_pred[j][i] = iClip1( img->max_imgpel_value, 
  204.           ((wbp0 * *l0pred++ + wbp1 * *l1pred++ + wp_round) >> (weight_denom)) + offset); 
  205.     }
  206.     else if (p_dir==0)
  207.     {
  208.       int wp = wp_weight[0][l0_ref_idx][0];
  209.       int offset = wp_offset[0][l0_ref_idx][0];
  210.       for   (j=block_y; j<block_y4; j++)
  211.         for (i=block_x; i<block_x4; i++)
  212.           mb_pred[j][i] = iClip1( img->max_imgpel_value, 
  213.           ((wp * *l0pred++  + wp_luma_round) >> luma_log_weight_denom) + offset);
  214.     }
  215.     else // (p_dir==1)
  216.     {
  217.       int wp = wp_weight[1][l1_ref_idx][0];
  218.       int offset = wp_offset[1][l1_ref_idx][0];
  219.       for   (j=block_y; j<block_y4; j++)
  220.         for (i=block_x; i<block_x4; i++)
  221.           mb_pred[j][i] = iClip1( img->max_imgpel_value, 
  222.           ((wp * *l1pred++  + wp_luma_round) >> luma_log_weight_denom) + offset );
  223.     }
  224.   }
  225.   else
  226.   {
  227.     if (p_dir==2)
  228.     {
  229.       for   (j=block_y; j<block_y4; j++)
  230.         for (i=block_x; i<block_x4; i++)
  231.           mb_pred[j][i] = (*l0pred++ + *l1pred++ + 1) >> 1;
  232.     }
  233.     else if (p_dir==0)
  234.     {
  235.       for (j=block_y; j<block_y4; j++)
  236.       {
  237.         memcpy(&(mb_pred[j][block_x]), l0pred, block_size_x * sizeof(imgpel));
  238.         l0pred += block_size_x;
  239.       }
  240.     }
  241.     else // (p_dir==1)
  242.     {
  243.       for (j=block_y; j<block_y4; j++)
  244.       {
  245.         memcpy(&(mb_pred[j][block_x]), l1pred, block_size_x * sizeof(imgpel));
  246.         l1pred += block_size_x;
  247.       }
  248.     }
  249.   }
  250. }
  252. /*!
  253.  ************************************************************************
  254.  * brief
  255.  *    Predict one Luma block
  256.  ************************************************************************
  257.  */
  258. void LumaPredictionBi ( Macroblock* currMB, //!< Current Macroblock
  259.                         int   block_x,      //!< relative horizontal block coordinate of 4x4 block
  260.                         int   block_y,      //!< relative vertical   block coordinate of 4x4 block
  261.                         int   block_size_x, //!< horizontal block size
  262.                         int   block_size_y, //!< vertical   block size
  263.                         int   l0_mode,      //!< list0 prediction mode (1-7, 0=DIRECT if l1_mode=0)
  264.                         int   l1_mode,      //!< list1 prediction mode (1-7, 0=DIRECT if l0_mode=0)
  265.                         short l0_ref_idx,   //!< reference frame for list0 prediction (-1: Intra4x4 pred. with l0_mode)
  266.                         short l1_ref_idx,   //!< reference frame for list1 prediction 
  267.                         int   list          //!< current list for prediction.
  268.                         )
  269. {
  270.   int  i, j;
  271.   int  block_x4  = block_x + block_size_x;
  272.   int  block_y4  = block_y + block_size_y;
  273.   int  pic_opix_x = ((img->opix_x + block_x) << 2) + IMG_PAD_SIZE_TIMES4;
  274.   int  pic_opix_y = ((img->opix_y + block_y) << 2) + IMG_PAD_SIZE_TIMES4;
  275.   int  bx        = block_x >> 2;
  276.   int  by        = block_y >> 2;
  277.   imgpel* l0pred     = l0_pred;
  278.   imgpel* l1pred     = l1_pred;
  280.   int  apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
  281.     (active_pps->weighted_bipred_idc && (img->type == B_SLICE)));  
  282.   short   ******mv_array = img->bipred_mv[list]; 
  283.   short   *mv_arrayl0 = mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx];
  284.   short   *mv_arrayl1 = mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx];
  285.   imgpel (*mb_pred)[16] = img->mb_pred[0];
  287.   OneComponentLumaPrediction (l0_pred, pic_opix_x + mv_arrayl0[0], pic_opix_y + mv_arrayl0[1], block_size_x, block_size_y, listX[0+currMB->list_offset][l0_ref_idx]);
  288.   OneComponentLumaPrediction (l1_pred, pic_opix_x + mv_arrayl1[0], pic_opix_y + mv_arrayl1[1], block_size_x, block_size_y, listX[1+currMB->list_offset][l1_ref_idx]);
  290.   if (apply_weights)
  291.   {
  292.     int wbp0 = wbp_weight[0][l0_ref_idx][l1_ref_idx][0];
  293.     int wbp1 = wbp_weight[1][l0_ref_idx][l1_ref_idx][0];
  294.     int offset = (wp_offset[0][l0_ref_idx][0] + wp_offset[1][l1_ref_idx][0] + 1)>>1;
  295.     int wp_round = 2*wp_luma_round;
  296.     int weight_denom = luma_log_weight_denom + 1;
  298.     for   (j=block_y; j<block_y4; j++)
  299.       for (i=block_x; i<block_x4; i++)
  300.         mb_pred[j][i] = iClip1( img->max_imgpel_value,
  301.         ((wbp0 * *l0pred++ + wbp1 * *l1pred++ + wp_round) >> weight_denom) + offset);
  302.   }
  303.   else
  304.   {
  305.     for   (j=block_y; j<block_y4; j++)
  306.       for (i=block_x; i<block_x4; i++)
  307.         mb_pred[j][i] = (*l0pred++ + *l1pred++ + 1) >> 1;
  308.   }
  309. }
  312. /*!
  313.  ************************************************************************
  314.  * brief
  315.  *    Predict (on-the-fly) one component of a chroma 4x4 block
  316.  ************************************************************************
  317.  */
  318. void OneComponentChromaPrediction4x4_regenerate (
  319.                                  imgpel*     mpred,      //!< array to store prediction values
  320.                                  int         block_c_x,  //!< horizontal pixel coordinate of 4x4 block
  321.                                  int         block_c_y,  //!< vertical   pixel coordinate of 4x4 block
  322.                                  short***    mv,         //!< motion vector array
  323.                                  StorablePicture *list,
  324.                                  int         uv)         //!< chroma component
  325. {
  326.   int     i, j, ii, jj, ii0, jj0, ii1, jj1, if0, if1, jf0, jf1;
  327.   short*  mvb;
  329.   int     f1_x = 64/img->mb_cr_size_x;
  330.   int     f2_x=f1_x-1;
  332.   int     f1_y = 64/img->mb_cr_size_y;
  333.   int     f2_y=f1_y-1;
  335.   int     f3=f1_x*f1_y, f4=f3>>1;
  336.   int     list_offset = img->mb_data[img->current_mb_nr].list_offset;
  337.   int     max_y_cr = (int) (list_offset ? (img->height_cr >> 1) - 1 : img->height_cr - 1);
  338.   int     max_x_cr = (int) (img->width_cr - 1);
  339.   int     jjx, iix;
  340.   int     mb_cr_y_div4 = img->mb_cr_size_y>>2;
  341.   int     mb_cr_x_div4 = img->mb_cr_size_x>>2;
  342.   int     jpos;
  344.   imgpel** refimage = list->imgUV[uv];
  346.   for (j=block_c_y; j < block_c_y + BLOCK_SIZE; j++)
  347.   {
  348.     jjx = j/mb_cr_y_div4;
  349.     jpos = (j + img->opix_c_y)*f1_y;
  351.     for (i=block_c_x; i < block_c_x + BLOCK_SIZE; i++)
  352.     {
  353.       iix = i/mb_cr_x_div4;
  354.       mvb  = mv [jjx][iix];
  356.       ii   = (i + img->opix_c_x)*f1_x + mvb[0];
  357.       jj   = jpos + mvb[1];
  359.       if (active_sps->chroma_format_idc == 1)
  360.         jj  += list->chroma_vector_adjustment;
  362.       ii0  = iClip3 (0, max_x_cr, ii/f1_x);
  363.       jj0  = iClip3 (0, max_y_cr, jj/f1_y);
  364.       ii1  = iClip3 (0, max_x_cr, (ii+f2_x)/f1_x);
  365.       jj1  = iClip3 (0, max_y_cr, (jj+f2_y)/f1_y);
  367.       if1  = (ii&f2_x);  if0 = f1_x-if1;
  368.       jf1  = (jj&f2_y);  jf0 = f1_y-jf1;
  370.       *mpred++ = (if0 * jf0 * refimage[jj0][ii0] +
  371.                   if1 * jf0 * refimage[jj0][ii1] +
  372.                   if0 * jf1 * refimage[jj1][ii0] +
  373.                   if1 * jf1 * refimage[jj1][ii1] + f4) / f3;
  374.     }
  375.   }
  376. }
  378. /*!
  379.  ************************************************************************
  380.  * brief
  381.  *    Retrieve one component of a chroma 4x4 block from the buffer
  382.  ************************************************************************
  383.  */
  384. void OneComponentChromaPrediction4x4_retrieve (imgpel*        mpred,      //!< array to store prediction values
  385.                                  int         block_c_x,  //!< horizontal pixel coordinate of 4x4 block
  386.                                  int         block_c_y,  //!< vertical   pixel coordinate of 4x4 block
  387.                                  short***    mv,         //!< motion vector array
  388.                                  StorablePicture *list,
  389.                                  int         uv)         //!< chroma component
  390. {
  391.   int     j, ii, jj;
  392.   short*  mvb;
  394.   int     jjx;
  395.   int     right_shift_x = 4 - chroma_shift_x;
  396.   int     right_shift_y = 4 - chroma_shift_y;
  397.   int     jpos;
  399.   int     pos_x1 = block_c_x >> right_shift_x;
  400.   int     pos_x2 = (block_c_x + 2) >> right_shift_x;
  401.   int     ipos1 = ((block_c_x + img->opix_c_x    ) << chroma_shift_x) + IMG_PAD_SIZE_TIMES4;
  402.   int     ipos2 = ((block_c_x + img->opix_c_x + 2) << chroma_shift_x) + IMG_PAD_SIZE_TIMES4;
  404.   imgpel**** refsubimage = list->imgUV_sub[uv];
  405.   imgpel *line_ptr;
  407.   int jj_chroma = ((active_sps->chroma_format_idc == 1) ? list->chroma_vector_adjustment : 0) + IMG_PAD_SIZE_TIMES4;
  409.   width_pad_cr  = list->size_x_cr_pad;
  410.   height_pad_cr = list->size_y_cr_pad;
  412.   for (j=block_c_y; j < block_c_y + BLOCK_SIZE; j++)
  413.   {
  414.     jjx = j >> right_shift_y; // translate into absolute block (luma) coordinates
  416.     jpos = ( (j + img->opix_c_y) << chroma_shift_y ) + jj_chroma;
  418.     mvb  = mv [jjx][pos_x1];
  420.     ii   = ipos1 + mvb[0];
  421.     jj   = jpos  + mvb[1];
  423.     line_ptr = UMVLine8X_chroma ( refsubimage, jj, ii);
  424.     *mpred++ = *line_ptr++;
  425.     *mpred++ = *line_ptr;
  427.     mvb  = mv [jjx][pos_x2];
  429.     ii   = ipos2 + mvb[0];
  430.     jj   = jpos  + mvb[1];
  432.     line_ptr = UMVLine8X_chroma ( refsubimage, jj, ii);
  433.     *mpred++ = *line_ptr++;
  434.     *mpred++ = *line_ptr;
  435.   }
  436. }
  439. /*!
  440.  ************************************************************************
  441.  * brief
  442.  *    Retrieve one component of a chroma block from the buffer
  443.  ************************************************************************
  444.  */
  445. static inline 
  446. void OneComponentChromaPrediction ( imgpel* mpred,      //!< array to store prediction values
  447.                                    int    pic_pix_x,      //!< motion shifted horizontal coordinate of block
  448.                                    int    pic_pix_y,      //!< motion shifted vertical  block
  449.                                    int     block_size_x,   //!< horizontal block size
  450.                                    int     block_size_y,   //!< vertical block size                                      
  451.                                    StorablePicture *list, //!< reference picture list
  452.                                    int         uv)         //!< chroma component
  453. {
  454.   int     j;
  455.   imgpel *ref_line = UMVLine4X (list->imgUV_sub[uv], pic_pix_y, pic_pix_x);
  457.   width_pad_cr  = list->size_x_cr_pad;
  458.   height_pad_cr = list->size_y_cr_pad;
  460.   for (j = 0; j < block_size_y; j++) 
  461.   {
  462.     memcpy(mpred, ref_line, block_size_x * sizeof(imgpel));
  463.     ref_line += img_cr_padded_size_x;
  464.     mpred += block_size_x;
  465.   }
  466. }
  468. /*!
  469.  ************************************************************************
  470.  * brief
  471.  *    Predict an intra chroma 4x4 block
  472.  ************************************************************************
  473.  */
  474. static inline
  475. void IntraChromaPrediction4x4 (Macroblock* currMB, //! <-- Current Macroblock
  476.                                int  uv,            //! <-- colour component
  477.                                int  block_x,       //! <-- relative horizontal block coordinate of 4x4 block
  478.                                int  block_y)       //! <-- relative vertical   block coordinate of 4x4 block
  479. {
  480.   int j;
  481.   imgpel (*mb_pred)[16]       = img->mb_pred[ uv ];
  482.   imgpel (*curr_mpr_16x16)[16] = img->mpr_16x16[uv][currMB->c_ipred_mode];
  484.   //===== prediction =====
  485.   for (j=block_y; j<block_y + BLOCK_SIZE; j++)
  486.     memcpy(&mb_pred[j][block_x],&curr_mpr_16x16[j][block_x], BLOCK_SIZE * sizeof(imgpel));
  487. }
  489. /*!
  490.  ************************************************************************
  491.  * brief
  492.  *    Predict one chroma block
  493.  ************************************************************************
  494.  */
  495. void ChromaPrediction ( Macroblock* currMB, // <-- Current Macroblock
  496.                        int   uv,            // <-- colour component
  497.                        int   block_x,       // <-- relative horizontal block coordinate of block
  498.                        int   block_y,       // <-- relative vertical   block coordinate of block
  499.                        int   block_size_x,  // <-- relative horizontal block coordinate of block
  500.                        int   block_size_y,  // <-- relative vertical   block coordinate of block                        
  501.                        int   p_dir,         // <-- prediction direction (0=list0, 1=list1, 2=bipred)
  502.                        int   l0_mode,       // <-- list0  prediction mode (1-7, 0=DIRECT if l1_mode=0)
  503.                        int   l1_mode,       // <-- list1 prediction mode (1-7, 0=DIRECT if l0_mode=0)
  504.                        short l0_ref_idx,    // <-- reference frame for list0 prediction (if (<0) -> intra prediction)
  505.                        short l1_ref_idx,    // <-- reference frame for list1 prediction 
  506.                        short bipred_me      // <-- use bi prediction mv (0=no bipred, 1 = use set 1, 2 = use set 2)
  507.                        )    
  508. {
  509.   int  i, j;
  510.   int  block_x4     = block_x + block_size_x;
  511.   int  block_y4     = block_y + block_size_y;
  512.   int  pic_opix_x   = ((img->opix_c_x + block_x) << 2) + IMG_PAD_SIZE_TIMES4;
  513.   int  pic_opix_y   = ((img->opix_c_y + block_y) << 2) + IMG_PAD_SIZE_TIMES4;
  514.   int  bx           = block_x >> 2;
  515.   int  by           = block_y >> 2;
  516.   imgpel* l0pred     = l0_pred;
  517.   imgpel* l1pred     = l1_pred;
  518.   short****** mv_array = img->all_mv;    
  519.   int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  520.   int uv_comp = uv + 1;
  521.   imgpel (*mb_pred)[16] = img->mb_pred[ uv_comp];
  523.   int  apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
  524.     (active_pps->weighted_bipred_idc && (img->type == B_SLICE)));
  526.   if (bipred_me && l0_ref_idx == 0 && l1_ref_idx == 0 && p_dir == 2 && is_bipred_enabled(l0_mode)  && is_bipred_enabled(l1_mode))
  527.     mv_array = img->bipred_mv[bipred_me - 1]; 
  529.   //===== INTRA PREDICTION =====
  530.   if (p_dir==-1)
  531.   {
  532.     IntraChromaPrediction4x4 (currMB, uv_comp, block_x, block_y);
  533.     return;
  534.   }
  536.   //===== INTER PREDICTION =====
  537.   switch (p_dir)
  538.   {
  539.   case 0:
  540.     OneComponentChromaPrediction (l0_pred, pic_opix_x + mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx][0], pic_opix_y + mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx][1], block_size_x, block_size_y, listX[0+currMB->list_offset][l0_ref_idx], uv);
  541.     break;
  542.   case 1: 
  543.     OneComponentChromaPrediction (l1_pred, pic_opix_x + mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx][0], pic_opix_y + mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx][1], block_size_x, block_size_y, listX[1+currMB->list_offset][l1_ref_idx], uv);
  544.     break;
  545.   case 2:
  546.     OneComponentChromaPrediction (l0_pred, pic_opix_x + mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx][0], pic_opix_y + mv_array[LIST_0][l0_ref_idx][l0_mode][by][bx][1], block_size_x, block_size_y, listX[0+currMB->list_offset][l0_ref_idx], uv);
  547.     OneComponentChromaPrediction (l1_pred, pic_opix_x + mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx][0], pic_opix_y + mv_array[LIST_1][l1_ref_idx][l1_mode][by][bx][1], block_size_x, block_size_y, listX[1+currMB->list_offset][l1_ref_idx], uv);
  548.     break;
  549.   default:
  550.     break;
  551.   }
  553.   if (apply_weights)
  554.   {
  555.     if (p_dir==2)
  556.     {
  557.       int wbp0 = wbp_weight[0][l0_ref_idx][l1_ref_idx][uv_comp];
  558.       int wbp1 = wbp_weight[1][l0_ref_idx][l1_ref_idx][uv_comp];
  559.       int offset = (wp_offset[0][l0_ref_idx][uv_comp] + wp_offset[1][l1_ref_idx][uv_comp] + 1)>>1;
  560.       int wp_round = 2*wp_chroma_round;
  561.       int weight_denom = luma_log_weight_denom + 1;
  564.       for   (j=block_y; j<block_y4; j++)
  565.         for (i=block_x; i<block_x4; i++)
  566.           mb_pred[j][i] =  iClip1( max_imgpel_value_uv,
  567.           ((wbp0 * *l0pred++ + wbp1 * *l1pred++ + wp_round) >> (weight_denom)) + (offset) );
  568.     }
  569.     else if (p_dir==0)
  570.     {
  571.       int wp = wp_weight[0][l0_ref_idx][uv_comp];
  572.       int offset = wp_offset[0][l0_ref_idx][uv_comp];
  573.       for   (j=block_y; j<block_y4; j++)
  574.         for (i=block_x; i<block_x4; i++)
  575.           mb_pred[j][i] = iClip1( max_imgpel_value_uv, (( wp * *l0pred++ + wp_chroma_round) >> chroma_log_weight_denom) +  offset);
  576.     }
  577.     else // (p_dir==1)
  578.     {
  579.       int wp = wp_weight[1][l1_ref_idx][uv_comp];
  580.       int offset = wp_offset[1][l1_ref_idx][uv_comp];
  582.       for   (j=block_y; j<block_y4; j++)
  583.         for (i=block_x; i<block_x4; i++)
  584.           mb_pred[j][i] = iClip1( max_imgpel_value_uv, ((wp * *l1pred++ + wp_chroma_round) >> chroma_log_weight_denom) + offset);
  585.     }
  586.   }
  587.   else
  588.   {
  589.     if (p_dir==2)
  590.     {
  591.       for   (j=block_y; j<block_y4; j++)
  592.         for (i=block_x; i<block_x4; i++)
  593.           mb_pred[j][i] = (*l0pred++ + *l1pred++ + 1) >> 1;
  594.     }
  595.     else if (p_dir==0)
  596.     {
  597.       for (j=block_y; j<block_y4; j++)
  598.       {
  599.         memcpy(&(mb_pred[j][block_x]), l0pred, block_size_x * sizeof(imgpel));
  600.         l0pred += block_size_x;
  601.       }
  602.     }
  603.     else // (p_dir==1)
  604.     {
  605.       for (j=block_y; j<block_y4; j++)
  606.       {
  607.         memcpy(&(mb_pred[j][block_x]), l1pred, block_size_x * sizeof(imgpel));
  608.         l1pred += block_size_x;
  609.       }
  610.     }
  611.   }
  612. }
  616. /*!
  617.  ************************************************************************
  618.  * brief
  619.  *    Predict one chroma 4x4 block
  620.  ************************************************************************
  621.  */
  622. void ChromaPrediction4x4 ( Macroblock* currMB, // <-- Current Macroblock
  623.                            int   uv,           // <-- colour component
  624.                            int   block_x,      // <-- relative horizontal block coordinate of 4x4 block
  625.                            int   block_y,      // <-- relative vertical   block coordinate of 4x4 block
  626.                            int   p_dir,        // <-- prediction direction (0=list0, 1=list1, 2=bipred)
  627.                            int   l0_mode,      // <-- list0  prediction mode (1-7, 0=DIRECT if l1_mode=0)
  628.                            int   l1_mode,      // <-- list1 prediction mode (1-7, 0=DIRECT if l0_mode=0)
  629.                            short l0_ref_idx,   // <-- reference frame for list0 prediction (if (<0) -> intra prediction)
  630.                            short l1_ref_idx,   // <-- reference frame for list1 prediction 
  631.                            short bipred_me     // <-- use bi prediction mv (0=no bipred, 1 = use set 1, 2 = use set 2)
  632.                            )   
  633. {
  634.   int  i, j;
  635.   int  block_x4  = block_x + BLOCK_SIZE;
  636.   int  block_y4  = block_y + BLOCK_SIZE;
  637.   imgpel* l0pred     = l0_pred;
  638.   imgpel* l1pred     = l1_pred;
  639.   short****** mv_array = img->all_mv;
  640.   int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  641.   int uv_comp = uv + 1;
  642.   imgpel (*mb_pred)[16] = img->mb_pred[uv_comp];
  643.   int     list_offset = currMB->list_offset;
  644.   
  645.   int  apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
  646.     (active_pps->weighted_bipred_idc && (img->type == B_SLICE)));
  648.   if (bipred_me && l0_ref_idx == 0 && l1_ref_idx == 0 && p_dir == 2 && is_bipred_enabled(l0_mode)  && is_bipred_enabled(l1_mode) )
  649.     mv_array = img->bipred_mv[bipred_me - 1]; 
  650.   //===== INTRA PREDICTION =====
  651.   
  652.   if (p_dir==-1)
  653.   {
  654.     IntraChromaPrediction4x4 (currMB, uv_comp, block_x, block_y);
  655.     return;
  656.   }
  658.   //===== INTER PREDICTION =====
  659.   switch (p_dir)
  660.   {
  661.   case 0: // LIST_0
  662.     (*OneComponentChromaPrediction4x4) (l0_pred, block_x, block_y, mv_array[LIST_0][l0_ref_idx][l0_mode], listX[LIST_0 + list_offset][l0_ref_idx], uv);
  663.     break;
  664.   case 1: // LIST_1
  665.     (*OneComponentChromaPrediction4x4) (l1_pred, block_x, block_y, mv_array[LIST_1][l1_ref_idx][l1_mode], listX[LIST_1 + list_offset][l1_ref_idx], uv);
  666.     break;
  667.   case 2: // BI_PRED
  668.     (*OneComponentChromaPrediction4x4) (l0_pred, block_x, block_y, mv_array[LIST_0][l0_ref_idx][l0_mode], listX[LIST_0 + list_offset][l0_ref_idx], uv);
  669.     (*OneComponentChromaPrediction4x4) (l1_pred, block_x, block_y, mv_array[LIST_1][l1_ref_idx][l1_mode], listX[LIST_1 + list_offset][l1_ref_idx], uv);
  670.     break;
  671.   default:
  672.     break;
  673.   }
  675.   if (apply_weights)
  676.   {
  677.     if (p_dir==2)
  678.     {
  679.       int wbp0 = wbp_weight[0][l0_ref_idx][l1_ref_idx][uv_comp];
  680.       int wbp1 = wbp_weight[1][l0_ref_idx][l1_ref_idx][uv_comp];
  681.       int offset = (wp_offset[0][l0_ref_idx][uv_comp] + wp_offset[1][l1_ref_idx][uv_comp] + 1)>>1;
  682.       int wp_round = 2 * wp_chroma_round;
  683.       int weight_denom = luma_log_weight_denom + 1;
  685.       for (j=block_y; j<block_y4; j++)
  686.         for (i=block_x; i<block_x4; i++)
  687.           mb_pred[j][i] =  iClip1( max_imgpel_value_uv,
  688.           ((wbp0 * *l0pred++ + wbp1 * *l1pred++ + wp_round) >> (weight_denom)) + (offset) );
  689.     }
  690.     else if (p_dir==0)
  691.     {
  692.       int wp = wp_weight[0][l0_ref_idx][uv_comp];
  693.       int offset = wp_offset[0][l0_ref_idx][uv_comp];
  694.       for (j=block_y; j<block_y4; j++)
  695.         for (i=block_x; i<block_x4; i++)
  696.           mb_pred[j][i] = iClip1( max_imgpel_value_uv, (( wp * *l0pred++ + wp_chroma_round) >> chroma_log_weight_denom) +  offset);
  697.     }
  698.     else // (p_dir==1)
  699.     {
  700.       int wp = wp_weight[1][l1_ref_idx][uv_comp];
  701.       int offset = wp_offset[1][l1_ref_idx][uv_comp];
  703.       for (j=block_y; j<block_y4; j++)
  704.         for (i=block_x; i<block_x4; i++)
  705.           mb_pred[j][i] = iClip1( max_imgpel_value_uv, ((wp * *l1pred++ + wp_chroma_round) >> chroma_log_weight_denom) + offset);
  706.     }
  707.   }
  708.   else
  709.   {
  710.     if (p_dir==2)
  711.     {
  712.       for (j=block_y; j<block_y4; j++)
  713.         for (i=block_x; i<block_x4; i++)
  714.           mb_pred[j][i] = (*l0pred++ + *l1pred++ + 1) >> 1;
  715.     }
  716.     else if (p_dir==0)
  717.     {
  718.       for (j=block_y; j<block_y4; j++)
  719.       {
  720.         memcpy(&(mb_pred[j][block_x]), l0pred, BLOCK_SIZE * sizeof(imgpel));
  721.         l0pred += BLOCK_SIZE;
  722.       }
  723.     }
  724.     else // (p_dir==1)
  725.     {
  726.       for (j=block_y; j<block_y4; j++)
  727.       {
  728.         memcpy(&(mb_pred[j][block_x]), l1pred, BLOCK_SIZE * sizeof(imgpel));
  729.         l1pred += BLOCK_SIZE;
  730.       }
  731.     }
  732.   }
  733. }
  736. /*!
  737.  ************************************************************************
  738.  * brief
  739.  *    Intra prediction of the chrminance layers of one macroblock
  740.  ************************************************************************
  741.  */
  742. void IntraChromaPrediction (Macroblock *currMB, int *mb_up, int *mb_left, int*mb_up_left)
  743. {
  744.   static int s, s0, s1, s2, s3, i, j, k;
  745.   static int ih,iv, ib, ic, iaa;
  746.   int      uv;
  747.   int      blk_x, blk_y;
  748.   int      b8,b4;
  749.   imgpel**  image;
  750.   imgpel   vline[16];
  751.   int      block_x, block_y;
  752.   int      mb_available_up;
  753.   int      mb_available_left[2];
  754.   int      mb_available_up_left;
  756.   int      mode;
  757.   int      best_mode = DC_PRED_8;  //just an initilaization here, should always be overwritten
  758.   int      cost;
  759.   int      min_cost;
  760.   PixelPos up;        //!< pixel position  p(0,-1)
  761.   PixelPos left[17];  //!< pixel positions p(-1, -1..15)
  762.   int      cr_MB_x = img->mb_cr_size_x;
  763.   int      cr_MB_y = img->mb_cr_size_y;
  764.   static imgpel (*cur_pred)[16];
  765.   static imgpel (*curr_mpr_16x16)[16][16];
  766.   static imgpel *hline;
  767.   static imgpel *img_org, *img_prd;
  769.   int      yuv = img->yuv_format - 1;
  770.   int      dc_pred_value_chroma = img->dc_pred_value_comp[1];
  771.   int      max_imgpel_value_uv  = img->max_imgpel_value_comp[1];
  773.   static const int block_pos[3][4][4]= //[yuv][b8][b4]
  774.   {
  775.     { {0, 1, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0},{0, 0, 0, 0}},
  776.     { {0, 1, 2, 3},{2, 3, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0}},
  777.     { {0, 1, 2, 3},{1, 1, 3, 3},{2, 3, 2, 3},{3, 3, 3, 3}}
  778.   };
  780.   for (i=0;i<cr_MB_y+1;i++)
  781.   {
  782.     getNeighbour(currMB, -1 , i-1 , img->mb_size[IS_CHROMA], &left[i]);
  783.   }
  784.   getNeighbour(currMB, 0 , -1 , img->mb_size[IS_CHROMA], &up);
  787.   mb_available_up                             = up.available;
  788.   mb_available_up_left                        = left[0].available;
  789.   mb_available_left[0] = mb_available_left[1] = left[1].available;
  791.   if(params->UseConstrainedIntraPred)
  792.   {
  793.     mb_available_up = up.available ? img->intra_block[up.mb_addr] : 0;
  794.     for (i=0, mb_available_left[0]=1; i<(cr_MB_y>>1);i++)
  795.       mb_available_left[0]  &= left[i+1].available ? img->intra_block[left[i+1].mb_addr]: 0;
  796.     for (i=(cr_MB_y>>1), mb_available_left[1]=1; i<cr_MB_y;i++)
  797.       mb_available_left[1] &= left[i+1].available ? img->intra_block[left[i+1].mb_addr]: 0;
  798.     mb_available_up_left = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  799.   }
  801.   if (mb_up)
  802.     *mb_up = mb_available_up;
  803.   if (mb_left)
  804.     *mb_left = mb_available_left[0] && mb_available_left[1];
  805.   if (mb_up_left)
  806.     *mb_up_left = mb_available_up_left;
  809.   // compute all chroma intra prediction modes for both U and V
  810.   for (uv=0; uv<2; uv++)
  811.   {
  812.     image          = enc_picture->imgUV[uv];
  813.     curr_mpr_16x16 = img->mpr_16x16[uv + 1];
  815.     // DC prediction
  816.     for(b8=0; b8<img->num_blk8x8_uv >> 1;b8++)
  817.     {
  818.       for (b4=0; b4<4; b4++)
  819.       {
  820.         block_y = subblk_offset_y[yuv][b8][b4];
  821.         block_x = subblk_offset_x[yuv][b8][b4];
  822.         blk_x = block_x;
  823.         blk_y = block_y + 1;
  825.         s=dc_pred_value_chroma;
  826.         s0=s1=s2=s3=0;
  828.         //===== get prediction value =====
  829.         switch (block_pos[yuv][b8][b4])
  830.         {
  831.         case 0:  //===== TOP LEFT =====
  832.           if      (mb_available_up)       
  833.             for (i=blk_x;i<(blk_x+4);i++)  
  834.               s0 += image[up.pos_y][up.pos_x + i];
  835.           if      (mb_available_left[0])  
  836.             for (i=blk_y;i<(blk_y+4);i++)  
  837.               s2 += image[left[i].pos_y][left[i].pos_x];
  838.           if      (mb_available_up && mb_available_left[0])  
  839.             s  = (s0+s2+4) >> 3;
  840.           else if (mb_available_up)                          
  841.             s  = (s0   +2) >> 2;
  842.           else if (mb_available_left[0])                     
  843.             s  = (s2   +2) >> 2;
  844.           break;
  845.         case 1: //===== TOP RIGHT =====
  846.           if      (mb_available_up)       
  847.             for (i=blk_x;i<(blk_x+4);i++)  
  848.               s1 += image[up.pos_y][up.pos_x + i];
  849.           else if (mb_available_left[0])  
  850.             for (i=blk_y;i<(blk_y+4);i++) 
  851.               s2 += image[left[i].pos_y][left[i].pos_x];
  852.           if      (mb_available_up)       
  853.             s  = (s1   +2) >> 2;
  854.           else if (mb_available_left[0])                    
  855.             s  = (s2   +2) >> 2;
  856.           break;
  857.         case 2: //===== BOTTOM LEFT =====
  858.           if      (mb_available_left[1])  
  859.             for (i=blk_y;i<(blk_y+4);i++)  
  860.               s3 += image[left[i].pos_y][left[i].pos_x];
  861.           else if (mb_available_up)       
  862.             for (i=blk_x;i<(blk_x+4);i++)  
  863.               s0 += image[up.pos_y][up.pos_x + i];
  864.           if      (mb_available_left[1])                     
  865.             s  = (s3   +2) >> 2;
  866.           else if (mb_available_up)                          
  867.             s  = (s0   +2) >> 2;
  868.           break;
  869.         case 3: //===== BOTTOM RIGHT =====
  870.           if      (mb_available_up)       
  871.             for (i=blk_x;i<(blk_x+4);i++)  
  872.               s1 += image[up.pos_y][up.pos_x + i];
  873.           if      (mb_available_left[1])  
  874.             for (i=blk_y;i<(blk_y+4);i++)  
  875.               s3 += image[left[i].pos_y][left[i].pos_x];
  876.           if      (mb_available_up && mb_available_left[1])  
  877.             s  = (s1+s3+4) >> 3;
  878.           else if (mb_available_up)                          
  879.             s  = (s1   +2) >> 2;
  880.           else if (mb_available_left[1])                     
  881.             s  = (s3   +2) >> 2;
  882.           break;
  883.         }
  885.         //===== prediction =====
  886.         cur_pred = curr_mpr_16x16[DC_PRED_8];
  887.         for (j=block_y; j<block_y+4; j++)
  888.           for (i=block_x; i<block_x+4; i++)
  889.           {
  890.             cur_pred[j][i] = s;
  891.           }
  892.       }
  893.     }
  895.     // vertical prediction    
  896.     if (mb_available_up)
  897.     {
  898.       cur_pred = curr_mpr_16x16[VERT_PRED_8];
  899.       //memcpy(hline,&image[up.pos_y][up.pos_x], cr_MB_x * sizeof(imgpel));
  900.       hline = &image[up.pos_y][up.pos_x];
  901.       for (j=0; j<cr_MB_y; j++)
  902.         memcpy(cur_pred[j], hline, cr_MB_x * sizeof(imgpel));
  903.     }
  905.     // horizontal prediction
  906.     if (mb_available_left[0] && mb_available_left[1])
  907.     {
  908.       cur_pred = curr_mpr_16x16[HOR_PRED_8];
  909.       for (i=0; i<cr_MB_y; i++)
  910.         vline[i] = image[left[i+1].pos_y][left[i+1].pos_x];
  911.       for (j=0; j<cr_MB_y; j++)
  912.       {
  913.         int predictor = vline[j];
  914.         for (i=0; i<cr_MB_x; i++)        
  915.           cur_pred[j][i] = predictor;
  916.       }
  917.     }
  919.     // plane prediction
  920.     if (mb_available_left[0] && mb_available_left[1] && mb_available_up && mb_available_up_left)
  921.     {
  922.       ih = (cr_MB_x>>1)*(hline[cr_MB_x-1] - image[left[0].pos_y][left[0].pos_x]);
  923.       for (i=0;i<(cr_MB_x>>1)-1;i++)
  924.         ih += (i+1)*(hline[(cr_MB_x>>1)+i] - hline[(cr_MB_x>>1)-2-i]);
  926.       iv = (cr_MB_y>>1)*(vline[cr_MB_y-1] - image[left[0].pos_y][left[0].pos_x]);
  927.       for (i=0;i<(cr_MB_y>>1)-1;i++)
  928.         iv += (i+1)*(vline[(cr_MB_y>>1)+i] - vline[(cr_MB_y>>1)-2-i]);
  930.       ib= ((cr_MB_x == 8?17:5)*ih+2*cr_MB_x)>>(cr_MB_x == 8?5:6);
  931.       ic= ((cr_MB_y == 8?17:5)*iv+2*cr_MB_y)>>(cr_MB_y == 8?5:6);
  933.       iaa=16*(hline[cr_MB_x-1] + vline[cr_MB_y-1]);
  934.       cur_pred = curr_mpr_16x16[PLANE_8];
  935.       for (j=0; j<cr_MB_y; j++)
  936.         for (i=0; i<cr_MB_x; i++)
  937.           cur_pred[j][i]= iClip1( max_imgpel_value_uv, (iaa+(i-(cr_MB_x>>1)+1)*ib+(j-(cr_MB_y>>1)+1)*ic+16)>>5);
  938.     }
  939.   }
  941.   if (!params->rdopt)      // the rd-opt part does not work correctly (see encode_one_macroblock)
  942.   {                       // since ipredmodes could be overwritten => encoder-decoder-mismatches
  943.     // pick lowest cost prediction mode
  944.     min_cost = INT_MAX;
  945.     for (i=0;i<cr_MB_y;i++)
  946.     {
  947.       getNeighbour(currMB, 0 , i, img->mb_size[IS_CHROMA], &left[i]);
  948.     }
  950.     if ( img->MbaffFrameFlag && img->field_mode )
  951.     {
  952.       for (i=0;i<cr_MB_y;i++)
  953.       {
  954.         left[i].pos_y = left[i].pos_y >> 1;
  955.       }
  956.     }
  958.     for (mode=DC_PRED_8; mode<=PLANE_8; mode++)
  959.     {
  960.       if ((img->type != I_SLICE || !params->IntraDisableInterOnly) && params->ChromaIntraDisable == 1 && mode!=DC_PRED_8)
  961.         continue;
  963.       if ((mode==VERT_PRED_8 && !mb_available_up) ||
  964.         (mode==HOR_PRED_8 && (!mb_available_left[0] || !mb_available_left[1])) ||
  965.         (mode==PLANE_8 && (!mb_available_left[0] || !mb_available_left[1] || !mb_available_up || !mb_available_up_left)))
  966.         continue;
  968.       cost = 0;
  969.       for (uv = 1; uv < 3; uv++)
  970.       {
  971.         image = pImgOrg[uv];
  972.         curr_mpr_16x16 = img->mpr_16x16[uv];
  973.         for (block_y=0; block_y<cr_MB_y; block_y+=4)
  974.           for (block_x = 0; block_x < cr_MB_x; block_x += 4)
  975.           {
  976.             for (k=0, j = block_y; j < block_y + 4; j++)
  977.             {
  978.               img_prd = curr_mpr_16x16[mode][j];
  979.               img_org = &image[left[j].pos_y][left[j].pos_x];
  980.               for (i = block_x; i < block_x + 4; i++)
  981.                 diff[k++] = img_org[i] - img_prd[i];
  982.             }
  983.             cost += distortion4x4(diff);
  984.           }
  985.       }
  986.       if (cost < min_cost)
  987.       {
  988.         best_mode = mode;
  989.         min_cost = cost;
  990.       }
  991.     }
  992.     currMB->c_ipred_mode = best_mode;
  993.   }
  994. }
  996. void ComputeResidue (imgpel **curImg, imgpel mpr[16][16], int img_m7[16][16], int mb_y, int mb_x, int opix_y, int opix_x, int width, int height)
  997. {
  998.   static imgpel *imgOrg, *imgPred;
  999.   static int    *m7;
  1000.   int i, j;
  1002.   for (j = mb_y; j < mb_y + height; j++)
  1003.   {
  1004.     imgOrg = &curImg[opix_y + j][opix_x];    
  1005.     imgPred = &mpr[j][mb_x];
  1006.     m7 = &img_m7[j][mb_x]; 
  1007.     for (i = 0; i < width; i++)
  1008.     {
  1009.       *m7++ = *imgOrg++ - *imgPred++;
  1010.     }
  1011.   }
  1012. }
  1014. void SampleReconstruct (imgpel **curImg, imgpel mpr[16][16], int img_m7[16][16], int mb_y, int mb_x, int opix_y, int opix_x, int width, int height, int max_imgpel_value, int dq_bits)
  1015. {
  1016.   static imgpel *imgOrg, *imgPred;
  1017.   static int    *m7;
  1018.   int i, j;
  1020.   for (j = mb_y; j < mb_y + height; j++)
  1021.   {
  1022.     imgOrg = &curImg[opix_y + j][opix_x];
  1023.     imgPred = &mpr[j][mb_x];
  1024.     m7 = &img_m7[j][mb_x]; 
  1025.     for (i=0;i<width;i++)
  1026.       *imgOrg++ = iClip1( max_imgpel_value, rshift_rnd_sf(*m7++, dq_bits) + *imgPred++);
  1027.   }
  1028. }