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

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

Audio

开发平台：

Visual C++

transform8x8.c：源码内容
  1. /*!
  2.  ***************************************************************************
  3.  * file transform8x8.c
  4.  *
  5.  * brief
  6.  *    8x8 transform functions
  7.  *
  8.  * author
  9.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  10.  *    - Yuri Vatis
  11.  *    - Jan Muenster
  12.  *    - Lowell Winger                   <lwinger@lsil.com>
  13.  * date
  14.  *    12. October 2003
  15.  **************************************************************************
  16.  */
  18. #include <math.h>
  19. #include <limits.h>
  21. #include "global.h"
  23. #include "image.h"
  24. #include "mb_access.h"
  25. #include "elements.h"
  26. #include "cabac.h"
  27. #include "vlc.h"
  28. #include "transform8x8.h"
  29. #include "transform.h"
  30. #include "macroblock.h"
  31. #include "symbol.h"
  32. #include "mc_prediction.h"
  33. #include "quant8x8.h"
  34. #include "rdoq.h"
  35. #include "q_matrix.h"
  36. #include "q_offsets.h"
  38. int   cofAC8x8_chroma[2][4][2][18];
  39. static int diff64[64];
  41. //! single scan pattern
  42. //static const byte SNGL_SCAN8x8[64][2] = {
  43. const byte SNGL_SCAN8x8[64][2] = {
  44.   {0,0}, {1,0}, {0,1}, {0,2}, {1,1}, {2,0}, {3,0}, {2,1},
  45.   {1,2}, {0,3}, {0,4}, {1,3}, {2,2}, {3,1}, {4,0}, {5,0},
  46.   {4,1}, {3,2}, {2,3}, {1,4}, {0,5}, {0,6}, {1,5}, {2,4},
  47.   {3,3}, {4,2}, {5,1}, {6,0}, {7,0}, {6,1}, {5,2}, {4,3},
  48.   {3,4}, {2,5}, {1,6}, {0,7}, {1,7}, {2,6}, {3,5}, {4,4},
  49.   {5,3}, {6,2}, {7,1}, {7,2}, {6,3}, {5,4}, {4,5}, {3,6},
  50.   {2,7}, {3,7}, {4,6}, {5,5}, {6,4}, {7,3}, {7,4}, {6,5},
  51.   {5,6}, {4,7}, {5,7}, {6,6}, {7,5}, {7,6}, {6,7}, {7,7}
  52. };
  55. //! field scan pattern
  56. //static const byte FIELD_SCAN8x8[64][2] = {   // 8x8
  57. const byte FIELD_SCAN8x8[64][2] = {   // 8x8
  58.   {0,0}, {0,1}, {0,2}, {1,0}, {1,1}, {0,3}, {0,4}, {1,2},
  59.   {2,0}, {1,3}, {0,5}, {0,6}, {0,7}, {1,4}, {2,1}, {3,0},
  60.   {2,2}, {1,5}, {1,6}, {1,7}, {2,3}, {3,1}, {4,0}, {3,2},
  61.   {2,4}, {2,5}, {2,6}, {2,7}, {3,3}, {4,1}, {5,0}, {4,2},
  62.   {3,4}, {3,5}, {3,6}, {3,7}, {4,3}, {5,1}, {6,0}, {5,2},
  63.   {4,4}, {4,5}, {4,6}, {4,7}, {5,3}, {6,1}, {6,2}, {5,4},
  64.   {5,5}, {5,6}, {5,7}, {6,3}, {7,0}, {7,1}, {6,4}, {6,5},
  65.   {6,6}, {6,7}, {7,2}, {7,3}, {7,4}, {7,5}, {7,6}, {7,7}
  66. };
  69. //! array used to find expensive coefficients
  70. static const byte COEFF_COST8x8[2][64] =
  71. {
  72.   {3,3,3,3,2,2,2,2,2,2,2,2,1,1,1,1,
  73.    1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
  74.    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  75.    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  76.   {9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  77.    9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  78.    9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  79.    9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9}
  80. };
  82. static int **levelscale = NULL, **leveloffset = NULL;
  83. static int **invlevelscale = NULL;
  84. static int **fadjust8x8 = NULL;
  87. /*!
  88. ************************************************************************
  89. * brief
  90. *    Residual DPCM for Intra lossless coding
  91. *
  92. * par Input:
  93. *    block_x,block_y: Block position inside a macro block (0,8).
  94. ************************************************************************
  95. */
  96. //For residual DPCM
  97. int Residual_DPCM_8x8(int ipmode, int ores[16][16], int rres[16][16],int block_y, int block_x)
  98. {
  99.   int i,j;
  100.   int temp[8][8];
  102.   if(ipmode==VERT_PRED)
  103.   { 
  105.     for (j=0; j<8; j++)
  106.      temp[0][j] = ores[block_y][block_x+j];
  108.     for (i=1; i<8; i++) 
  109.       for (j=0; j<8; j++)
  110.         temp[i][j] =  ores[block_y+i][block_x+j] - ores[block_y+i-1][block_x+j];
  112.     for (i = 0; i < 8; i++)
  113.       for (j = 0; j < 8; j++)
  114.         rres[block_y+i][block_x+j] = temp[i][j];
  115.   }
  116.   else  //HOR_PRED
  117.   {
  118.     for (i=0; i<8; i++)
  119.      temp[i][0] = ores[block_y + i][block_x];
  121.     for (i=0; i<8; i++)
  122.       for (j=1; j<8; j++)
  123.         temp[i][j] = ores[block_y+i][block_x+j] - ores[block_y+i][block_x+j-1];
  125.     for (i=0; i<8; i++)
  126.       for (j=0; j<8; j++)
  127.         rres[block_y+i][block_x+j] = temp[i][j];
  128.   }
  129.   return 0;
  130. }
  132. /*!
  133. ************************************************************************
  134. * brief
  135. *    Inverse residual DPCM for Intra lossless coding
  136. *
  137. * par Input:
  138. *    block_x,block_y: Block position inside a macro block (0,8).
  139. ************************************************************************
  140. */
  141. //For residual DPCM
  142. int Inv_Residual_DPCM_8x8(int m7[16][16], int block_y, int block_x)  
  143. {
  144.   int i;
  145.   int temp[8][8];
  147.   if(ipmode_DPCM==VERT_PRED)
  148.   {
  149.     for(i=0; i<8; i++)
  150.     {
  151.       temp[0][i] = m7[block_y+0][block_x+i];
  152.       temp[1][i] = temp[0][i] + m7[block_y+1][block_x+i];
  153.       temp[2][i] = temp[1][i] + m7[block_y+2][block_x+i];
  154.       temp[3][i] = temp[2][i] + m7[block_y+3][block_x+i];
  155.       temp[4][i] = temp[3][i] + m7[block_y+4][block_x+i];
  156.       temp[5][i] = temp[4][i] + m7[block_y+5][block_x+i];
  157.       temp[6][i] = temp[5][i] + m7[block_y+6][block_x+i];
  158.       temp[7][i] = temp[6][i] + m7[block_y+7][block_x+i];
  159.     }
  160.     for(i=0; i<8; i++)
  161.     {
  162.       m7[block_y+1][block_x+i] = temp[1][i];
  163.       m7[block_y+2][block_x+i] = temp[2][i];
  164.       m7[block_y+3][block_x+i] = temp[3][i];
  165.       m7[block_y+4][block_x+i] = temp[4][i];
  166.       m7[block_y+5][block_x+i] = temp[5][i];
  167.       m7[block_y+6][block_x+i] = temp[6][i];
  168.       m7[block_y+7][block_x+i] = temp[7][i];
  169.     }
  170.   }
  171.   else //HOR_PRED
  172.   {
  173.     for(i=0; i<8; i++)
  174.     {
  175.       temp[i][0] = m7[block_y+i][block_x+0];
  176.       temp[i][1] = temp[i][0] + m7[block_y+i][block_x+1];
  177.       temp[i][2] = temp[i][1] + m7[block_y+i][block_x+2];
  178.       temp[i][3] = temp[i][2] + m7[block_y+i][block_x+3];
  179.       temp[i][4] = temp[i][3] + m7[block_y+i][block_x+4];
  180.       temp[i][5] = temp[i][4] + m7[block_y+i][block_x+5];
  181.       temp[i][6] = temp[i][5] + m7[block_y+i][block_x+6];
  182.       temp[i][7] = temp[i][6] + m7[block_y+i][block_x+7];
  183.     }
  184.     for(i=0; i<8; i++)
  185.     {
  186.       m7[block_y+i][block_x+1] = temp[i][1];
  187.       m7[block_y+i][block_x+2] = temp[i][2];
  188.       m7[block_y+i][block_x+3] = temp[i][3];
  189.       m7[block_y+i][block_x+4] = temp[i][4];
  190.       m7[block_y+i][block_x+5] = temp[i][5];
  191.       m7[block_y+i][block_x+6] = temp[i][6];
  192.       m7[block_y+i][block_x+7] = temp[i][7];
  193.     }
  194.   }
  195.   return 0;
  196. }
  198. /*!
  199.  *************************************************************************************
  200.  * brief
  201.  *    8x8 Intra mode decision for a macroblock
  202.  *************************************************************************************
  203.  */
  205. int Mode_Decision_for_new_Intra8x8Macroblock (Macroblock *currMB, double lambda, double *min_cost)
  206. {
  207.   int cur_cbp = 0, b8;
  208.   double cost8x8;
  209.   int cr_cbp[3] = { 0, 0, 0}; 
  211.   *min_cost = (int)floor(6.0 * lambda + 0.4999);
  213.   cmp_cbp[1] = cmp_cbp[2] = 0;
  214.   if (params->rdopt == 0)
  215.     Mode_Decision_for_new_8x8IntraBlocks = Mode_Decision_for_new_8x8IntraBlocks_JM_Low;
  216.   else
  217.     Mode_Decision_for_new_8x8IntraBlocks = Mode_Decision_for_new_8x8IntraBlocks_JM_High;
  218.   for (b8=0; b8<4; b8++)
  219.   {
  220.     if (Mode_Decision_for_new_8x8IntraBlocks (currMB, b8, lambda, &cost8x8, cr_cbp))
  221.     {
  222.       cur_cbp |= (1<<b8);
  223.     }
  224.     *min_cost += cost8x8;
  226.     if (img->P444_joined)
  227.     {
  228.       int k;
  229.       for (k = 1; k < 3; k++)
  230.       {
  231.         if (cr_cbp[k])
  232.         {
  233.           cmp_cbp[k] |= (1<<b8);
  234.           cur_cbp |= cmp_cbp[k];
  235.           cmp_cbp[k] = cur_cbp;
  236.         }
  237.       }
  238.     }
  239.   }
  241.   return cur_cbp;
  242. }
  244. /*!
  245.  *************************************************************************************
  246.  * brief
  247.  *    8x8 Intra mode decision for a macroblock - Low complexity
  248.  *************************************************************************************
  249.  */
  251. int Mode_Decision_for_new_8x8IntraBlocks_JM_Low (Macroblock *currMB, int b8, double lambda, double *min_cost, int cr_cbp[3])
  252. {
  253.   int     ipmode, best_ipmode = 0, i, j, dummy;
  254.   double  cost;
  255.   int     nonzero = 0;
  256.   int     block_x     = (b8 & 0x01) << 3;
  257.   int     block_y     = (b8 >> 1) << 3;
  258.   int     pic_pix_x   = img->pix_x + block_x;
  259.   int     pic_pix_y   = img->pix_y + block_y;
  260.   int     pic_opix_x   = img->opix_x + block_x;
  261.   int     pic_opix_y   = img->opix_y + block_y;
  262.   int     pic_block_x = pic_pix_x >> 2;
  263.   int     pic_block_y = pic_pix_y >> 2;
  264.   imgpel    *img_org, *img_prd;
  265.   int       *residual;
  266.   int left_available, up_available, all_available;
  267.   int    (*mb_ores)[16] = img->mb_ores[0]; 
  268.   imgpel (*mb_pred)[16] = img->mb_pred[0];
  269.   int *mb_size = img->mb_size[IS_LUMA];
  271.   char   upMode;
  272.   char   leftMode;
  273.   int    mostProbableMode;
  275.   PixelPos left_block;
  276.   PixelPos top_block;
  278.   get4x4Neighbour(currMB, block_x - 1, block_y    , mb_size, &left_block);
  279.   get4x4Neighbour(currMB, block_x,     block_y - 1, mb_size, &top_block );
  281.   if (params->UseConstrainedIntraPred)
  282.   {
  283.     top_block.available  = top_block.available ? img->intra_block [top_block.mb_addr] : 0;
  284.     left_block.available = left_block.available ? img->intra_block [left_block.mb_addr] : 0;
  285.   }
  287.   if(b8 >> 1)
  288.     upMode    =  top_block.available ? img->ipredmode8x8[top_block.pos_y ][top_block.pos_x ] : -1;
  289.   else
  290.     upMode    =  top_block.available ? img->ipredmode   [top_block.pos_y ][top_block.pos_x ] : -1;
  291.   if(b8 & 0x01)
  292.     leftMode  = left_block.available ? img->ipredmode8x8[left_block.pos_y][left_block.pos_x] : -1;
  293.   else
  294.     leftMode  = left_block.available ? img->ipredmode[left_block.pos_y][left_block.pos_x] : -1;
  296.   mostProbableMode  = (upMode < 0 || leftMode < 0) ? DC_PRED : upMode < leftMode ? upMode : leftMode;
  298.   *min_cost = INT_MAX;
  300.   ipmode_DPCM = NO_INTRA_PMODE; //For residual DPCM
  302.   //===== INTRA PREDICTION FOR 8x8 BLOCK =====
  303.   intrapred_8x8 (currMB, PLANE_Y, pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
  305.   if(img->P444_joined)
  306.   { 
  307.     select_plane(PLANE_U);
  308.     intrapred_8x8(currMB, PLANE_U, pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
  309.     select_plane(PLANE_V);
  310.     intrapred_8x8(currMB, PLANE_V, pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
  311.     select_plane(PLANE_Y);
  312.   }
  314.   //===== LOOP OVER ALL 8x8 INTRA PREDICTION MODES =====
  315.   for (ipmode = 0; ipmode < NO_INTRA_PMODE; ipmode++)
  316.   {
  317.     if( (ipmode==DC_PRED) ||
  318.       ((ipmode==VERT_PRED||ipmode==VERT_LEFT_PRED||ipmode==DIAG_DOWN_LEFT_PRED) && up_available ) ||
  319.       ((ipmode==HOR_PRED||ipmode==HOR_UP_PRED) && left_available ) ||
  320.       (all_available) )
  321.     {
  322.       cost  = (ipmode == mostProbableMode) ? 0 : (int)floor(4 * lambda );
  323.       compute_comp_cost8x8(&pImgOrg[0][pic_opix_y], img->mpr_8x8[0][ipmode], pic_opix_x, &cost);
  324.      
  325.       if(img->P444_joined)
  326.       {
  327.         int m;
  328.         for (m = PLANE_U; m <= PLANE_V; m++)
  329.         compute_comp_cost8x8(&pImgOrg[m][pic_opix_y], img->mpr_8x8[m][ipmode], pic_opix_x, &cost);
  330.       }
  332.       if (cost < *min_cost)
  333.       {
  334.         best_ipmode = ipmode;
  335.         *min_cost   = cost;
  336.       }
  337.     }
  338.   }
  340.   //===== set intra mode prediction =====
  341.   img->ipredmode8x8[pic_block_y][pic_block_x] = (char) best_ipmode;
  342.   ipmode_DPCM = best_ipmode; //For residual DPCM
  344.   if(img->P444_joined)
  345.   {
  346.     ColorPlane k;
  347.     CbCr_predmode_8x8[b8] = best_ipmode; 
  348.     for (k = PLANE_U; k <= PLANE_V; k++)
  349.     {
  350.       cr_cbp[k] = 0; 
  351.       select_plane(k);
  352.       for (j=0; j<8; j++)
  353.       {
  354.         for (i=0; i<8; i++)
  355.         {
  356.           img->mb_pred[k][block_y+j][block_x+i]  = img->mpr_8x8[k][best_ipmode][j][i]; 
  357.           img->mb_ores[k][block_y+j][block_x+i]   = pImgOrg[k][img->pix_y+block_y+j][img->pix_x+block_x+i] - img->mpr_8x8[k][best_ipmode][j][i];
  358.         }
  359.       }
  360.       ipmode_DPCM=best_ipmode; 
  362.       if (pDCT_8x8(currMB, k, b8, &dummy, 1))
  363.         cr_cbp[k] = 1;
  364.     }
  365.     select_plane(PLANE_Y);
  366.   }
  368.   currMB->intra_pred_modes8x8[4*b8] = (mostProbableMode == best_ipmode)
  369.     ? -1
  370.     : (best_ipmode < mostProbableMode ? best_ipmode : best_ipmode-1);
  372.   for(j = img->mb_y*4+(b8 >> 1)*2; j < img->mb_y*4+(b8 >> 1)*2 + 2; j++)   //loop 4x4s in the subblock for 8x8 prediction setting
  373.     memset(&img->ipredmode8x8[j][img->mb_x*4+(b8 & 0x01)*2], best_ipmode, 2 * sizeof(char));
  375.   // get prediction and prediction error
  376.   for (j = block_y; j < block_y + 8; j++)
  377.   {
  378.     memcpy(&mb_pred[j][block_x],img->mpr_8x8[0][best_ipmode][j - block_y], 8 * sizeof(imgpel));
  379.     img_org  = &pCurImg[img->opix_y+j][pic_opix_x];
  380.     img_prd  = &mb_pred[j][block_x];
  381.     residual = &mb_ores[j][block_x];
  382.     for (i=0; i<8; i++)
  383.     {
  384.       *residual++ = *img_org++ - *img_prd++;
  385.     }
  386.   }
  388.   ipmode_DPCM = best_ipmode;
  389.   nonzero = pDCT_8x8 (currMB, PLANE_Y, b8, &dummy, 1);    
  390.   return nonzero;
  391. }
  393. /*!
  394. *************************************************************************************
  395. * brief
  396. *    8x8 Intra mode decision for a macroblock - High complexity
  397. *************************************************************************************
  398. */
  400. int Mode_Decision_for_new_8x8IntraBlocks_JM_High (Macroblock *currMB, int b8, double lambda, double *min_cost, int cr_cbp[3])
  401. {
  402.   int     ipmode, best_ipmode = 0, i, j, k, y, dummy;
  403.   int     c_nz, nonzero = 0;
  404.   static  imgpel  rec8x8[3][8][8];
  405.   double  rdcost = 0.0;
  406.   int     block_x     = (b8 & 0x01) << 3;
  407.   int     block_y     = (b8 >> 1) << 3;
  408.   int     pic_pix_x   = img->pix_x + block_x;
  409.   int     pic_pix_y   = img->pix_y + block_y;
  410.   int     pic_opix_x   = img->opix_x + block_x;
  411.   int     pic_opix_y   = img->opix_y + block_y;
  412.   int     pic_block_x = pic_pix_x >> 2;
  413.   int     pic_block_y = pic_pix_y >> 2;
  414.   double  min_rdcost  = 1e30;
  415.   imgpel    *img_org, *img_prd;
  416.   int       *residual;
  417.   extern  int ****cofAC8x8;
  418.   static int fadjust8x8[2][16][16];
  419.   static int fadjust8x8Cr[2][2][16][16];
  420.   extern  int ****cofAC8x8CbCr[2];
  421.   int uv, c_nzCbCr[3];
  422.   int left_available, up_available, all_available;
  423.   int    (*mb_ores)[16] = img->mb_ores[0]; 
  424.   imgpel (*mb_pred)[16] = img->mb_pred[0];
  425.   int *mb_size = img->mb_size[IS_LUMA];
  427.   char   upMode;
  428.   char   leftMode;
  429.   int    mostProbableMode;
  431.   PixelPos left_block;
  432.   PixelPos top_block;
  434.   get4x4Neighbour(currMB, block_x - 1, block_y    , mb_size, &left_block);
  435.   get4x4Neighbour(currMB, block_x,     block_y - 1, mb_size, &top_block );
  437.   if (params->UseConstrainedIntraPred)
  438.   {
  439.     top_block.available  = top_block.available ? img->intra_block [top_block.mb_addr] : 0;
  440.     left_block.available = left_block.available ? img->intra_block [left_block.mb_addr] : 0;
  441.   }
  443.   if(b8 >> 1)
  444.     upMode    =  top_block.available ? img->ipredmode8x8[top_block.pos_y ][top_block.pos_x ] : -1;
  445.   else
  446.     upMode    =  top_block.available ? img->ipredmode   [top_block.pos_y ][top_block.pos_x ] : -1;
  447.   if(b8 & 0x01)
  448.     leftMode  = left_block.available ? img->ipredmode8x8[left_block.pos_y][left_block.pos_x] : -1;
  449.   else
  450.     leftMode  = left_block.available ? img->ipredmode[left_block.pos_y][left_block.pos_x] : -1;
  452.   mostProbableMode  = (upMode < 0 || leftMode < 0) ? DC_PRED : upMode < leftMode ? upMode : leftMode;
  454.   *min_cost = INT_MAX;
  456.   ipmode_DPCM = NO_INTRA_PMODE; //For residual DPCM
  458.   //===== INTRA PREDICTION FOR 8x8 BLOCK =====
  459.   intrapred_8x8 (currMB, PLANE_Y, pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
  461.   if(img->P444_joined)
  462.   { 
  463.     select_plane(PLANE_U);
  464.     intrapred_8x8(currMB, PLANE_U, pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
  465.     select_plane(PLANE_V);
  466.     intrapred_8x8(currMB, PLANE_V, pic_pix_x, pic_pix_y, &left_available, &up_available, &all_available);
  467.     select_plane(PLANE_Y);
  468.   }
  470.   //===== LOOP OVER ALL 8x8 INTRA PREDICTION MODES =====
  471.   for (ipmode = 0; ipmode < NO_INTRA_PMODE; ipmode++)
  472.   {
  473.     if( (ipmode==DC_PRED) ||
  474.       ((ipmode==VERT_PRED||ipmode==VERT_LEFT_PRED||ipmode==DIAG_DOWN_LEFT_PRED) && up_available ) ||
  475.       ((ipmode==HOR_PRED||ipmode==HOR_UP_PRED) && left_available ) ||
  476.       (all_available) )
  477.     {
  478.       // get prediction and prediction error
  479.       for (j=block_y; j < block_y  + 8; j++)
  480.       {
  481.         memcpy(&mb_pred[j][block_x],img->mpr_8x8[0][ipmode][j - block_y], 8 * sizeof(imgpel));
  482.         img_org  = &pCurImg[img->opix_y+j][pic_opix_x];
  483.         img_prd  = &mb_pred[j][block_x];
  484.         residual = &mb_ores[j][block_x];
  485.         for (i=0; i<8; i++)
  486.         {
  487.           *residual++ = *img_org++ - *img_prd++;
  488.         }
  489.       }
  490.       if(img->P444_joined) 
  491.       {
  492.         for (k = PLANE_U; k <= PLANE_V; k++)
  493.         {
  494.           for (j=0; j<8; j++)
  495.           {
  496.             memcpy(&img->mb_pred[k][block_y+j][block_x],img->mpr_8x8[k][ipmode][j], 8 * sizeof(imgpel));
  497.             for (i=0; i<8; i++)
  498.             {
  499.               img->mb_ores[k][block_y+j][block_x+i] = (int) (pImgOrg[k][pic_opix_y+j][pic_opix_x+i] - img->mpr_8x8[k][ipmode][j][i]);
  500.               img->mb_ores[k][block_y+j][block_x+i] = img->mb_ores[k][block_y+j][block_x+i]; // line is temporary until we fix code to use img->mb_ores
  501.             }
  502.           }
  503.         }
  504.       }
  506.       ipmode_DPCM=ipmode;
  508.       //===== store the coding state =====
  509.       // store_coding_state_cs_cm(currMB);
  510.       // get and check rate-distortion cost
  512.       if ((rdcost = RDCost_for_8x8IntraBlocks (currMB, &c_nz, b8, ipmode, lambda, min_rdcost, mostProbableMode, c_nzCbCr)) < min_rdcost)
  513.       {
  514.         //--- set coefficients ---
  515.        memcpy(cofAC8x8[b8][0][0],img->cofAC[b8][0][0], 4 * 2 * 65 * sizeof(int));
  517.         //--- set reconstruction ---
  518.         for (y=0; y<8; y++)
  519.         {
  520.           memcpy(rec8x8[0][y],&enc_picture->imgY[pic_pix_y+y][pic_pix_x], 8 * sizeof(imgpel));
  521.         }
  523.         if (img->AdaptiveRounding)
  524.         {
  525.           for (j=block_y; j<block_y + 8; j++)
  526.             memcpy(&fadjust8x8[1][j][block_x],&img->fadjust8x8[1][j][block_x], 8 * sizeof(int));
  528.           if (img->P444_joined)
  529.           {
  530.             for (j=block_y; j<block_y + 8; j++)
  531.             {
  532.               memcpy(&fadjust8x8Cr[0][1][j][block_x],&img->fadjust8x8Cr[0][1][j][block_x], 8 * sizeof(int));
  533.               memcpy(&fadjust8x8Cr[1][1][j][block_x],&img->fadjust8x8Cr[1][1][j][block_x], 8 * sizeof(int));
  534.             }
  535.           }            
  536.         }
  538.         if (img->P444_joined) 
  539.         { 
  540.           //--- set coefficients ---
  541.           for (uv=0; uv < 2; uv++)
  542.           {
  543.             memcpy(cofAC8x8CbCr[uv][b8][0][0],img->cofAC[4+b8+4*uv][0][0], 2 * 4 * 65 * sizeof(int));
  545.             cr_cbp[uv + 1] = c_nzCbCr[uv + 1];
  546.             //--- set reconstruction ---
  547.             for (y=0; y<8; y++)
  548.             {
  549.               memcpy(rec8x8[uv + 1][y],&enc_picture->imgUV[uv][pic_pix_y+y][pic_pix_x], 8 * sizeof(imgpel));
  550.             }
  551.           }
  552.         }
  554.         //--- flag if dct-coefficients must be coded ---
  555.         nonzero = c_nz;
  557.         //--- set best mode update minimum cost ---
  558.         *min_cost   = rdcost;
  559.         min_rdcost  = rdcost;
  560.         best_ipmode = ipmode;
  561.       }
  562.       reset_coding_state_cs_cm(currMB);
  563.     }
  564.   }
  566.   //===== set intra mode prediction =====
  567.   img->ipredmode8x8[pic_block_y][pic_block_x] = (char) best_ipmode;
  568.   ipmode_DPCM = best_ipmode; //For residual DPCM
  570.   if(img->P444_joined)
  571.   {
  572.     ColorPlane k;
  573.     CbCr_predmode_8x8[b8] = best_ipmode; 
  574.     for (k = PLANE_U; k <= PLANE_V; k++)
  575.     {
  576.       cr_cbp[k] = 0; 
  577.       select_plane(k);
  578.       for (j=0; j<8; j++)
  579.       {
  580.         for (i=0; i<8; i++)
  581.         {
  582.           img->mb_pred[k][block_y+j][block_x+i] = img->mpr_8x8[k][best_ipmode][j][i]; 
  583.           img->mb_ores[k][block_y+j][block_x+i] = pImgOrg[k][img->pix_y+block_y+j][img->pix_x+block_x+i] - img->mpr_8x8[k][best_ipmode][j][i];
  584.         }
  585.       }
  586.       ipmode_DPCM = best_ipmode; 
  588.       if (pDCT_8x8(currMB, k, b8, &dummy, 1))
  589.         cr_cbp[k] = 1;
  590.     }
  591.     select_plane(PLANE_Y);
  592.   }
  594.   currMB->intra_pred_modes8x8[4*b8] = (mostProbableMode == best_ipmode)
  595.     ? -1
  596.     : (best_ipmode < mostProbableMode ? best_ipmode : best_ipmode-1);
  598.   for(j = img->mb_y*4+(b8 >> 1)*2; j < img->mb_y*4+(b8 >> 1)*2 + 2; j++)   //loop 4x4s in the subblock for 8x8 prediction setting
  599.     memset(&img->ipredmode8x8[j][img->mb_x*4+(b8 & 0x01)*2], best_ipmode, 2 * sizeof(char));
  601.   //===== restore coefficients =====
  602.   memcpy(img->cofAC[b8][0][0],cofAC8x8[b8][0][0], 4 * 2 * 65 * sizeof(int));
  605.   if (img->AdaptiveRounding)
  606.   {
  607.     for (j=block_y; j< block_y + 8; j++)
  608.       memcpy(&img->fadjust8x8[1][j][block_x], &fadjust8x8[1][j][block_x], 8 * sizeof(int));
  609.     if (img->P444_joined)
  610.     {
  611.       for (j=0; j<8; j++)
  612.       {
  613.         memcpy(&img->fadjust8x8Cr[0][1][block_y+j][block_x], &fadjust8x8Cr[0][1][block_y+j][block_x], 8 * sizeof(int));
  614.         memcpy(&img->fadjust8x8Cr[1][1][block_y+j][block_x], &fadjust8x8Cr[1][1][block_y+j][block_x], 8 * sizeof(int));
  615.       }
  616.     }
  617.   }
  619.   //===== restore reconstruction and prediction (needed if single coeffs are removed) =====
  620.   for (y=0; y<8; y++)
  621.   {
  622.     memcpy(&enc_picture->imgY[pic_pix_y + y][pic_pix_x], rec8x8[0][y], 8 * sizeof(imgpel));
  623.     memcpy(&mb_pred[block_y + y][block_x], img->mpr_8x8[0][best_ipmode][y], 8 * sizeof(imgpel));
  624.   }
  625.   if (img->P444_joined)
  626.   {
  627.     //===== restore coefficients =====
  628.     memcpy(img->cofAC[4+b8+4*0][0][0], cofAC8x8CbCr[0][b8][0][0], 4 * 2 * 65 * sizeof(int));
  629.     memcpy(img->cofAC[4+b8+4*1][0][0], cofAC8x8CbCr[1][b8][0][0], 4 * 2 * 65 * sizeof(int));
  631.         //===== restore reconstruction and prediction (needed if single coeffs are removed) =====
  632.     for (y=0; y<8; y++) 
  633.     {
  634.       memcpy(&enc_picture->imgUV[0][pic_pix_y+y][pic_pix_x], rec8x8[1][y], 8 * sizeof(imgpel));
  635.       memcpy(&enc_picture->imgUV[1][pic_pix_y+y][pic_pix_x], rec8x8[2][y], 8 * sizeof(imgpel));
  636.       memcpy(&img->mb_pred[1][block_y+y][block_x], img->mpr_8x8[1][best_ipmode][y], 8 * sizeof(imgpel));
  637.       memcpy(&img->mb_pred[2][block_y+y][block_x], img->mpr_8x8[2][best_ipmode][y], 8 * sizeof(imgpel));
  638.     }
  639.   }
  641.   return nonzero;
  642. }
  644. // Notation for comments regarding prediction and predictors.
  645. // The pels of the 4x4 block are labelled a..p. The predictor pels above
  646. // are labelled A..H, from the left I..P, and from above left X, as follows:
  647. //
  648. //  Z  A  B  C  D  E  F  G  H  I  J  K  L  M   N  O  P
  649. //  Q  a1 b1 c1 d1 e1 f1 g1 h1
  650. //  R  a2 b2 c2 d2 e2 f2 g2 h2
  651. //  S  a3 b3 c3 d3 e3 f3 g3 h3
  652. //  T  a4 b4 c4 d4 e4 f4 g4 h4
  653. //  U  a5 b5 c5 d5 e5 f5 g5 h5
  654. //  V  a6 b6 c6 d6 e6 f6 g6 h6
  655. //  W  a7 b7 c7 d7 e7 f7 g7 h7
  656. //  X  a8 b8 c8 d8 e8 f8 g8 h8
  659. // Predictor array index definitions
  660. #define P_Z (PredPel[0])
  661. #define P_A (PredPel[1])
  662. #define P_B (PredPel[2])
  663. #define P_C (PredPel[3])
  664. #define P_D (PredPel[4])
  665. #define P_E (PredPel[5])
  666. #define P_F (PredPel[6])
  667. #define P_G (PredPel[7])
  668. #define P_H (PredPel[8])
  669. #define P_I (PredPel[9])
  670. #define P_J (PredPel[10])
  671. #define P_K (PredPel[11])
  672. #define P_L (PredPel[12])
  673. #define P_M (PredPel[13])
  674. #define P_N (PredPel[14])
  675. #define P_O (PredPel[15])
  676. #define P_P (PredPel[16])
  677. #define P_Q (PredPel[17])
  678. #define P_R (PredPel[18])
  679. #define P_S (PredPel[19])
  680. #define P_T (PredPel[20])
  681. #define P_U (PredPel[21])
  682. #define P_V (PredPel[22])
  683. #define P_W (PredPel[23])
  684. #define P_X (PredPel[24])
  686. /*!
  687.  ************************************************************************
  688.  * brief
  689.  *    Make intra 8x8 prediction according to all 9 prediction modes.
  690.  *    The routine uses left and upper neighbouring points from
  691.  *    previous coded blocks to do this (if available). Notice that
  692.  *    inaccessible neighbouring points are signalled with a negative
  693.  *    value in the predmode array .
  694.  *
  695.  *  par Input:
  696.  *     Starting point of current 8x8 block image posision
  697.  *
  698.  *  par Output:
  699.  *      none
  700.  ************************************************************************
  701.  */
  702. void intrapred_8x8(Macroblock *currMB, ColorPlane pl, int img_x,int img_y, int *left_available, int *up_available, int *all_available)
  703. {
  704.   int i,j;
  705.   int s0;
  706.   static imgpel PredPel[25];  // array of predictor pels
  707.   imgpel **img_enc = enc_picture->p_curr_img;
  708.   imgpel *img_pel;
  709.   static imgpel (*cur_pred)[16];
  710.   imgpel (*curr_mpr_8x8)[16][16]  = img->mpr_8x8[pl];
  711.   unsigned int dc_pred_value = img->dc_pred_value;
  712.   int *mb_size = img->mb_size[IS_LUMA];
  714.   int ioff = (img_x & 15);
  715.   int joff = (img_y & 15);
  717.   PixelPos pix_a[8];
  718.   PixelPos pix_b, pix_c, pix_d;
  720.   int block_available_up;
  721.   int block_available_left;
  722.   int block_available_up_left;
  723.   int block_available_up_right;
  725.   for (i=0;i<8;i++)
  726.   {
  727.     getNeighbour(currMB, ioff - 1, joff + i , mb_size, &pix_a[i]);
  728.   }
  730.   getNeighbour(currMB, ioff    , joff - 1, mb_size, &pix_b);
  731.   getNeighbour(currMB, ioff + 8, joff - 1, mb_size, &pix_c);
  732.   getNeighbour(currMB, ioff - 1, joff - 1, mb_size, &pix_d);
  734.   pix_c.available = pix_c.available &&!(ioff == 8 && joff == 8);
  736.   if (params->UseConstrainedIntraPred)
  737.   {
  738.     for (i=0, block_available_left=1; i<8;i++)
  739.       block_available_left  &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
  741.     block_available_up       = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
  742.     block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
  743.     block_available_up_left  = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
  744.   }
  745.   else
  746.   {
  747.     block_available_left     = pix_a[0].available;
  748.     block_available_up       = pix_b.available;
  749.     block_available_up_right = pix_c.available;
  750.     block_available_up_left  = pix_d.available;
  751.   }
  753.   *left_available = block_available_left;
  754.   *up_available   = block_available_up;
  755.   *all_available  = block_available_up && block_available_left && block_available_up_left;
  757.   i = (img_x & 15);
  758.   j = (img_y & 15);
  760.   // form predictor pels
  761.   // form predictor pels
  762.   if (block_available_up)
  763.   {
  764.     img_pel = &img_enc[pix_b.pos_y][pix_b.pos_x];
  765.     P_A = *(img_pel++);
  766.     P_B = *(img_pel++);
  767.     P_C = *(img_pel++);
  768.     P_D = *(img_pel++);
  769.     P_E = *(img_pel++);
  770.     P_F = *(img_pel++);
  771.     P_G = *(img_pel++);
  772.     P_H = *(img_pel);
  773.   }
  774.   else
  775.   {
  776.     P_A = P_B = P_C = P_D = P_E = P_F = P_G = P_H = dc_pred_value;
  777.   }
  779.   if (block_available_up_right)
  780.   {
  781.     img_pel = &img_enc[pix_c.pos_y][pix_c.pos_x];
  782.     P_I = *(img_pel++);
  783.     P_J = *(img_pel++);
  784.     P_K = *(img_pel++);
  785.     P_L = *(img_pel++);
  786.     P_M = *(img_pel++);
  787.     P_N = *(img_pel++);
  788.     P_O = *(img_pel++);
  789.     P_P = *(img_pel);
  791.   }
  792.   else
  793.   {
  794.     P_I = P_J = P_K = P_L = P_M = P_N = P_O = P_P = P_H;
  795.   }
  797.   if (block_available_left)
  798.   {
  799.     P_Q = img_enc[pix_a[0].pos_y][pix_a[0].pos_x];
  800.     P_R = img_enc[pix_a[1].pos_y][pix_a[1].pos_x];
  801.     P_S = img_enc[pix_a[2].pos_y][pix_a[2].pos_x];
  802.     P_T = img_enc[pix_a[3].pos_y][pix_a[3].pos_x];
  803.     P_U = img_enc[pix_a[4].pos_y][pix_a[4].pos_x];
  804.     P_V = img_enc[pix_a[5].pos_y][pix_a[5].pos_x];
  805.     P_W = img_enc[pix_a[6].pos_y][pix_a[6].pos_x];
  806.     P_X = img_enc[pix_a[7].pos_y][pix_a[7].pos_x];
  807.   }
  808.   else
  809.   {
  810.     P_Q = P_R = P_S = P_T = P_U = P_V = P_W = P_X = dc_pred_value;
  811.   }
  813.   if (block_available_up_left)
  814.   {
  815.     P_Z = img_enc[pix_d.pos_y][pix_d.pos_x];
  816.   }
  817.   else
  818.   {
  819.     P_Z = dc_pred_value;
  820.   }
  822.   for(i=0;i<9;i++)
  823.     curr_mpr_8x8[i][0][0]=-1;
  825.   LowPassForIntra8x8Pred(&(P_Z), block_available_up_left, block_available_up, block_available_left);
  827.   ///////////////////////////////
  828.   // make DC prediction
  829.   ///////////////////////////////
  830.   s0 = 0;
  831.   if (block_available_up && block_available_left)
  832.   {
  833.     // no edge
  834.     s0 = rshift_rnd_sf((P_A + P_B + P_C + P_D + P_E + P_F + P_G + P_H + P_Q + P_R + P_S + P_T + P_U + P_V + P_W + P_X), 4);
  835.   }
  836.   else if (!block_available_up && block_available_left)
  837.   {
  838.     // upper edge
  839.     s0 = rshift_rnd_sf((P_Q + P_R + P_S + P_T + P_U + P_V + P_W + P_X), 3);
  840.   }
  841.   else if (block_available_up && !block_available_left)
  842.   {
  843.     // left edge
  844.     s0 = rshift_rnd_sf((P_A + P_B + P_C + P_D + P_E + P_F + P_G + P_H), 3);
  845.   }
  846.   else //if (!block_available_up && !block_available_left)
  847.   {
  848.     // top left corner, nothing to predict from
  849.     s0 = dc_pred_value;
  850.   }
  852.   // store DC prediction
  853.   cur_pred = curr_mpr_8x8[DC_PRED];
  854.   for (j=0; j < BLOCK_SIZE_8x8; j++)
  855.   {
  856.     for (i=0; i < BLOCK_SIZE_8x8; i++)
  857.     {
  858.       cur_pred[j][i] = (imgpel) s0;
  859.     }
  860.   }
  863.   ///////////////////////////////
  864.   // make horiz and vert prediction
  865.   ///////////////////////////////
  866.   cur_pred = curr_mpr_8x8[VERT_PRED];
  867.   for (i=0; i < BLOCK_SIZE_8x8; i++)
  868.   {
  869.     cur_pred[0][i] =
  870.     cur_pred[1][i] =
  871.     cur_pred[2][i] =
  872.     cur_pred[3][i] =
  873.     cur_pred[4][i] =
  874.     cur_pred[5][i] =
  875.     cur_pred[6][i] =
  876.     cur_pred[7][i] = (imgpel)(&P_A)[i];
  877.   }
  878.   if(!block_available_up)
  879.     cur_pred[0][0]=-1;
  881.   cur_pred = curr_mpr_8x8[HOR_PRED];
  882.   for (i=0; i < BLOCK_SIZE_8x8; i++)
  883.   {
  884.     cur_pred[i][0]  =
  885.     cur_pred[i][1]  =
  886.     cur_pred[i][2]  =
  887.     cur_pred[i][3]  =
  888.     cur_pred[i][4]  =
  889.     cur_pred[i][5]  =
  890.     cur_pred[i][6]  =
  891.     cur_pred[i][7]  = (imgpel) (&P_Q)[i];
  892.   }
  893.   if(!block_available_left)
  894.     cur_pred[0][0]=-1;
  896.   ///////////////////////////////////
  897.   // make diagonal down left prediction
  898.   ///////////////////////////////////
  899.   if (block_available_up)
  900.   {
  901.     // Mode DIAG_DOWN_LEFT_PRED
  902.     cur_pred = curr_mpr_8x8[DIAG_DOWN_LEFT_PRED];
  903.     cur_pred[0][0] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
  904.     cur_pred[0][1] =
  905.     cur_pred[1][0] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
  906.     cur_pred[0][2] =
  907.     cur_pred[1][1] =
  908.     cur_pred[2][0] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
  909.     cur_pred[0][3] =
  910.     cur_pred[1][2] =
  911.     cur_pred[2][1] =
  912.     cur_pred[3][0] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
  913.     cur_pred[0][4] =
  914.     cur_pred[1][3] =
  915.     cur_pred[2][2] =
  916.     cur_pred[3][1] =
  917.     cur_pred[4][0] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
  918.     cur_pred[0][5] =
  919.     cur_pred[1][4] =
  920.     cur_pred[2][3] =
  921.     cur_pred[3][2] =
  922.     cur_pred[4][1] =
  923.     cur_pred[5][0] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
  924.     cur_pred[0][6] =
  925.     cur_pred[1][5] =
  926.     cur_pred[2][4] =
  927.     cur_pred[3][3] =
  928.     cur_pred[4][2] =
  929.     cur_pred[5][1] =
  930.     cur_pred[6][0] = (imgpel) ((P_G + P_I + 2*(P_H) + 2) >> 2);
  931.     cur_pred[0][7] =
  932.     cur_pred[1][6] =
  933.     cur_pred[2][5] =
  934.     cur_pred[3][4] =
  935.     cur_pred[4][3] =
  936.     cur_pred[5][2] =
  937.     cur_pred[6][1] =
  938.     cur_pred[7][0] = (imgpel) ((P_H + P_J + 2*(P_I) + 2) >> 2);
  939.     cur_pred[1][7] =
  940.     cur_pred[2][6] =
  941.     cur_pred[3][5] =
  942.     cur_pred[4][4] =
  943.     cur_pred[5][3] =
  944.     cur_pred[6][2] =
  945.     cur_pred[7][1] = (imgpel) ((P_I + P_K + 2*(P_J) + 2) >> 2);
  946.     cur_pred[2][7] =
  947.     cur_pred[3][6] =
  948.     cur_pred[4][5] =
  949.     cur_pred[5][4] =
  950.     cur_pred[6][3] =
  951.     cur_pred[7][2] = (imgpel) ((P_J + P_L + 2*(P_K) + 2) >> 2);
  952.     cur_pred[3][7] =
  953.     cur_pred[4][6] =
  954.     cur_pred[5][5] =
  955.     cur_pred[6][4] =
  956.     cur_pred[7][3] = (imgpel) ((P_K + P_M + 2*(P_L) + 2) >> 2);
  957.     cur_pred[4][7] =
  958.     cur_pred[5][6] =
  959.     cur_pred[6][5] =
  960.     cur_pred[7][4] = (imgpel) ((P_L + P_N + 2*(P_M) + 2) >> 2);
  961.     cur_pred[5][7] =
  962.     cur_pred[6][6] =
  963.     cur_pred[7][5] = (imgpel) ((P_M + P_O + 2*(P_N) + 2) >> 2);
  964.     cur_pred[6][7] =
  965.     cur_pred[7][6] = (imgpel) ((P_N + P_P + 2*(P_O) + 2) >> 2);
  966.     cur_pred[7][7] = (imgpel) ((P_O + 3*(P_P) + 2) >> 2);
  968.     ///////////////////////////////////
  969.     // make vertical left prediction
  970.     ///////////////////////////////////
  971.     cur_pred = curr_mpr_8x8[VERT_LEFT_PRED];
  972.     cur_pred[0][0] = (imgpel) ((P_A + P_B + 1) >> 1);
  973.     cur_pred[0][1] =
  974.     cur_pred[2][0] = (imgpel) ((P_B + P_C + 1) >> 1);
  975.     cur_pred[0][2] =
  976.     cur_pred[2][1] =
  977.     cur_pred[4][0] = (imgpel) ((P_C + P_D + 1) >> 1);
  978.     cur_pred[0][3] =
  979.     cur_pred[2][2] =
  980.     cur_pred[4][1] =
  981.     cur_pred[6][0] = (imgpel) ((P_D + P_E + 1) >> 1);
  982.     cur_pred[0][4] =
  983.     cur_pred[2][3] =
  984.     cur_pred[4][2] =
  985.     cur_pred[6][1] = (imgpel) ((P_E + P_F + 1) >> 1);
  986.     cur_pred[0][5] =
  987.     cur_pred[2][4] =
  988.     cur_pred[4][3] =
  989.     cur_pred[6][2] = (imgpel) ((P_F + P_G + 1) >> 1);
  990.     cur_pred[0][6] =
  991.     cur_pred[2][5] =
  992.     cur_pred[4][4] =
  993.     cur_pred[6][3] = (imgpel) ((P_G + P_H + 1) >> 1);
  994.     cur_pred[0][7] =
  995.     cur_pred[2][6] =
  996.     cur_pred[4][5] =
  997.     cur_pred[6][4] = (imgpel) ((P_H + P_I + 1) >> 1);
  998.     cur_pred[2][7] =
  999.     cur_pred[4][6] =
  1000.     cur_pred[6][5] = (imgpel) ((P_I + P_J + 1) >> 1);
  1001.     cur_pred[4][7] =
  1002.     cur_pred[6][6] = (imgpel) ((P_J + P_K + 1) >> 1);
  1003.     cur_pred[6][7] = (imgpel) ((P_K + P_L + 1) >> 1);
  1004.     cur_pred[1][0] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
  1005.     cur_pred[1][1] =
  1006.     cur_pred[3][0] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
  1007.     cur_pred[1][2] =
  1008.     cur_pred[3][1] =
  1009.     cur_pred[5][0] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
  1010.     cur_pred[1][3] =
  1011.     cur_pred[3][2] =
  1012.     cur_pred[5][1] =
  1013.     cur_pred[7][0] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
  1014.     cur_pred[1][4] =
  1015.     cur_pred[3][3] =
  1016.     cur_pred[5][2] =
  1017.     cur_pred[7][1] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
  1018.     cur_pred[1][5] =
  1019.     cur_pred[3][4] =
  1020.     cur_pred[5][3] =
  1021.     cur_pred[7][2] = (imgpel) ((P_F + P_H + 2*P_G + 2) >> 2);
  1022.     cur_pred[1][6] =
  1023.     cur_pred[3][5] =
  1024.     cur_pred[5][4] =
  1025.     cur_pred[7][3] = (imgpel) ((P_G + P_I + 2*P_H + 2) >> 2);
  1026.     cur_pred[1][7] =
  1027.     cur_pred[3][6] =
  1028.     cur_pred[5][5] =
  1029.     cur_pred[7][4] = (imgpel) ((P_H + P_J + 2*P_I + 2) >> 2);
  1030.     cur_pred[3][7] =
  1031.     cur_pred[5][6] =
  1032.     cur_pred[7][5] = (imgpel) ((P_I + P_K + 2*P_J + 2) >> 2);
  1033.     cur_pred[5][7] =
  1034.     cur_pred[7][6] = (imgpel) ((P_J + P_L + 2*P_K + 2) >> 2);
  1035.     cur_pred[7][7] = (imgpel) ((P_K + P_M + 2*P_L + 2) >> 2);
  1036.   }
  1038.   ///////////////////////////////////
  1039.   // make diagonal down right prediction
  1040.   ///////////////////////////////////
  1041.   if (block_available_up && block_available_left && block_available_up_left)
  1042.   {
  1043.     // Mode DIAG_DOWN_RIGHT_PRED
  1044.     cur_pred = curr_mpr_8x8[DIAG_DOWN_RIGHT_PRED];
  1045.     cur_pred[7][0] = (imgpel) ((P_X + P_V + 2*(P_W) + 2) >> 2);
  1046.     cur_pred[6][0] =
  1047.     cur_pred[7][1] = (imgpel) ((P_W + P_U + 2*(P_V) + 2) >> 2);
  1048.     cur_pred[5][0] =
  1049.     cur_pred[6][1] =
  1050.     cur_pred[7][2] = (imgpel) ((P_V + P_T + 2*(P_U) + 2) >> 2);
  1051.     cur_pred[4][0] =
  1052.     cur_pred[5][1] =
  1053.     cur_pred[6][2] =
  1054.     cur_pred[7][3] = (imgpel) ((P_U + P_S + 2*(P_T) + 2) >> 2);
  1055.     cur_pred[3][0] =
  1056.     cur_pred[4][1] =
  1057.     cur_pred[5][2] =
  1058.     cur_pred[6][3] =
  1059.     cur_pred[7][4] = (imgpel) ((P_T + P_R + 2*(P_S) + 2) >> 2);
  1060.     cur_pred[2][0] =
  1061.     cur_pred[3][1] =
  1062.     cur_pred[4][2] =
  1063.     cur_pred[5][3] =
  1064.     cur_pred[6][4] =
  1065.     cur_pred[7][5] = (imgpel) ((P_S + P_Q + 2*(P_R) + 2) >> 2);
  1066.     cur_pred[1][0] =
  1067.     cur_pred[2][1] =
  1068.     cur_pred[3][2] =
  1069.     cur_pred[4][3] =
  1070.     cur_pred[5][4] =
  1071.     cur_pred[6][5] =
  1072.     cur_pred[7][6] = (imgpel) ((P_R + P_Z + 2*(P_Q) + 2) >> 2);
  1073.     cur_pred[0][0] =
  1074.     cur_pred[1][1] =
  1075.     cur_pred[2][2] =
  1076.     cur_pred[3][3] =
  1077.     cur_pred[4][4] =
  1078.     cur_pred[5][5] =
  1079.     cur_pred[6][6] =
  1080.     cur_pred[7][7] = (imgpel) ((P_Q + P_A + 2*(P_Z) + 2) >> 2);
  1081.     cur_pred[0][1] =
  1082.     cur_pred[1][2] =
  1083.     cur_pred[2][3] =
  1084.     cur_pred[3][4] =
  1085.     cur_pred[4][5] =
  1086.     cur_pred[5][6] =
  1087.     cur_pred[6][7] = (imgpel) ((P_Z + P_B + 2*(P_A) + 2) >> 2);
  1088.     cur_pred[0][2] =
  1089.     cur_pred[1][3] =
  1090.     cur_pred[2][4] =
  1091.     cur_pred[3][5] =
  1092.     cur_pred[4][6] =
  1093.     cur_pred[5][7] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
  1094.     cur_pred[0][3] =
  1095.     cur_pred[1][4] =
  1096.     cur_pred[2][5] =
  1097.     cur_pred[3][6] =
  1098.     cur_pred[4][7] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
  1099.     cur_pred[0][4] =
  1100.     cur_pred[1][5] =
  1101.     cur_pred[2][6] =
  1102.     cur_pred[3][7] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
  1103.     cur_pred[0][5] =
  1104.     cur_pred[1][6] =
  1105.     cur_pred[2][7] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
  1106.     cur_pred[0][6] =
  1107.     cur_pred[1][7] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
  1108.     cur_pred[0][7] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
  1110.     ///////////////////////////////////
  1111.     // make vertical right prediction
  1112.     ///////////////////////////////////
  1113.     cur_pred = curr_mpr_8x8[VERT_RIGHT_PRED];
  1114.     cur_pred[0][0] =
  1115.     cur_pred[2][1] =
  1116.     cur_pred[4][2] =
  1117.     cur_pred[6][3] = (imgpel) ((P_Z + P_A + 1) >> 1);
  1118.     cur_pred[0][1] =
  1119.     cur_pred[2][2] =
  1120.     cur_pred[4][3] =
  1121.     cur_pred[6][4] = (imgpel) ((P_A + P_B + 1) >> 1);
  1122.     cur_pred[0][2] =
  1123.     cur_pred[2][3] =
  1124.     cur_pred[4][4] =
  1125.     cur_pred[6][5] = (imgpel) ((P_B + P_C + 1) >> 1);
  1126.     cur_pred[0][3] =
  1127.     cur_pred[2][4] =
  1128.     cur_pred[4][5] =
  1129.     cur_pred[6][6] = (imgpel) ((P_C + P_D + 1) >> 1);
  1130.     cur_pred[0][4] =
  1131.     cur_pred[2][5] =
  1132.     cur_pred[4][6] =
  1133.     cur_pred[6][7] = (imgpel) ((P_D + P_E + 1) >> 1);
  1134.     cur_pred[0][5] =
  1135.     cur_pred[2][6] =
  1136.     cur_pred[4][7] = (imgpel) ((P_E + P_F + 1) >> 1);
  1137.     cur_pred[0][6] =
  1138.     cur_pred[2][7] = (imgpel) ((P_F + P_G + 1) >> 1);
  1139.     cur_pred[0][7] = (imgpel) ((P_G + P_H + 1) >> 1);
  1140.     cur_pred[1][0] =
  1141.     cur_pred[3][1] =
  1142.     cur_pred[5][2] =
  1143.     cur_pred[7][3] = (imgpel) ((P_Q + P_A + 2*P_Z + 2) >> 2);
  1144.     cur_pred[1][1] =
  1145.     cur_pred[3][2] =
  1146.     cur_pred[5][3] =
  1147.     cur_pred[7][4] = (imgpel) ((P_Z + P_B + 2*P_A + 2) >> 2);
  1148.     cur_pred[1][2] =
  1149.     cur_pred[3][3] =
  1150.     cur_pred[5][4] =
  1151.     cur_pred[7][5] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
  1152.     cur_pred[1][3] =
  1153.     cur_pred[3][4] =
  1154.     cur_pred[5][5] =
  1155.     cur_pred[7][6] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
  1156.     cur_pred[1][4] =
  1157.     cur_pred[3][5] =
  1158.     cur_pred[5][6] =
  1159.     cur_pred[7][7] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
  1160.     cur_pred[1][5] =
  1161.     cur_pred[3][6] =
  1162.     cur_pred[5][7] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
  1163.     cur_pred[1][6] =
  1164.     cur_pred[3][7] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
  1165.     cur_pred[1][7] = (imgpel) ((P_F + P_H + 2*P_G + 2) >> 2);
  1166.     cur_pred[2][0] =
  1167.     cur_pred[4][1] =
  1168.     cur_pred[6][2] = (imgpel) ((P_R + P_Z + 2*P_Q + 2) >> 2);
  1169.     cur_pred[3][0] =
  1170.     cur_pred[5][1] =
  1171.     cur_pred[7][2] = (imgpel) ((P_S + P_Q + 2*P_R + 2) >> 2);
  1172.     cur_pred[4][0] =
  1173.     cur_pred[6][1] = (imgpel) ((P_T + P_R + 2*P_S + 2) >> 2);
  1174.     cur_pred[5][0] =
  1175.     cur_pred[7][1] = (imgpel) ((P_U + P_S + 2*P_T + 2) >> 2);
  1176.     cur_pred[6][0] = (imgpel) ((P_V + P_T + 2*P_U + 2) >> 2);
  1177.     cur_pred[7][0] = (imgpel) ((P_W + P_U + 2*P_V + 2) >> 2);
  1179.     ///////////////////////////////////
  1180.     // make horizontal down prediction
  1181.     ///////////////////////////////////
  1182.     cur_pred = img->mpr_8x8[0][HOR_DOWN_PRED];
  1183.     cur_pred[0][0] =
  1184.     cur_pred[1][2] =
  1185.     cur_pred[2][4] =
  1186.     cur_pred[3][6] = (imgpel) ((P_Q + P_Z + 1) >> 1);
  1187.     cur_pred[1][0] =
  1188.     cur_pred[2][2] =
  1189.     cur_pred[3][4] =
  1190.     cur_pred[4][6] = (imgpel) ((P_R + P_Q + 1) >> 1);
  1191.     cur_pred[2][0] =
  1192.     cur_pred[3][2] =
  1193.     cur_pred[4][4] =
  1194.     cur_pred[5][6] = (imgpel) ((P_S + P_R + 1) >> 1);
  1195.     cur_pred[3][0] =
  1196.     cur_pred[4][2] =
  1197.     cur_pred[5][4] =
  1198.     cur_pred[6][6] = (imgpel) ((P_T + P_S + 1) >> 1);
  1199.     cur_pred[4][0] =
  1200.     cur_pred[5][2] =
  1201.     cur_pred[6][4] =
  1202.     cur_pred[7][6] = (imgpel) ((P_U + P_T + 1) >> 1);
  1203.     cur_pred[5][0] =
  1204.     cur_pred[6][2] =
  1205.     cur_pred[7][4] = (imgpel) ((P_V + P_U + 1) >> 1);
  1206.     cur_pred[6][0] =
  1207.     cur_pred[7][2] = (imgpel) ((P_W + P_V + 1) >> 1);
  1208.     cur_pred[7][0] = (imgpel) ((P_X + P_W + 1) >> 1);
  1209.     cur_pred[0][1] =
  1210.     cur_pred[1][3] =
  1211.     cur_pred[2][5] =
  1212.     cur_pred[3][7] = (imgpel) ((P_Q + P_A + 2*P_Z + 2) >> 2);
  1213.     cur_pred[1][1] =
  1214.     cur_pred[2][3] =
  1215.     cur_pred[3][5] =
  1216.     cur_pred[4][7] = (imgpel) ((P_Z + P_R + 2*P_Q + 2) >> 2);
  1217.     cur_pred[2][1] =
  1218.     cur_pred[3][3] =
  1219.     cur_pred[4][5] =
  1220.     cur_pred[5][7] = (imgpel) ((P_Q + P_S + 2*P_R + 2) >> 2);
  1221.     cur_pred[3][1] =
  1222.     cur_pred[4][3] =
  1223.     cur_pred[5][5] =
  1224.     cur_pred[6][7] = (imgpel) ((P_R + P_T + 2*P_S + 2) >> 2);
  1225.     cur_pred[4][1] =
  1226.     cur_pred[5][3] =
  1227.     cur_pred[6][5] =
  1228.     cur_pred[7][7] = (imgpel) ((P_S + P_U + 2*P_T + 2) >> 2);
  1229.     cur_pred[5][1] =
  1230.     cur_pred[6][3] =
  1231.     cur_pred[7][5] = (imgpel) ((P_T + P_V + 2*P_U + 2) >> 2);
  1232.     cur_pred[6][1] =
  1233.     cur_pred[7][3] = (imgpel) ((P_U + P_W + 2*P_V + 2) >> 2);
  1234.     cur_pred[7][1] = (imgpel) ((P_V + P_X + 2*P_W + 2) >> 2);
  1235.     cur_pred[0][2] =
  1236.     cur_pred[1][4] =
  1237.     cur_pred[2][6] = (imgpel) ((P_Z + P_B + 2*P_A + 2) >> 2);
  1238.     cur_pred[0][3] =
  1239.     cur_pred[1][5] =
  1240.     cur_pred[2][7] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
  1241.     cur_pred[0][4] =
  1242.     cur_pred[1][6] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
  1243.     cur_pred[0][5] =
  1244.     cur_pred[1][7] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
  1245.     cur_pred[0][6] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
  1246.     cur_pred[0][7] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
  1247.   }
  1249.   ///////////////////////////////////
  1250.   // make horizontal up prediction
  1251.   ///////////////////////////////////
  1252.   if (block_available_left)
  1253.   {
  1254.     cur_pred = curr_mpr_8x8[HOR_UP_PRED];
  1255.     cur_pred[0][0] = (imgpel) ((P_Q + P_R + 1) >> 1);
  1256.     cur_pred[1][0] =
  1257.     cur_pred[0][2] = (imgpel) ((P_R + P_S + 1) >> 1);
  1258.     cur_pred[2][0] =
  1259.     cur_pred[1][2] =
  1260.     cur_pred[0][4] = (imgpel) ((P_S + P_T + 1) >> 1);
  1261.     cur_pred[3][0] =
  1262.     cur_pred[2][2] =
  1263.     cur_pred[1][4] =
  1264.     cur_pred[0][6] = (imgpel) ((P_T + P_U + 1) >> 1);
  1265.     cur_pred[4][0] =
  1266.     cur_pred[3][2] =
  1267.     cur_pred[2][4] =
  1268.     cur_pred[1][6] = (imgpel) ((P_U + P_V + 1) >> 1);
  1269.     cur_pred[5][0] =
  1270.     cur_pred[4][2] =
  1271.     cur_pred[3][4] =
  1272.     cur_pred[2][6] = (imgpel) ((P_V + P_W + 1) >> 1);
  1273.     cur_pred[6][0] =
  1274.     cur_pred[5][2] =
  1275.     cur_pred[4][4] =
  1276.     cur_pred[3][6] = (imgpel) ((P_W + P_X + 1) >> 1);
  1277.     cur_pred[4][6] =
  1278.     cur_pred[4][7] =
  1279.     cur_pred[5][4] =
  1280.     cur_pred[5][5] =
  1281.     cur_pred[5][6] =
  1282.     cur_pred[5][7] =
  1283.     cur_pred[6][2] =
  1284.     cur_pred[6][3] =
  1285.     cur_pred[6][4] =
  1286.     cur_pred[6][5] =
  1287.     cur_pred[6][6] =
  1288.     cur_pred[6][7] =
  1289.     cur_pred[7][0] =
  1290.     cur_pred[7][1] =
  1291.     cur_pred[7][2] =
  1292.     cur_pred[7][3] =
  1293.     cur_pred[7][4] =
  1294.     cur_pred[7][5] =
  1295.     cur_pred[7][6] =
  1296.     cur_pred[7][7] = (imgpel) P_X;
  1297.     cur_pred[6][1] =
  1298.     cur_pred[5][3] =
  1299.     cur_pred[4][5] =
  1300.     cur_pred[3][7] = (imgpel) ((P_W + 3*P_X + 2) >> 2);
  1301.     cur_pred[5][1] =
  1302.     cur_pred[4][3] =
  1303.     cur_pred[3][5] =
  1304.     cur_pred[2][7] = (imgpel) ((P_X + P_V + 2*P_W + 2) >> 2);
  1305.     cur_pred[4][1] =
  1306.     cur_pred[3][3] =
  1307.     cur_pred[2][5] =
  1308.     cur_pred[1][7] = (imgpel) ((P_W + P_U + 2*P_V + 2) >> 2);
  1309.     cur_pred[3][1] =
  1310.     cur_pred[2][3] =
  1311.     cur_pred[1][5] =
  1312.     cur_pred[0][7] = (imgpel) ((P_V + P_T + 2*P_U + 2) >> 2);
  1313.     cur_pred[2][1] =
  1314.     cur_pred[1][3] =
  1315.     cur_pred[0][5] = (imgpel) ((P_U + P_S + 2*P_T + 2) >> 2);
  1316.     cur_pred[1][1] =
  1317.     cur_pred[0][3] = (imgpel) ((P_T + P_R + 2*P_S + 2) >> 2);
  1318.     cur_pred[0][1] = (imgpel) ((P_S + P_Q + 2*P_R + 2) >> 2);
  1319.   }
  1320. }
  1322. /*!
  1323.  *************************************************************************************
  1324.  * brief
  1325.  *    Prefiltering for Intra8x8 prediction
  1326.  *************************************************************************************
  1327.  */
  1328. void LowPassForIntra8x8Pred(imgpel *PredPel, int block_up_left, int block_up, int block_left)
  1329. {
  1330.   int i;
  1331.   static imgpel LoopArray[25];
  1333.   memcpy(LoopArray,PredPel, 25 * sizeof(imgpel));
  1335.   if(block_up)
  1336.   {
  1337.     if(block_up_left)
  1338.     {
  1339.       LoopArray[1] = ((PredPel[0] + (PredPel[1]<<1) + PredPel[2] + 2)>>2);
  1340.     }
  1341.     else
  1342.       LoopArray[1] = ((PredPel[1] + (PredPel[1]<<1) + PredPel[2] + 2)>>2);
  1345.     for(i = 2; i <16; i++)
  1346.     {
  1347.       LoopArray[i] = ((PredPel[i-1] + (PredPel[i]<<1) + PredPel[i+1] + 2)>>2);
  1348.     }
  1349.     LoopArray[16] = ((P_P + (P_P<<1) + P_O + 2)>>2);
  1350.   }
  1352.   if(block_up_left)
  1353.   {
  1354.     if(block_up && block_left)
  1355.     {
  1356.       LoopArray[0] = ((P_Q + (P_Z<<1) + P_A +2)>>2);
  1357.     }
  1358.     else
  1359.     {
  1360.       if(block_up)
  1361.         LoopArray[0] = ((P_Z + (P_Z<<1) + P_A +2)>>2);
  1362.       else
  1363.         if(block_left)
  1364.           LoopArray[0] = ((P_Z + (P_Z<<1) + P_Q +2)>>2);
  1365.     }
  1366.   }
  1368.   if(block_left)
  1369.   {
  1370.     if(block_up_left)
  1371.       LoopArray[17] = ((P_Z + (P_Q<<1) + P_R + 2)>>2);
  1372.     else
  1373.       LoopArray[17] = ((P_Q + (P_Q<<1) + P_R + 2)>>2);
  1375.     for(i = 18; i <24; i++)
  1376.     {
  1377.       LoopArray[i] = ((PredPel[i-1] + (PredPel[i]<<1) + PredPel[i+1] + 2)>>2);
  1378.     }
  1379.     LoopArray[24] = ((P_W + (P_X<<1) + P_X + 2) >> 2);
  1380.   }
  1382.   memcpy(PredPel, LoopArray, 25 * sizeof(imgpel));
  1383. }
  1386. /*!
  1387.  *************************************************************************************
  1388.  * brief
  1389.  *    R-D Cost for an 8x8 Intra block
  1390.  *************************************************************************************
  1391.  */
  1393. double RDCost_for_8x8IntraBlocks(Macroblock *currMB, int *nonzero, int b8, int ipmode, double lambda, double min_rdcost, int mostProbableMode, int c_nzCbCr[3])
  1394. {
  1395.   double  rdcost = 0.0;
  1396.   int     dummy;
  1397.   int     rate;
  1398.   int64   distortion  = 0;
  1399.   int     block_x     = (b8 & 0x01) << 3;
  1400.   int     block_y     = (b8 >> 1) << 3;
  1401.   int     pic_pix_x   = img->pix_x + block_x;
  1402.   int     pic_pix_y   = img->pix_y + block_y;
  1403.   int     pic_opix_y  = img->opix_y + block_y;
  1405.   Slice          *currSlice =  img->currentSlice;
  1406.   SyntaxElement  se;
  1407.   const int      *partMap   = assignSE2partition[params->partition_mode];
  1408.   DataPartition  *dataPart;
  1410.   //===== perform DCT, Q, IQ, IDCT, Reconstruction =====
  1411.   dummy = 0;
  1413.   *nonzero = pDCT_8x8 (currMB, PLANE_Y, b8, &dummy, 1);
  1415.   //===== get distortion (SSD) of 8x8 block =====
  1416.   distortion += compute_SSE(&pCurImg[pic_opix_y], &enc_picture->imgY[pic_pix_y], pic_pix_x, pic_pix_x, 8, 8);
  1418.   if(img->P444_joined) 
  1419.   {
  1420.     ColorPlane k;
  1422.     for (k = PLANE_U; k <= PLANE_V; k++)
  1423.     {
  1424.       select_plane(k);
  1425.       /*    for (j=0; j<8; j++)   //KHHan, I think these line are not necessary
  1426.       {
  1427.       for (i=0; i<8; i++)
  1428.       {         
  1429.       img->mb_pred[k][block_y+j][block_x+i]  = img->mpr_8x8[k][ipmode][j][i];
  1430.       img->mb_ores[k][j][i] = pImgOrg[k][img->pix_y+block_y+j][img->pix_x+block_x+i] - img->mpr_8x8[k][ipmode][j][i];
  1431.       }
  1432.       }*/
  1433.       c_nzCbCr[k ]= pDCT_8x8(currMB, k, b8, &dummy,1);
  1434.       distortion += compute_SSE(&pImgOrg[k][pic_opix_y], &enc_picture->p_curr_img[pic_pix_y], pic_pix_x, pic_pix_x, 8, 8);
  1435.     }
  1436.   ipmode_DPCM = NO_INTRA_PMODE;
  1437.     select_plane(PLANE_Y);
  1438.   }
  1439.   else if( img->yuv_format==YUV444 && IS_INDEPENDENT(params) )  //For residual DPCM
  1440.   {
  1441.     ipmode_DPCM = NO_INTRA_PMODE;  
  1442.   }
  1444.   //===== RATE for INTRA PREDICTION MODE  (SYMBOL MODE MUST BE SET TO CAVLC) =====
  1445.   se.value1 = (mostProbableMode == ipmode) ? -1 : ipmode < mostProbableMode ? ipmode : ipmode-1;
  1447.   //--- set position and type ---
  1448.   se.context = b8;
  1449.   se.type    = SE_INTRAPREDMODE;
  1451.   //--- choose data partition ---
  1452.   if (img->type!=B_SLICE)
  1453.     dataPart = &(currSlice->partArr[partMap[SE_INTRAPREDMODE]]);
  1454.   else
  1455.     dataPart = &(currSlice->partArr[partMap[SE_BFRAME]]);
  1457.   //--- encode and update rate ---
  1458.   writeIntraPredMode (&se, dataPart);
  1460.   rate = se.len;
  1462.   //===== RATE for LUMINANCE COEFFICIENTS =====
  1464.   if (currSlice->symbol_mode == CAVLC)
  1465.   {      
  1466.     if (img->P444_joined)
  1467.     {
  1468.       int b4;
  1469.       for(b4=0; b4<4; b4++)
  1470.       {
  1471.         rate  += writeCoeff4x4_CAVLC (currMB, LUMA, b8, b4, 0);
  1472.         rate  += writeCoeff4x4_CAVLC (currMB, CB, b8, b4, 0);
  1473.         rate  += writeCoeff4x4_CAVLC (currMB, CR, b8, b4, 0);
  1474.       }
  1475.     }
  1476.     else
  1477.     {
  1478.       rate  += writeCoeff4x4_CAVLC (currMB, LUMA, b8, 0, 0);
  1479.       rate  += writeCoeff4x4_CAVLC (currMB, LUMA, b8, 1, 0);
  1480.       rate  += writeCoeff4x4_CAVLC (currMB, LUMA, b8, 2, 0);
  1481.       rate  += writeCoeff4x4_CAVLC (currMB, LUMA, b8, 3, 0);
  1482.     }
  1483.   }
  1484.   else
  1485.   {
  1486.     rate  += writeCoeff8x8_CABAC (currMB, PLANE_Y, b8, 1);
  1487.     if(img->P444_joined)
  1488.     {
  1489.       rate  += writeCoeff8x8_CABAC (currMB, PLANE_U, b8, 1);
  1490.       rate  += writeCoeff8x8_CABAC (currMB, PLANE_V, b8, 1);
  1491.     }
  1492.   }
  1494.   rdcost = (double)distortion + lambda*(double)rate;
  1496.   return rdcost;
  1497. }
  1499. /*!
  1500.  ************************************************************************
  1501.  * brief
  1502.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  1503.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  1504.  *    RD constrained quantization also.
  1505.  *
  1506.  * par Input:
  1507.  *    b8: Block position inside a macro block (0,1,2,3).
  1508.  *
  1509.  * par Output:
  1510.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.
  1511.  *    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
  1512.  ************************************************************************
  1513.  */
  1514. int dct_8x8(Macroblock *currMB, ColorPlane pl, int b8, int *coeff_cost, int intra)
  1515. {
  1516.   int j;
  1518.   int nonzero = FALSE; 
  1520.   int block_x = 8*(b8 & 0x01);
  1521.   int block_y = 8*(b8 >> 1);
  1522.   int pl_off = b8+ (pl<<2);
  1523.   int*  ACLevel = img->cofAC[pl_off][0][0];
  1524.   int*  ACRun   = img->cofAC[pl_off][0][1];  
  1525.   imgpel **img_enc       = enc_picture->p_curr_img;
  1526.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  1527.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];
  1528.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl];
  1530.   int max_imgpel_value   = img->max_imgpel_value;
  1531.   int qp = currMB->qp_scaled[pl];
  1532.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN8x8 : SNGL_SCAN8x8;
  1534.   int qp_rem = qp_rem_matrix[qp];
  1536.   levelscale    = LevelScale8x8Comp   [pl][intra][qp_rem];
  1537.   invlevelscale = InvLevelScale8x8Comp[pl][intra][qp_rem];
  1538.   leveloffset   = LevelOffset8x8Comp  [pl][intra][qp];
  1540.   fadjust8x8 = img->AdaptiveRounding ? (pl ? &img->fadjust8x8Cr[pl-1][intra][block_y] : &img->fadjust8x8[intra][block_y]) :NULL;
  1542.   // Forward 8x8 transform
  1543.   forward8x8(mb_ores, mb_rres, block_y, block_x);
  1545.   // Quantization process
  1546.   nonzero = quant_8x8(&mb_rres[block_y], block_y, block_x, qp, ACLevel, ACRun, fadjust8x8, 
  1547.     levelscale, invlevelscale, leveloffset, coeff_cost, pos_scan, COEFF_COST8x8[params->disthres]);
  1549.   if (nonzero)
  1550.   {
  1551.     // Inverse 8x8 transform
  1552.     inverse8x8(mb_rres, mb_rres, block_y, block_x);
  1554.     // generate final block
  1555.     SampleReconstruct (img_enc, mb_pred, mb_rres, block_y, block_x, img->pix_y, img->pix_x + block_x, BLOCK_SIZE_8x8, BLOCK_SIZE_8x8, max_imgpel_value, DQ_BITS_8);
  1556.   }
  1557.   else // if (nonzero) => No transformed residual. Just use prediction.
  1558.   {      
  1559.     for( j=block_y; j< block_y + BLOCK_SIZE_8x8; j++)
  1560.     {
  1561.       memcpy(&(img_enc[img->pix_y + j][img->pix_x + block_x]),&(mb_pred[j][block_x]), BLOCK_SIZE_8x8 * sizeof(imgpel));
  1562.     }
  1563.   }  
  1565.   //  Decoded block moved to frame memory
  1566.   return nonzero;
  1567. }
  1569. /*!
  1570.  ************************************************************************
  1571.  * brief
  1572.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  1573.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  1574.  *    RD constrained quantization also. Used for CAVLC.
  1575.  *
  1576.  * par Input:
  1577.  *    b8: Block position inside a macro block (0,1,2,3).
  1578.  *
  1579.  * par Output:
  1580.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.
  1581.  *    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
  1582.  ************************************************************************
  1583.  */
  1584. int dct_8x8_cavlc(Macroblock *currMB, ColorPlane pl, int b8, int *coeff_cost, int intra)
  1585. {
  1586.   int j;
  1587.   int nonzero = FALSE; 
  1589.   int block_x = 8*(b8 & 0x01);
  1590.   int block_y = 8*(b8 >> 1);
  1591.   int pl_off = b8+ (pl<<2);
  1592.   imgpel **img_enc = enc_picture->p_curr_img;
  1593.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];  
  1594.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];   
  1595.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl];   
  1597.   int max_imgpel_value   = img->max_imgpel_value;
  1599.   int qp = currMB->qp_scaled[pl];
  1600.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN8x8 : SNGL_SCAN8x8;
  1602.   int qp_rem = qp_rem_matrix[qp];
  1604.   levelscale    = LevelScale8x8Comp   [pl][intra][qp_rem];
  1605.   invlevelscale = InvLevelScale8x8Comp[pl][intra][qp_rem];
  1606.   leveloffset   = LevelOffset8x8Comp  [pl][intra][qp];
  1608.   fadjust8x8 = img->AdaptiveRounding ? (pl ? &img->fadjust8x8Cr[pl-1][intra][block_y] : &img->fadjust8x8[intra][block_y]) :NULL;
  1610.   // Forward 8x8 transform
  1611.   forward8x8(mb_ores, mb_rres, block_y, block_x);
  1613.   // Quantization process
  1614.   nonzero = quant_8x8cavlc(&mb_rres[block_y], block_y, block_x, qp, img->cofAC[pl_off], fadjust8x8, 
  1615.     levelscale, invlevelscale, leveloffset, coeff_cost, pos_scan, COEFF_COST8x8[params->disthres]);
  1617.   if (nonzero)
  1618.   {
  1619.     // Inverse 8x8 transform
  1620.     inverse8x8(mb_rres, mb_rres, block_y, block_x);
  1622.     // generate final block
  1623.     SampleReconstruct (img_enc, mb_pred, mb_rres, block_y, block_x, img->pix_y, img->pix_x + block_x, BLOCK_SIZE_8x8, BLOCK_SIZE_8x8, max_imgpel_value, DQ_BITS_8);
  1624.   }
  1625.   else // if (nonzero) => No transformed residual. Just use prediction.
  1626.   {      
  1627.     for( j=block_y; j< block_y + BLOCK_SIZE_8x8; j++)
  1628.     {
  1629.       memcpy(&(img_enc[img->pix_y + j][img->pix_x + block_x]),&(mb_pred[j][block_x]), BLOCK_SIZE_8x8 * sizeof(imgpel));
  1630.     }
  1631.   }  
  1633.   //  Decoded block moved to frame memory
  1634.   return nonzero;
  1635. }
  1637. int dct_8x8_ls(Macroblock *currMB, ColorPlane pl, int b8, int *coeff_cost, int intra)
  1638. {
  1639.   int i,j,coeff_ctr;
  1640.   int scan_pos = 0,run = -1;
  1641.   int nonzero = FALSE;  
  1643.   int block_x = 8*(b8 & 0x01);
  1644.   int block_y = 8*(b8 >> 1);
  1645.   int pl_off = b8 + (pl<<2);
  1646.   int*  ACLevel = img->cofAC[pl_off][0][0];
  1647.   int*  ACRun   = img->cofAC[pl_off][0][1];  
  1648.   imgpel **img_enc       = enc_picture->p_curr_img;
  1649.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  1650.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];
  1651.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl];
  1653.   int scan_poss[4] = { 0 }, runs[4] = { -1, -1, -1, -1 };
  1654.   int MCcoeff = 0;
  1655.   int *m7;
  1656.   int is_cavlc = (img->currentSlice->symbol_mode == CAVLC);
  1658.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN8x8 : SNGL_SCAN8x8;
  1660.   int **fadjust8x8 = img->AdaptiveRounding ? (pl ? &img->fadjust8x8Cr[pl-1][intra][block_y] : &img->fadjust8x8[intra][block_y]) :NULL;
  1662.   runs[0]=runs[1]=runs[2]=runs[3]=-1;
  1663.   scan_poss[0] = scan_poss[1] = scan_poss[2] = scan_poss[3] = 0;
  1665.   if( (ipmode_DPCM < 2)&&(intra))
  1666.   {
  1667.     Residual_DPCM_8x8(ipmode_DPCM, mb_ores, mb_rres, block_y, block_x);
  1668.   }
  1670.   for (coeff_ctr=0; coeff_ctr < 64; coeff_ctr++)
  1671.   {
  1672.     i=pos_scan[coeff_ctr][0];
  1673.     j=pos_scan[coeff_ctr][1];
  1675.     run++;
  1677.     if (currMB->luma_transform_size_8x8_flag && is_cavlc)
  1678.     {
  1679.       MCcoeff = (coeff_ctr & 3);
  1680.       runs[MCcoeff]++;
  1681.     }
  1683.     m7 = &mb_rres[block_y + j][block_x + i];
  1685.     if (img->AdaptiveRounding)
  1686.     {
  1687.       fadjust8x8[j][block_x+i] = 0;
  1688.     }
  1690.     if (*m7 != 0)
  1691.     {
  1692.       nonzero = TRUE;
  1694.       if (currMB->luma_transform_size_8x8_flag && is_cavlc)
  1695.       {
  1696.         *m7 = iClip3(-CAVLC_LEVEL_LIMIT, CAVLC_LEVEL_LIMIT, *m7);
  1697.         *coeff_cost += MAX_VALUE;
  1699.         img->cofAC[pl_off][MCcoeff][0][scan_poss[MCcoeff]  ] = *m7;
  1700.         img->cofAC[pl_off][MCcoeff][1][scan_poss[MCcoeff]++] = runs[MCcoeff];
  1701.         ++scan_pos;
  1702.         runs[MCcoeff]=-1;
  1703.       }
  1704.       else
  1705.       {
  1706.         *coeff_cost += MAX_VALUE;
  1707.         ACLevel[scan_pos  ] = *m7;
  1708.         ACRun  [scan_pos++] = run;
  1709.         run=-1;                     // reset zero level counter
  1710.       }
  1711.     }
  1712.   }
  1714.   if (!currMB->luma_transform_size_8x8_flag || !is_cavlc)
  1715.     ACLevel[scan_pos] = 0;
  1716.   else
  1717.   {
  1718.     for(i=0; i<4; i++)
  1719.       img->cofAC[pl_off][i][0][scan_poss[i]] = 0;
  1720.   }
  1722.   if( (ipmode_DPCM < 2) && (intra))
  1723.   {
  1724.     Inv_Residual_DPCM_8x8(mb_rres, block_y, block_x);
  1725.   }
  1727.   for( j=block_y; j<block_y + BLOCK_SIZE_8x8; j++)
  1728.   {            
  1729.     for( i=block_x; i< block_x + BLOCK_SIZE_8x8; i++)
  1730.     {
  1731.       mb_rres[j][i] += mb_pred[j][i];
  1732.       img_enc[img->pix_y + j][img->pix_x + i]= (imgpel) mb_rres[j][i];
  1733.     }
  1734.   }  
  1736.   //  Decoded block moved to frame memory
  1737.   return nonzero;
  1738. }
  1741. /*static inline void compute_diff(int *diff, imgpel *cimg, imgpel *cmpr, int width)
  1742. {
  1743.   int i;
  1744.   for (i = 0; i < width; i++)
  1745.   {
  1746.     *(diff++) = *(cimg++) - *(cmpr++);
  1747.   }
  1748. }*/
  1749. /*!
  1750. *************************************************************************************
  1751. * brief
  1752. *     distortion for an 8x8 Intra block 
  1753. *************************************************************************************
  1754. */
  1755. void compute_comp_cost8x8(imgpel **cur_img, imgpel mpr8x8[16][16], int pic_opix_x, double *cost)
  1756. {
  1757.   int i, j;
  1758.   int *diff = &diff64[0];
  1759.   imgpel *cimg, *cmpr;
  1761.   for (j=0; j<8; j++)
  1762.   {
  1763.   //  compute_diff(diff, &cur_img[j][pic_opix_x], &mpr8x8[j][0], BLOCK_SIZE_8x8);
  1765.     cimg = &cur_img[j][pic_opix_x];
  1766.     cmpr = &mpr8x8[j][0];
  1767.     for (i=0; i<8; i++)
  1768.     {
  1769.       *diff++ = *cimg++ - *cmpr++;
  1770.     }
  1772.   }
  1773.   *cost += distortion8x8 (diff64);
  1774. }