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

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

Audio

开发平台：

Visual C++

block.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file block.c
  5.  *
  6.  * brief
  7.  *    Process one block
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Inge Lille-Langoy               <inge.lille-langoy@telenor.com>
  12.  *    - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  13.  *    - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  14.  *    - Jani Lainema                    <jani.lainema@nokia.com>
  15.  *    - Detlev Marpe                    <marpe@hhi.de>
  16.  *    - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
  17.  *    - Ragip Kurceren                  <ragip.kurceren@nokia.com>
  18.  *    - Greg Conklin                    <gregc@real.com>
  19.  *************************************************************************************
  20.  */
  22. #include "contributors.h"
  24. #include <math.h>
  26. #include "global.h"
  27. #include "enc_statistics.h"
  29. #include "image.h"
  30. #include "mb_access.h"
  31. #include "block.h"
  32. #include "vlc.h"
  33. #include "transform.h"
  34. #include "mc_prediction.h"
  35. #include "q_offsets.h"
  36. #include "q_matrix.h"
  37. #include "quant4x4.h"
  38. #include "quantChroma.h"
  40. // Notation for comments regarding prediction and predictors.
  41. // The pels of the 4x4 block are labelled a..p. The predictor pels above
  42. // are labelled A..H, from the left I..P, and from above left X, as follows:
  43. //
  44. //  X A B C D E F G H
  45. //  I a b c d
  46. //  J e f g h
  47. //  K i j k l
  48. //  L m n o p
  49. //
  51. // Predictor array index definitions
  52. #define P_X (PredPel[0])
  53. #define P_A (PredPel[1])
  54. #define P_B (PredPel[2])
  55. #define P_C (PredPel[3])
  56. #define P_D (PredPel[4])
  57. #define P_E (PredPel[5])
  58. #define P_F (PredPel[6])
  59. #define P_G (PredPel[7])
  60. #define P_H (PredPel[8])
  61. #define P_I (PredPel[9])
  62. #define P_J (PredPel[10])
  63. #define P_K (PredPel[11])
  64. #define P_L (PredPel[12])
  66. extern const unsigned char subblk_offset_y[3][8][4];
  67. extern const unsigned char subblk_offset_x[3][8][4];
  68. // global pointers for 4x4 quantization parameters
  69. extern int ****ptLevelOffset4x4;
  70. static int **levelscale = NULL, **leveloffset = NULL;
  71. static int **invlevelscale = NULL;
  72. static int **levelscale_sp = NULL, **leveloffset_sp = NULL;
  73. static int **invlevelscale_sp = NULL;
  74. static int **fadjust4x4 = NULL;
  75. static int **fadjust2x2 = NULL;
  76. static int **fadjust4x2 = NULL; // note that this is in fact 2x4 but the coefficients have been transposed for better memory access
  77. static int **levelscaleDC = NULL, **leveloffsetDC = NULL;
  78. static int **invlevelscaleDC = NULL;
  79. static int M1[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
  80. static int M4[4][4];
  82. //For residual DPCM
  83. static int Residual_DPCM_4x4_for_Intra16x16(int mb_ores[4][4], int ipmode);
  84. static int Inv_Residual_DPCM_4x4_for_Intra16x16(int m7[4][4], int ipmode);
  85. static int Residual_DPCM_4x4(int ipmode, int mb_ores[16][16], int mb_rres[16][16], int block_y, int block_x);  
  86. static int Inv_Residual_DPCM_4x4(int m7[16][16], int block_y, int block_x);
  88. /*!
  89.  ************************************************************************
  90.  * brief
  91.  *    Make intra 4x4 prediction according to all 9 prediction modes.
  92.  *    The routine uses left and upper neighbouring points from
  93.  *    previous coded blocks to do this (if available). Notice that
  94.  *    inaccessible neighbouring points are signalled with a negative
  95.  *    value in the predmode array .
  96.  *
  97.  *  par Input:
  98.  *     Starting point of current 4x4 block image posision
  99.  *
  100.  *  par Output:
  101.  *      none
  102.  ************************************************************************
  103.  */
  104. void intrapred_4x4(Macroblock *currMB, ColorPlane pl, int img_x,int img_y, int *left_available, int *up_available, int *all_available)
  105. {
  106.   int i,j;
  107.   int s0;
  108.   imgpel  PredPel[13];  // array of predictor pels
  109.   imgpel  **img_enc = enc_picture->p_curr_img;
  110.   imgpel  *img_pel;  
  111.   imgpel (*cur_pred)[MB_BLOCK_SIZE];
  112.   imgpel (*curr_mpr_4x4)[MB_BLOCK_SIZE][MB_BLOCK_SIZE]  = img->mpr_4x4[pl];
  113.   unsigned int dc_pred_value = img->dc_pred_value;
  115.   int ioff = (img_x & 15);
  116.   int joff = (img_y & 15);
  118.   PixelPos pix_a[4];
  119.   PixelPos pix_b, pix_c, pix_d;
  121.   int block_available_up;
  122.   int block_available_left;
  123.   int block_available_up_left;
  124.   int block_available_up_right;
  125.   int *mb_size = img->mb_size[IS_LUMA];
  127.   for (i=0;i<4;i++)
  128.   {
  129.     getNeighbour(currMB, ioff -1 , joff +i , mb_size, &pix_a[i]);
  130.   }
  132.   getNeighbour(currMB, ioff    , joff -1 , mb_size, &pix_b);
  133.   getNeighbour(currMB, ioff +4 , joff -1 , mb_size, &pix_c);
  134.   getNeighbour(currMB, ioff -1 , joff -1 , mb_size, &pix_d);
  136.   pix_c.available = pix_c.available && !((ioff==4) && ((joff==4)||(joff==12)));
  138.   if (params->UseConstrainedIntraPred)
  139.   {
  140.     for (i=0, block_available_left=1; i<4;i++)
  141.       block_available_left  &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
  142.     block_available_up       = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
  143.     block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
  144.     block_available_up_left  = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
  145.   }
  146.   else
  147.   {
  148.     block_available_left     = pix_a[0].available;
  149.     block_available_up       = pix_b.available;
  150.     block_available_up_right = pix_c.available;
  151.     block_available_up_left  = pix_d.available;
  152.   }
  154.   *left_available = block_available_left;
  155.   *up_available   = block_available_up;
  156.   *all_available  = block_available_up && block_available_left && block_available_up_left;
  158.   i = (img_x & 15);
  159.   j = (img_y & 15);
  161.   // form predictor pels
  162.   if (block_available_up)
  163.   {
  164.     img_pel = &img_enc[pix_b.pos_y][pix_b.pos_x];
  165.     P_A = *(img_pel++);
  166.     P_B = *(img_pel++);
  167.     P_C = *(img_pel++);
  168.     P_D = *(img_pel);
  170.   }
  171.   else
  172.   {
  173.     P_A = P_B = P_C = P_D = dc_pred_value;
  174.   }
  176.   if (block_available_up_right)
  177.   {
  178.     img_pel = &img_enc[pix_c.pos_y][pix_c.pos_x];
  179.     P_E = *(img_pel++);
  180.     P_F = *(img_pel++);
  181.     P_G = *(img_pel++);
  182.     P_H = *(img_pel);
  183.   }
  184.   else
  185.   {
  186.     P_E = P_F = P_G = P_H = P_D;
  187.   }
  189.   if (block_available_left)
  190.   {
  191.     P_I = img_enc[pix_a[0].pos_y][pix_a[0].pos_x];
  192.     P_J = img_enc[pix_a[1].pos_y][pix_a[1].pos_x];
  193.     P_K = img_enc[pix_a[2].pos_y][pix_a[2].pos_x];
  194.     P_L = img_enc[pix_a[3].pos_y][pix_a[3].pos_x];
  195.   }
  196.   else
  197.   {
  198.     P_I = P_J = P_K = P_L = dc_pred_value;
  199.   }
  201.   if (block_available_up_left)
  202.   {
  203.     P_X = img_enc[pix_d.pos_y][pix_d.pos_x];
  204.   }
  205.   else
  206.   {
  207.     P_X = dc_pred_value;
  208.   }
  209.   for(i=0;i<9;i++)
  210.     curr_mpr_4x4[i][0][0]=-1;
  212.   ///////////////////////////////
  213.   // make DC prediction
  214.   ///////////////////////////////
  215.   s0 = 0;
  216.   if (block_available_up && block_available_left)
  217.   {
  218.     // no edge
  219.     s0 = (P_A + P_B + P_C + P_D + P_I + P_J + P_K + P_L + 4) >> (BLOCK_SHIFT + 1);
  220.   }
  221.   else if (!block_available_up && block_available_left)
  222.   {
  223.     // upper edge
  224.     s0 = (P_I + P_J + P_K + P_L + 2) >> BLOCK_SHIFT;;
  225.   }
  226.   else if (block_available_up && !block_available_left)
  227.   {
  228.     // left edge
  229.     s0 = (P_A + P_B + P_C + P_D + 2) >> BLOCK_SHIFT;
  230.   }
  231.   else //if (!block_available_up && !block_available_left)
  232.   {
  233.     // top left corner, nothing to predict from
  234.     s0 = dc_pred_value;
  235.   }
  237.   // store DC prediction
  238.   cur_pred = curr_mpr_4x4[DC_PRED];
  239.   for (j=0; j < BLOCK_SIZE; j++)
  240.   {
  241.     for (i=0; i < BLOCK_SIZE; i++)
  242.       cur_pred[j][i] = (imgpel) s0;
  243.   }
  245.   ///////////////////////////////
  246.   // make horiz and vert prediction
  247.   ///////////////////////////////
  249.   //Mode vertical
  250.   cur_pred = curr_mpr_4x4[VERT_PRED];
  251.   for (i=0; i < BLOCK_SIZE; i++)
  252.   {
  253.     cur_pred[0][i] =
  254.     cur_pred[1][i] =
  255.     cur_pred[2][i] =
  256.     cur_pred[3][i] = (imgpel) (&P_A)[i];
  257.   }
  258.   if(!block_available_up)
  259.     cur_pred [0][0]=-1;
  261.   //Mode horizontal
  262.   cur_pred = curr_mpr_4x4[HOR_PRED];
  263.   for (i=0; i < BLOCK_SIZE; i++)
  264.   {
  265.     cur_pred[i][0]  =
  266.     cur_pred[i][1]  =
  267.     cur_pred[i][2]  =
  268.     cur_pred[i][3]  = (imgpel) (&P_I)[i];
  269.   }
  270.   if(!block_available_left)
  271.     cur_pred[0][0]=-1;
  273.   if (block_available_up)
  274.   {
  275.     // Mode DIAG_DOWN_LEFT_PRED
  276.     cur_pred = curr_mpr_4x4[DIAG_DOWN_LEFT_PRED];
  277.     cur_pred[0][0] = (imgpel) ((P_A + P_C + ((P_B)<<1) + 2) >> 2);
  278.     cur_pred[0][1] =
  279.     cur_pred[1][0] = (imgpel) ((P_B + P_D + ((P_C)<<1) + 2) >> 2);
  280.     cur_pred[0][2] =
  281.     cur_pred[1][1] =
  282.     cur_pred[2][0] = (imgpel) ((P_C + P_E + ((P_D)<<1) + 2) >> 2);
  283.     cur_pred[0][3] =
  284.     cur_pred[1][2] =
  285.     cur_pred[2][1] =
  286.     cur_pred[3][0] = (imgpel) ((P_D + P_F + ((P_E)<<1) + 2) >> 2);
  287.     cur_pred[1][3] =
  288.     cur_pred[2][2] =
  289.     cur_pred[3][1] = (imgpel) ((P_E + P_G + ((P_F)<<1) + 2) >> 2);
  290.     cur_pred[2][3] =
  291.     cur_pred[3][2] = (imgpel) ((P_F + P_H + ((P_G)<<1) + 2) >> 2);
  292.     cur_pred[3][3] = (imgpel) ((P_G + 3*(P_H) + 2) >> 2);
  294.     // Mode VERT_LEFT_PRED
  295.     cur_pred = curr_mpr_4x4[VERT_LEFT_PRED];
  296.     cur_pred[0][0] = (imgpel) ((P_A + P_B + 1) >> 1);
  297.     cur_pred[0][1] =
  298.     cur_pred[2][0] = (imgpel) ((P_B + P_C + 1) >> 1);
  299.     cur_pred[0][2] =
  300.     cur_pred[2][1] = (imgpel) ((P_C + P_D + 1) >> 1);
  301.     cur_pred[0][3] =
  302.     cur_pred[2][2] = (imgpel) ((P_D + P_E + 1) >> 1);
  303.     cur_pred[2][3] = (imgpel) ((P_E + P_F + 1) >> 1);
  304.     cur_pred[1][0] = (imgpel) ((P_A + ((P_B)<<1) + P_C + 2) >> 2);
  305.     cur_pred[1][1] =
  306.     cur_pred[3][0] = (imgpel) ((P_B + ((P_C)<<1) + P_D + 2) >> 2);
  307.     cur_pred[1][2] =
  308.     cur_pred[3][1] = (imgpel) ((P_C + ((P_D)<<1) + P_E + 2) >> 2);
  309.     cur_pred[1][3] =
  310.     cur_pred[3][2] = (imgpel) ((P_D + ((P_E)<<1) + P_F + 2) >> 2);
  311.     cur_pred[3][3] = (imgpel) ((P_E + ((P_F)<<1) + P_G + 2) >> 2);
  313.   }
  315.   /*  Prediction according to 'diagonal' modes */
  316.   if (block_available_left)
  317.   {
  318.     // Mode HOR_UP_PRED
  319.     cur_pred = curr_mpr_4x4[HOR_UP_PRED];
  320.     cur_pred[0][0] = (imgpel) ((P_I + P_J + 1) >> 1);
  321.     cur_pred[0][1] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
  322.     cur_pred[0][2] =
  323.     cur_pred[1][0] = (imgpel) ((P_J + P_K + 1) >> 1);
  324.     cur_pred[0][3] =
  325.     cur_pred[1][1] = (imgpel) ((P_J + 2*P_K + P_L + 2) >> 2);
  326.     cur_pred[1][2] =
  327.     cur_pred[2][0] = (imgpel) ((P_K + P_L + 1) >> 1);
  328.     cur_pred[1][3] =
  329.     cur_pred[2][1] = (imgpel) ((P_K + 2*P_L + P_L + 2) >> 2);
  330.     cur_pred[3][0] =
  331.     cur_pred[2][2] =
  332.     cur_pred[2][3] =
  333.     cur_pred[3][1] =
  334.     cur_pred[3][2] =
  335.     cur_pred[3][3] = (imgpel) P_L;
  336.   }
  338.   /*  Prediction according to 'diagonal' modes */
  339.   if (block_available_up && block_available_left && block_available_up_left)
  340.   {
  341.     // Mode DIAG_DOWN_RIGHT_PRED
  342.     cur_pred = curr_mpr_4x4[DIAG_DOWN_RIGHT_PRED];
  343.     cur_pred[3][0] = (imgpel) ((P_L + 2*P_K + P_J + 2) >> 2);
  344.     cur_pred[2][0] =
  345.     cur_pred[3][1] = (imgpel) ((P_K + 2*P_J + P_I + 2) >> 2);
  346.     cur_pred[1][0] =
  347.     cur_pred[2][1] =
  348.     cur_pred[3][2] = (imgpel) ((P_J + 2*P_I + P_X + 2) >> 2);
  349.     cur_pred[0][0] =
  350.     cur_pred[1][1] =
  351.     cur_pred[2][2] =
  352.     cur_pred[3][3] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
  353.     cur_pred[0][1] =
  354.     cur_pred[1][2] =
  355.     cur_pred[2][3] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
  356.     cur_pred[0][2] =
  357.     cur_pred[1][3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  358.     cur_pred[0][3] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
  360.     // Mode VERT_RIGHT_PRED
  361.     cur_pred = curr_mpr_4x4[VERT_RIGHT_PRED];
  362.     cur_pred[0][0] =
  363.     cur_pred[2][1] = (imgpel) ((P_X + P_A + 1) >> 1);
  364.     cur_pred[0][1] =
  365.     cur_pred[2][2] = (imgpel) ((P_A + P_B + 1) >> 1);
  366.     cur_pred[0][2] =
  367.     cur_pred[2][3] = (imgpel) ((P_B + P_C + 1) >> 1);
  368.     cur_pred[0][3] = (imgpel) ((P_C + P_D + 1) >> 1);
  369.     cur_pred[1][0] =
  370.     cur_pred[3][1] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
  371.     cur_pred[1][1] =
  372.     cur_pred[3][2] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
  373.     cur_pred[1][2] =
  374.     cur_pred[3][3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  375.     cur_pred[1][3] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
  376.     cur_pred[2][0] = (imgpel) ((P_X + 2*P_I + P_J + 2) >> 2);
  377.     cur_pred[3][0] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
  379.     // Mode HOR_DOWN_PRED
  380.     cur_pred = curr_mpr_4x4[HOR_DOWN_PRED];
  381.     cur_pred[0][0] =
  382.     cur_pred[1][2] = (imgpel) ((P_X + P_I + 1) >> 1);
  383.     cur_pred[0][1] =
  384.     cur_pred[1][3] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
  385.     cur_pred[0][2] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
  386.     cur_pred[0][3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  387.     cur_pred[1][0] =
  388.     cur_pred[2][2] = (imgpel) ((P_I + P_J + 1) >> 1);
  389.     cur_pred[1][1] =
  390.     cur_pred[2][3] = (imgpel) ((P_X + 2*P_I + P_J + 2) >> 2);
  391.     cur_pred[2][0] =
  392.     cur_pred[3][2] = (imgpel) ((P_J + P_K + 1) >> 1);
  393.     cur_pred[2][1] =
  394.     cur_pred[3][3] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
  395.     cur_pred[3][0] = (imgpel) ((P_K + P_L + 1) >> 1);
  396.     cur_pred[3][1] = (imgpel) ((P_J + 2*P_K + P_L + 2) >> 2);
  397.   }
  398. }
  401. /*!
  402.  ************************************************************************
  403.  * brief
  404.  *    16x16 based luma prediction
  405.  *
  406.  * par Input:
  407.  *    Image parameters
  408.  *
  409.  * par Output:
  410.  *    none
  411.  ************************************************************************
  412.  */
  413. void intrapred_16x16(Macroblock *currMB, ColorPlane pl)
  414. {
  415.   int s0=0,s1,s2;
  416.   imgpel s[2][16];
  417.   int i,j;
  419.   int ih,iv;
  420.   int ib,ic,iaa;
  422.   imgpel **img_enc = enc_picture->p_curr_img;
  423.   imgpel (*curr_mpr_16x16)[MB_BLOCK_SIZE][MB_BLOCK_SIZE]  = img->mpr_16x16[pl];
  424.   unsigned int dc_pred_value = img->dc_pred_value;
  426.   PixelPos up;          //!< pixel position p(0,-1)
  427.   PixelPos left[17];    //!< pixel positions p(-1, -1..15)
  429.   int up_avail, left_avail, left_up_avail;
  430.   int *mb_size = img->mb_size[IS_LUMA];
  432.   for (i=0;i<17;i++)
  433.   {
  434.     getNeighbour(currMB, -1,  i-1, mb_size, &left[i]);
  435.   }
  437.   getNeighbour(currMB,    0,   -1, mb_size, &up);
  439.   if (!(params->UseConstrainedIntraPred))
  440.   {
  441.     up_avail      = up.available;
  442.     left_avail    = left[1].available;
  443.     left_up_avail = left[0].available;
  444.   }
  445.   else
  446.   {
  447.     up_avail      = up.available ? img->intra_block[up.mb_addr] : 0;
  448.     for (i=1, left_avail=1; i<17;i++)
  449.       left_avail  &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
  450.     left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  451.   }
  453.   s1=s2=0;
  454.   // make DC prediction
  455.   if (up_avail)
  456.   {
  457.     for (i=up.pos_x; i < up.pos_x + MB_BLOCK_SIZE; i++)
  458.       s1 += img_enc[up.pos_y][i];    // sum hor pix
  459.   }
  461.   if (left_avail)
  462.   {
  463.     for (i=1; i < MB_BLOCK_SIZE + 1; i++)
  464.       s2 += img_enc[left[i].pos_y][left[i].pos_x];    // sum vert pix
  465.   }
  467.   if (up_avail)
  468.   {
  469.     s0= left_avail
  470.       ? rshift_rnd_sf((s1+s2),(MB_BLOCK_SHIFT + 1)) // no edge
  471.       : rshift_rnd_sf(s1, MB_BLOCK_SHIFT);          // left edge
  472.   }
  473.   else
  474.   {
  475.     s0=left_avail
  476.       ? rshift_rnd_sf(s2, MB_BLOCK_SHIFT)           // upper edge
  477.       : dc_pred_value;                              // top left corner, nothing to predict from
  478.   }
  480.   // vertical prediction
  481.   if (up_avail)
  482.     memcpy(s[0], &img_enc[up.pos_y][up.pos_x], MB_BLOCK_SIZE * sizeof(imgpel));
  484.   // horizontal prediction
  485.   if (left_avail)
  486.   {
  487.     for (i=1; i < MB_BLOCK_SIZE + 1; i++)
  488.       s[1][i - 1]=img_enc[left[i].pos_y][left[i].pos_x];
  489.   }
  491.   for (j=0; j < MB_BLOCK_SIZE; j++)
  492.   {
  493.     memcpy(curr_mpr_16x16[VERT_PRED_16][j], s[0], MB_BLOCK_SIZE * sizeof(imgpel)); // store vertical prediction
  494.     for (i=0; i < MB_BLOCK_SIZE; i++)
  495.     {
  496.       curr_mpr_16x16[HOR_PRED_16 ][j][i] = s[1][j]; // store horizontal prediction
  497.       curr_mpr_16x16[DC_PRED_16  ][j][i] = s0;      // store DC prediction
  498.     }
  499.   }
  500.   
  501.   if (!up_avail || !left_avail || !left_up_avail) // edge
  502.     return;
  504.   // 16 bit integer plan pred
  506.   ih=0;
  507.   iv=0;
  508.   for (i=1;i<9;i++)
  509.   {
  510.     if (i<8)
  511.       ih += i*(img_enc[up.pos_y][up.pos_x+7+i] - img_enc[up.pos_y][up.pos_x+7-i]);
  512.     else
  513.       ih += i*(img_enc[up.pos_y][up.pos_x+7+i] - img_enc[left[0].pos_y][left[0].pos_x]);
  515.     iv += i*(img_enc[left[8+i].pos_y][left[8+i].pos_x] - img_enc[left[8-i].pos_y][left[8-i].pos_x]);
  516.   }
  517.   ib=(5*ih+32)>>6;
  518.   ic=(5*iv+32)>>6;
  520.   iaa=16*(img_enc[up.pos_y][up.pos_x+15]+img_enc[left[16].pos_y][left[16].pos_x]);
  522.   for (j=0;j< MB_BLOCK_SIZE;j++)
  523.   {
  524.     for (i=0;i< MB_BLOCK_SIZE;i++)
  525.     {
  526.       curr_mpr_16x16[PLANE_16][j][i]= iClip1( img->max_imgpel_value, rshift_rnd_sf((iaa+(i-7)*ib +(j-7)*ic), 5));// store plane prediction
  527.     }
  528.   }
  529. }
  532. /*!
  533.  ************************************************************************
  534.  * brief
  535.  *    For new intra pred routines
  536.  *
  537.  * par Input:
  538.  *    Image par, 16x16 based intra mode
  539.  *
  540.  * par Output:
  541.  *    none
  542.  ************************************************************************
  543.  */
  544. int dct_16x16(Macroblock *currMB, ColorPlane pl, int new_intra_mode, int is_cavlc)
  545. {
  546.   int i,j;
  547.   int ii,jj;
  549.   int ac_coef = 0;
  550.   static imgpel *img_Y, *predY;
  551.   int nonzero = FALSE;
  553.   int   jpos, ipos;
  554.   int   b8, b4;
  556.   //begin the changes
  557.   int   pl_off = pl<<2;
  558.   int*  DCLevel = img->cofDC[pl][0];
  559.   int*  DCRun   = img->cofDC[pl][1];
  560.   int   ****cofAC = &img->cofAC[pl_off];
  561.   int*  ACLevel;
  562.   int*  ACRun;  
  563.   int coeff_cost;
  564.   imgpel **img_enc          = enc_picture->p_curr_img;
  565.   int    max_imgpel_value   = img->max_imgpel_value;
  566.   int    qp                 = currMB->qp_scaled[pl]; 
  567.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  568.   imgpel  (*curr_mpr_16x16)[MB_BLOCK_SIZE][MB_BLOCK_SIZE]  = img->mpr_16x16[pl];
  570.   int qp_per = qp_per_matrix[qp];
  571.   int qp_rem = qp_rem_matrix[qp];
  573.   // select scaling parameters
  574.   levelscale    = LevelScale4x4Comp[pl][1][qp_rem];
  575.   invlevelscale = InvLevelScale4x4Comp[pl][1][qp_rem];
  576.   leveloffset   = ptLevelOffset4x4  [1][qp]; 
  578.   fadjust4x4 = img->AdaptiveRounding ? (pl ? &img->fadjust4x4Cr[pl-1][2][0] : &img->fadjust4x4[2][0]): NULL;
  580.   for (j = 0; j < 16; j++)
  581.   {
  582.     predY = curr_mpr_16x16[new_intra_mode][j];
  583.     img_Y = &pCurImg[img->opix_y + j][img->opix_x];
  584.     for (i = 0; i < 16; i++)
  585.     {
  586.       M1[j][i] = img_Y[i] - predY[i];
  587.     }
  588.   }
  590.   // forward 4x4 DCT
  591.   for (j = 0; j < 16; j+=4)
  592.   {
  593.     for (i = 0;i < 16; i+=4)
  594.     {
  595.       forward4x4(M1, M1, j, i);
  596.     }
  597.   }
  599.   // pick out DC coeff
  600.   for (j = 0; j < 4; j++)
  601.     for (i = 0; i < 4; i++)
  602.       M4[j][i]= M1[j << 2][i << 2];
  604.   // hadamard of DC coefficients
  605.   hadamard4x4(M4, M4);
  607.   nonzero = quant_dc4x4(&M4[0], qp, DCLevel, DCRun, levelscale[0][0], invlevelscale[0][0], leveloffset[0][0], pos_scan, is_cavlc);
  610.   // inverse DC transform
  611.   if (nonzero)
  612.   {
  613.     ihadamard4x4(M4, M4);
  615.     // Reset DC coefficients
  616.     for (j = 0; j < 4; j++)
  617.     {
  618.       for (i = 0; i<4;i++)
  619.       {
  620.         M1[j<<2][i<<2] = rshift_rnd_sf(((M4[j][i]) * invlevelscale[0][0]) << qp_per, 6);
  621.       }
  622.     }
  623.   }
  624.   else // All DC equal to 0.
  625.   {
  626.     for (j=0;j<4;j++)
  627.     {
  628.       for (i=0;i<4;i++)
  629.       {
  630.         M1[j<<2][i<<2] = 0;
  631.       }
  632.     }
  633.   }
  635.   // AC processing for MB
  636.   for (jj=0;jj<4;jj++)
  637.   {
  638.     jpos = (jj << 2);
  639.     for (ii=0;ii<4;ii++)
  640.     {
  641.       ipos = (ii << 2);
  643.       b8       = 2*(jj >> 1) + (ii >> 1);
  644.       b4       = 2*(jj & 0x01) + (ii & 0x01);
  645.       ACLevel  = cofAC[b8][b4][0];
  646.       ACRun    = cofAC[b8][b4][1];
  647.       img->subblock_y = jj;
  648.       img->subblock_x = ii;
  650.       // Quantization process
  651.       nonzero = quant_ac4x4(&M1[jpos], jpos, ipos, qp, ACLevel, ACRun, &fadjust4x4[jpos], 
  652.         levelscale, invlevelscale, leveloffset, &coeff_cost, pos_scan, COEFF_COST4x4[params->disthres], LUMA_16AC, is_cavlc);
  654.       if (nonzero)
  655.         ac_coef = 15;
  657.       //IDCT
  658.       if (M1[jpos][ipos]!= 0 || nonzero)
  659.         inverse4x4(M1, M1, jpos, ipos);
  660.     }
  661.   }
  664.     // Reconstruct samples
  665.     SampleReconstruct (img_enc, curr_mpr_16x16[new_intra_mode], M1, 0, 0, img->pix_y, img->pix_x, 16, 16, max_imgpel_value, DQ_BITS);
  667.   if(img->type == SP_SLICE)
  668.   {
  669.     for (j = img->pix_y; j < img->pix_y + 16;j++)
  670.       for (i = img->pix_x; i < img->pix_x + 16;i++)
  671.         lrec[j][i]=-16; //signals an I16 block in the SP frame
  672.   }
  674.   return ac_coef;
  675. }
  678. /*!
  679.  ************************************************************************
  680.  * brief
  681.  *    For new intra pred routines
  682.  *
  683.  * par Input:
  684.  *    Image par, 16x16 based intra mode
  685.  *
  686.  * par Output:
  687.  *    none
  688.  ************************************************************************
  689.  */
  690. int dct_16x16_ls(Macroblock *currMB, ColorPlane pl, int new_intra_mode, int is_cavlc)
  691. {
  692.   int i,j;
  693.   int ii,jj;
  695.   int run,scan_pos,coeff_ctr;
  696.   int ac_coef = 0;
  697.   static imgpel *img_Y, *predY;
  699.   int   b8, b4;
  701.   //begin the changes
  702.   int   pl_off = pl<<2;
  703.   int*  DCLevel = img->cofDC[pl][0];
  704.   int*  DCRun   = img->cofDC[pl][1];
  705.   int*  ACLevel;
  706.   int*  ACRun;  
  707.   imgpel **img_enc = enc_picture->p_curr_img;
  708.   int   *m7;
  710.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  711.   imgpel  (*curr_mpr_16x16)[MB_BLOCK_SIZE][MB_BLOCK_SIZE]  = img->mpr_16x16[pl];
  713.   for (j = 0; j < 16; j++)
  714.   {
  715.     predY = curr_mpr_16x16[new_intra_mode][j];
  716.     img_Y = &pCurImg[img->opix_y + j][img->opix_x];
  717.     for (i = 0; i < 16; i++)
  718.     {
  719.       M1[j][i] = img_Y[i] - predY[i];
  720.     }
  721.   }
  722.   // pick out DC coeff
  723.   for (j = 0; j < 4;j++)
  724.     for (i = 0; i < 4;i++)
  725.       M4[j][i]= M1[j << 2][i << 2];
  727.   run=-1;
  728.   scan_pos=0;
  730.   for (coeff_ctr=0;coeff_ctr<16;coeff_ctr++)
  731.   {
  732.     i=pos_scan[coeff_ctr][0];
  733.     j=pos_scan[coeff_ctr][1];
  735.     run++;
  737.     m7 = &M4[j][i];
  739.     if (*m7 != 0)
  740.     {
  741.       if (is_cavlc)
  742.         *m7 = iClip3(-CAVLC_LEVEL_LIMIT, CAVLC_LEVEL_LIMIT, *m7);
  744.       DCLevel[scan_pos  ] = *m7;
  745.       DCRun  [scan_pos++] = run;
  746.       run=-1;
  747.     }
  748.   }
  749.   DCLevel[scan_pos]=0;
  751.   // replace DC coeff. This is needed in case of out of limits for CAVLC. Could be done only for CAVLC
  752.   for (j = 0; j < 4;j++)
  753.     for (i = 0; i < 4;i++)
  754.       M1[j << 2][i << 2] = M4[j][i];
  756.   // AC inverse trans/quant for MB
  757.   for (jj=0;jj<4;jj++)
  758.   {
  759.     for (ii=0;ii<4;ii++)
  760.     {
  761.       for (j=0;j<4;j++)
  762.       {
  763.         memcpy(M4[j],&M1[(jj<<2)+j][(ii<<2)], BLOCK_SIZE * sizeof(int));
  764.       }
  766.       //For residual DPCM
  767.       if(new_intra_mode < 2)  //residual DPCM
  768.       {
  769.         Residual_DPCM_4x4_for_Intra16x16(M4, new_intra_mode);  
  770.       }
  772.       run      = -1;
  773.       scan_pos =  0;
  774.       b8       = 2*(jj >> 1) + (ii >> 1);
  775.       b4       = 2*(jj & 0x01) + (ii & 0x01);
  776.       ACLevel  = img->cofAC [b8+pl_off][b4][0];
  777.       ACRun    = img->cofAC [b8+pl_off][b4][1];
  779.       for (coeff_ctr=1;coeff_ctr<16;coeff_ctr++) // set in AC coeff
  780.       {
  781.         i=pos_scan[coeff_ctr][0];
  782.         j=pos_scan[coeff_ctr][1];
  784.         run++;
  785.         m7 = &M4[j][i];
  787.         if (*m7 != 0)
  788.         {
  789.           if (is_cavlc)
  790.             *m7 = iClip3(-CAVLC_LEVEL_LIMIT, CAVLC_LEVEL_LIMIT, *m7);
  792.           ac_coef = 15;
  793.           ACLevel[scan_pos  ] = *m7;
  794.           ACRun  [scan_pos++] = run;
  795.           run=-1;
  796.         }
  797.         // set adaptive rounding params to 0 since process is not meaningful here.
  798.       }
  799.       ACLevel[scan_pos] = 0;
  801.       ///For residual DPCM.  inv. residual DCPM
  802.       if(new_intra_mode<2)  
  803.       {
  804.         Inv_Residual_DPCM_4x4_for_Intra16x16(M4, new_intra_mode);  
  805.       }
  806.       for (j=0;j<4;j++)
  807.         memcpy(&M1[(jj<<2)+j][(ii<<2)],M4[j], BLOCK_SIZE * sizeof(int)); 
  808.     }
  809.   }
  811.   for (j = 0; j < 16; j++)
  812.   {
  813.     img_Y = &img_enc[img->pix_y + j][img->pix_x];
  814.     predY = curr_mpr_16x16[new_intra_mode][j];        
  815.     for (i = 0; i < 16; i++)
  816.       img_Y[i]=(imgpel)(M1[j][i] + predY[i]);
  817.   }
  819.   if(img->type == SP_SLICE)
  820.   {
  821.     for (j = img->pix_y; j < img->pix_y + 16;j++)
  822.       for (i = img->pix_x; i < img->pix_x + 16;i++)
  823.         lrec[j][i]=-16; //signals an I16 block in the SP frame
  824.   }
  826.   return ac_coef;
  827. }
  829. /*!
  830. ************************************************************************
  831. * brief
  832. *    The routine performs transform,quantization,inverse transform, 
  833. *    adds the diff to the prediction and writes the result to the 
  834. *    decoded luma frame. 
  835. *
  836. * par Input:
  837. *    currMB:          Current macroblock.
  838. *    pl:              Color plane for 4:4:4 coding.
  839. *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  840. *    intra:           Intra block indicator.
  841. *
  842. * par Output_
  843. *    nonzero:         0 if no levels are nonzero. n
  844. *                     1 if there are nonzero levels.n
  845. *    coeff_cost:      Coeff coding cost for thresholding consideration.n
  846. ************************************************************************
  847. */
  848. int dct_4x4(Macroblock *currMB, ColorPlane pl, int block_x,int block_y, int *coeff_cost, int intra, int is_cavlc)
  849. {
  850.   int j;
  852.   int nonzero = FALSE;
  854.   int   pos_x   = block_x >> BLOCK_SHIFT;
  855.   int   pos_y   = block_y >> BLOCK_SHIFT;
  856.   int   b8      = 2*(pos_y >> 1) + (pos_x >> 1) + (pl<<2);
  857.   int   b4      = 2*(pos_y & 0x01) + (pos_x & 0x01);
  858.   int*  ACLevel = img->cofAC[b8][b4][0];
  859.   int*  ACRun   = img->cofAC[b8][b4][1];
  861.   imgpel **img_enc      = enc_picture->p_curr_img;
  862.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  863.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];
  864.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl]; 
  866.   int   max_imgpel_value = img->max_imgpel_value;
  867.   int   qp = currMB->qp_scaled[pl]; 
  868.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  870.   int qp_rem = qp_rem_matrix[qp];
  872.   // select scaling parameters
  873.   levelscale    = LevelScale4x4Comp[pl][intra][qp_rem];
  874.   invlevelscale = InvLevelScale4x4Comp[pl][intra][qp_rem];
  875.   leveloffset   = ptLevelOffset4x4[intra][qp];
  877.   fadjust4x4    = img->AdaptiveRounding ? (pl ? &img->fadjust4x4Cr[pl-1][intra][block_y] : &img->fadjust4x4[intra][block_y]) : NULL;
  878.   img->subblock_x = ((b8&0x1)==0) ? (((b4&0x1)==0)? 0: 1) : (((b4&0x1)==0)? 2: 3); // horiz. position for coeff_count context
  879.   img->subblock_y = (b8<2)        ? ((b4<2)       ? 0: 1) : ((b4<2)       ? 2: 3); // vert.  position for coeff_count context
  881.   //  Forward 4x4 transform
  882.   forward4x4(mb_ores, M1, block_y, block_x);
  884.   // Quantization process
  885.   nonzero = quant_4x4(&M1[block_y], block_y, block_x, qp, ACLevel, ACRun, fadjust4x4, 
  886.     levelscale, invlevelscale, leveloffset, coeff_cost, pos_scan, COEFF_COST4x4[params->disthres], is_cavlc);
  888.   //  Decoded block moved to frame memory
  889.   if (nonzero)
  890.   {
  891.     // Inverse 4x4 transform
  892.     inverse4x4(M1, mb_rres, block_y, block_x);
  894.     // generate final block
  895.     SampleReconstruct (img_enc, mb_pred, mb_rres, block_y, block_x, img->pix_y, img->pix_x + block_x, BLOCK_SIZE, BLOCK_SIZE, max_imgpel_value, DQ_BITS);
  896.   }
  897.   else // if (nonzero) => No transformed residual. Just use prediction.
  898.   {
  899.     for (j=block_y; j < block_y + BLOCK_SIZE; j++)
  900.     {
  901.       memcpy(&(img_enc[img->pix_y + j][img->pix_x + block_x]),&(mb_pred[j][block_x]), BLOCK_SIZE * sizeof(imgpel));
  902.     }
  903.   }
  905.   return nonzero;
  906. }
  910. /*!
  911. ************************************************************************
  912. * brief
  913. *    Process for lossless coding of coefficients.
  914. *    The routine performs transform, quantization,inverse transform, 
  915. *    adds the diff to the prediction and writes the result to the 
  916. *    decoded luma frame. 
  917. *
  918. * par Input:
  919. *    currMB:          Current macroblock.
  920. *    pl:              Color plane for 4:4:4 coding.
  921. *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  922. *    intra:           Intra block indicator.
  923. *
  924. * par Output_
  925. *    nonzero:         0 if no levels are nonzero. n
  926. *                     1 if there are nonzero levels.n
  927. *    coeff_cost:      Coeff coding cost for thresholding consideration.n
  928. ************************************************************************
  929. */
  930. int dct_4x4_ls(Macroblock *currMB, ColorPlane pl, int block_x,int block_y,int *coeff_cost, int intra, int is_cavlc)
  931. {
  932.   int i,j, coeff_ctr;
  933.   int run = -1;
  934.   int nonzero = FALSE;  
  936.   int   pos_x   = block_x >> BLOCK_SHIFT;
  937.   int   pos_y   = block_y >> BLOCK_SHIFT;
  938.   int   b8      = 2*(pos_y >> 1) + (pos_x >> 1) + (pl<<2);
  939.   int   b4      = 2*(pos_y & 0x01) + (pos_x & 0x01);
  941.   int*  ACL = &img->cofAC[b8][b4][0][0];
  942.   int*  ACR = &img->cofAC[b8][b4][1][0];
  944.   int   pix_y, pix_x;
  945.   imgpel **img_enc       = enc_picture->p_curr_img;
  946.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  947.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];
  948.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl]; 
  949.   int   *m7;
  951.   const byte *p_scan = currMB->is_field_mode ? &FIELD_SCAN[0][0] : &SNGL_SCAN[0][0];
  953.   // select scaling parameters
  954.   fadjust4x4 = img->AdaptiveRounding ? &img->fadjust4x4[intra][block_y] : NULL;
  956.   if( (ipmode_DPCM < 2) && (intra))
  957.   {
  958.     Residual_DPCM_4x4(ipmode_DPCM, mb_ores, mb_rres, block_y, block_x);
  959.   }
  961.   for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)
  962.   {
  963.     i = *p_scan++;
  964.     j = *p_scan++;
  966.     run++;
  968.     m7 = &mb_rres[j+block_y][i+block_x];    
  970.     if (img->AdaptiveRounding)
  971.       fadjust4x4[j][block_x+i] = 0;
  973.     if (*m7 != 0)
  974.     {
  975.       if (is_cavlc)
  976.         *m7 = iClip3(-CAVLC_LEVEL_LIMIT, CAVLC_LEVEL_LIMIT, *m7);
  978.       nonzero=TRUE;
  979.       *coeff_cost += MAX_VALUE;
  980.       *ACL++ = *m7;
  981.       *ACR++ = run;
  982.       run=-1;                     // reset zero level counter        
  983.     }
  984.   }
  985.   *ACL = 0;
  987.   if( (ipmode_DPCM < 2) && (intra))
  988.   {
  989.     Inv_Residual_DPCM_4x4(mb_rres, block_y, block_x);
  990.   }
  992.   for (j=0; j < BLOCK_SIZE; j++)
  993.   {
  994.     pix_y = img->pix_y + block_y + j;
  995.     pix_x = img->pix_x+block_x;
  996.     for (i=0; i < BLOCK_SIZE; i++)
  997.     {
  998.       img_enc[pix_y][pix_x+i] = mb_rres[j+block_y][i+block_x] + mb_pred[j+block_y][i+block_x];
  999.     }
  1000.   }
  1002.   return nonzero;
  1003. }
  1005. /*!
  1006. ************************************************************************
  1007. * brief
  1008. *    Residual DPCM for Intra lossless coding
  1009. *
  1010. * par Input:
  1011. *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  1012. ************************************************************************
  1013. */
  1014. static int Residual_DPCM_4x4(int ipmode, int mb_ores[16][16], int mb_rres[16][16], int block_y, int block_x)
  1015. {
  1016.   int i;
  1017.   int temp[4][4];
  1019.   if(ipmode==VERT_PRED)
  1020.   {
  1021.     temp[0][0] = mb_ores[block_y][block_x    ];
  1022.     temp[0][1] = mb_ores[block_y][block_x + 1];
  1023.     temp[0][2] = mb_ores[block_y][block_x + 2];
  1024.     temp[0][3] = mb_ores[block_y][block_x + 3];
  1026.     for (i=1; i<4; i++) 
  1027.     {
  1028.       temp[i][0] = mb_ores[block_y + i][block_x    ] - mb_ores[block_y + i - 1][block_x    ];
  1029.       temp[i][1] = mb_ores[block_y + i][block_x + 1] - mb_ores[block_y + i - 1][block_x + 1];
  1030.       temp[i][2] = mb_ores[block_y + i][block_x + 2] - mb_ores[block_y + i - 1][block_x + 2];
  1031.       temp[i][3] = mb_ores[block_y + i][block_x + 3] - mb_ores[block_y + i - 1][block_x + 3];
  1032.     }
  1034.     for (i = 0; i < 4; i++)
  1035.     {
  1036.       mb_ores[block_y+i][block_x    ] = temp[i][0];
  1037.       mb_ores[block_y+i][block_x + 1] = temp[i][1];
  1038.       mb_ores[block_y+i][block_x + 2] = temp[i][2];
  1039.       mb_ores[block_y+i][block_x + 3] = temp[i][3];
  1040.     }
  1041.   }
  1042.   else  //HOR_PRED
  1043.   {
  1044.     temp[0][0] = mb_ores[block_y    ][block_x];
  1045.     temp[1][0] = mb_ores[block_y + 1][block_x];
  1046.     temp[2][0] = mb_ores[block_y + 2][block_x];
  1047.     temp[3][0] = mb_ores[block_y + 3][block_x];
  1049.     for (i=0; i<4; i++)
  1050.     {
  1051.       temp[i][1] = mb_ores[block_y + i][block_x + 1] - mb_ores[block_y + i][block_x    ];
  1052.       temp[i][2] = mb_ores[block_y + i][block_x + 2] - mb_ores[block_y + i][block_x + 1];
  1053.       temp[i][3] = mb_ores[block_y + i][block_x + 3] - mb_ores[block_y + i][block_x + 2];
  1054.     }
  1056.     for (i=0; i<4; i++)
  1057.     {
  1058.       mb_ores[block_y + i][block_x + 0] = temp[i][0];
  1059.       mb_ores[block_y + i][block_x + 1] = temp[i][1];
  1060.       mb_ores[block_y + i][block_x + 2] = temp[i][2];
  1061.       mb_ores[block_y + i][block_x + 3] = temp[i][3];
  1062.     }
  1063.   }
  1064.   return 0;
  1065. }
  1067. /*!
  1068. ************************************************************************
  1069. * brief
  1070. *    Inverse residual DPCM for Intra lossless coding
  1071. *
  1072. * par Input:
  1073. *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  1074. ************************************************************************
  1075. */
  1076. //For residual DPCM
  1077. static int Inv_Residual_DPCM_4x4(int m7[16][16], int block_y, int block_x)  
  1078. {
  1079.   int i;
  1080.   int temp[4][4];
  1082.   if(ipmode_DPCM==VERT_PRED)
  1083.   {
  1084.     for(i=0; i<4; i++)
  1085.     {
  1086.       temp[0][i] = m7[block_y + 0][block_x + i];
  1087.       temp[1][i] = temp[0][i] + m7[block_y + 1][block_x + i];
  1088.       temp[2][i] = temp[1][i] + m7[block_y + 2][block_x + i];
  1089.       temp[3][i] = temp[2][i] + m7[block_y + 3][block_x + i];
  1090.     }
  1091.     for(i=0; i<4; i++)
  1092.     {      
  1093.       m7[block_y + i][block_x    ] = temp[i][0];
  1094.       m7[block_y + i][block_x + 1] = temp[i][1];
  1095.       m7[block_y + i][block_x + 2] = temp[i][2];
  1096.       m7[block_y + i][block_x + 3] = temp[i][3];
  1097.     }
  1098.   }
  1099.   else //HOR_PRED
  1100.   {
  1101.     for(i=0; i<4; i++)
  1102.     {
  1103.       temp[i][0] = m7[block_y+i][block_x+0];
  1104.       temp[i][1] = temp[i][0] + m7[block_y + i][block_x + 1];
  1105.       temp[i][2] = temp[i][1] + m7[block_y + i][block_x + 2];
  1106.       temp[i][3] = temp[i][2] + m7[block_y + i][block_x + 3];    
  1107.     }
  1108.     for(i=0; i<4; i++)
  1109.     {
  1110.       m7[block_y+i][block_x  ] = temp[i][0];
  1111.       m7[block_y+i][block_x+1] = temp[i][1];
  1112.       m7[block_y+i][block_x+2] = temp[i][2];
  1113.       m7[block_y+i][block_x+3] = temp[i][3];
  1114.     }
  1115.   }
  1116.   return 0;
  1117. }
  1119. /*!
  1120. ************************************************************************
  1121. * brief
  1122. *    Residual DPCM for Intra lossless coding
  1123. ************************************************************************
  1124. */
  1125. //For residual DPCM
  1126. static int Residual_DPCM_4x4_for_Intra16x16(int m7[4][4], int ipmode)  
  1127. {
  1128.   int i,j;
  1129.   int temp[4][4];
  1131.   if(ipmode==VERT_PRED)
  1132.   {   
  1133.     for (i=1; i<4; i++) 
  1134.       for (j=0; j<4; j++)
  1135.         temp[i][j] = m7[i][j] - m7[i-1][j];
  1137.     for (i=1; i<4; i++)
  1138.       for (j=0; j<4; j++)
  1139.         m7[i][j] = temp[i][j];
  1140.   }
  1141.   else  //HOR_PRED
  1142.   {
  1143.     for (i=0; i<4; i++)
  1144.       for (j=1; j<4; j++)
  1145.         temp[i][j] = m7[i][j] - m7[i][j-1];
  1147.     for (i=0; i<4; i++)
  1148.       for (j=1; j<4; j++)
  1149.         m7[i][j] = temp[i][j];
  1150.   }
  1151.   return 0;
  1152. }
  1153. /*!
  1154. ************************************************************************
  1155. * brief
  1156. *    Inverse residual DPCM for Intra lossless coding
  1157. ************************************************************************
  1158. */
  1159. //For residual DPCM
  1160. static int Inv_Residual_DPCM_4x4_for_Intra16x16(int m7[4][4], int ipmode)  
  1161. {
  1162.   int i;
  1163.   int temp[4][4];
  1165.   if(ipmode==VERT_PRED)
  1166.   {
  1167.     for (i=0; i<4; i++) 
  1168.     {
  1169.       temp[0][i] = m7[0][i];
  1170.       temp[1][i] = m7[1][i] + temp[0][i];
  1171.       temp[2][i] = m7[2][i] + temp[1][i];
  1172.       temp[3][i] = m7[3][i] + temp[2][i];
  1173.     }
  1174.     // These could now just use a memcpy
  1175.     for (i=0; i<4; i++)
  1176.     {
  1177.       m7[1][i] = temp[1][i];
  1178.       m7[2][i] = temp[2][i];
  1179.       m7[3][i] = temp[3][i];
  1180.     }
  1181.   }
  1182.   else  //HOR_PRED
  1183.   {
  1184.     for(i=0; i<4; i++)
  1185.     {
  1186.       temp[i][0] = m7[i][0];
  1187.       temp[i][1] = m7[i][1] + temp[i][0];
  1188.       temp[i][2] = m7[i][2] + temp[i][1];
  1189.       temp[i][3] = m7[i][3] + temp[i][2];
  1190.     }
  1191.     for (i=0; i<4; i++)
  1192.     {
  1193.       m7[i][1] = temp[i][1];
  1194.       m7[i][2] = temp[i][2];
  1195.       m7[i][3] = temp[i][3];
  1196.     }    
  1197.   }
  1198.   return 0;
  1199. }
  1201. /*!
  1202.  ************************************************************************
  1203.  * brief
  1204.  *    Transform,quantization,inverse transform for chroma.
  1205.  *    The main reason why this is done in a separate routine is the
  1206.  *    additional 2x2 transform of DC-coeffs. This routine is called
  1207.  *    once for each of the chroma components.
  1208.  *
  1209.  * par Input:
  1210.  *    uv    : Make difference between the U and V chroma component  n
  1211.  *    cr_cbp: chroma coded block pattern
  1212.  *
  1213.  * par Output:
  1214.  *    cr_cbp: Updated chroma coded block pattern.
  1215.  ************************************************************************
  1216.  */
  1217. int dct_chroma(Macroblock *currMB, int uv, int cr_cbp, int is_cavlc)
  1218. {
  1219.   int i, j, n2, n1, coeff_ctr;
  1220.   static int m1[BLOCK_SIZE];
  1221.   int coeff_cost = 0;
  1222.   int cr_cbp_tmp = 0;
  1223.   int DCzero = FALSE;
  1224.   int nonzero[4][4] = {{FALSE}};
  1225.   int nonezero = FALSE;
  1227.   const byte *c_cost = COEFF_COST4x4[params->disthres];
  1229.   int   b4;
  1230.   int*  DCLevel = img->cofDC[uv+1][0];
  1231.   int*  DCRun   = img->cofDC[uv+1][1];
  1232.   int*  ACLevel;
  1233.   int*  ACRun;
  1234.   int   intra = IS_INTRA (currMB);
  1235.   int   uv_scale = uv * (img->num_blk8x8_uv >> 1);
  1237.   //FRExt
  1238.   static const int64 cbpblk_pattern[4]={0, 0xf0000, 0xff0000, 0xffff0000};
  1239.   int yuv = img->yuv_format;
  1240.   int b8;  
  1242.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  1243.   int cur_qp = currMB->qpc[uv] + img->bitdepth_chroma_qp_scale;  
  1245.   int qp_rem = qp_rem_matrix[cur_qp];
  1247.   int max_imgpel_value_uv = img->max_imgpel_value_comp[uv + 1];
  1249.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[uv + 1]; 
  1250.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[uv + 1];
  1251.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[uv + 1]; 
  1253.   levelscale    = LevelScale4x4Comp   [uv + 1][intra][qp_rem];
  1254.   leveloffset   = LevelOffset4x4Comp  [uv + 1][intra][cur_qp];
  1255.   invlevelscale = InvLevelScale4x4Comp[uv + 1][intra][qp_rem];
  1256.   fadjust4x4    = img->AdaptiveRounding ? img->fadjust4x4Cr[intra][uv] : NULL;
  1257.   img->is_v_block = uv;
  1259.   //============= dct transform ===============
  1260.   for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1261.   {
  1262.     for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1263.     {
  1264.       forward4x4(mb_ores, mb_rres, n2, n1);
  1265.     }
  1266.   }
  1268.   if (yuv == YUV420)
  1269.   {
  1270.     //================== CHROMA DC YUV420 ===================
  1271.   
  1272.     // forward 2x2 hadamard
  1273.     hadamard2x2(mb_rres, m1);
  1275.     // Quantization process of chroma 2X2 hadamard transformed DC coeffs.
  1276.     DCzero = quant_dc_cr(&m1, cur_qp, DCLevel, DCRun, fadjust2x2, levelscale[0][0], invlevelscale[0][0], leveloffset, SCAN_YUV420, is_cavlc);
  1278.     if (DCzero) 
  1279.     {
  1280.         currMB->cbp_blk |= 0xf0000 << (uv << 2) ;    // if one of the 2x2-DC levels is != 0 set the
  1281.         cr_cbp=imax(1,cr_cbp);                     // coded-bit all 4 4x4 blocks (bit 16-19 or 20-23)
  1282.     }
  1284.     //  Inverse transform of 2x2 DC levels
  1285.     ihadamard2x2(m1, m1);
  1287.     mb_rres[0][0] = m1[0] >> 5;
  1288.     mb_rres[0][4] = m1[1] >> 5;
  1289.     mb_rres[4][0] = m1[2] >> 5;
  1290.     mb_rres[4][4] = m1[3] >> 5;
  1291.   }
  1292.   else if (yuv == YUV422)
  1293.   {
  1294.     //for YUV422 only
  1295.     int cur_qp_dc = currMB->qpc[uv] + 3 + img->bitdepth_chroma_qp_scale;
  1296.     int qp_rem_dc = qp_rem_matrix[cur_qp_dc];
  1298.     invlevelscaleDC = InvLevelScale4x4Comp[uv + 1][intra][qp_rem_dc];
  1299.     levelscaleDC    = LevelScale4x4Comp   [uv + 1][intra][qp_rem_dc];
  1300.     leveloffsetDC   = LevelOffset4x4Comp  [uv + 1][intra][cur_qp_dc];
  1302.     //================== CHROMA DC YUV422 ===================
  1303.     //pick out DC coeff    
  1304.     for (j=0; j < img->mb_cr_size_y; j+=BLOCK_SIZE)
  1305.     {
  1306.       for (i=0; i < img->mb_cr_size_x; i+=BLOCK_SIZE)
  1307.         M4[i>>2][j>>2]= mb_rres[j][i];
  1308.     }
  1310.     // forward hadamard transform. Note that coeffs have been transposed (4x2 instead of 2x4) which makes transform a bit faster
  1311.     hadamard4x2(M4, M4);
  1313.     // Quantization process of chroma transformed DC coeffs.
  1314.     DCzero = quant_dc_cr(M4, cur_qp_dc, DCLevel, DCRun, fadjust4x2, levelscaleDC[0][0], invlevelscaleDC[0][0], leveloffsetDC, SCAN_YUV422, is_cavlc);
  1316.     if (DCzero)
  1317.     {
  1318.       currMB->cbp_blk |= 0xff0000 << (uv << 3) ;   // if one of the DC levels is != 0 set the
  1319.       cr_cbp=imax(1,cr_cbp);                       // coded-bit all 4 4x4 blocks (bit 16-31 or 32-47) //YUV444
  1320.     }
  1322.     //inverse DC transform. Note that now M4 is transposed back
  1323.     ihadamard4x2(M4, M4);    
  1325.     // This code assumes sizeof(int) > 16. Therefore, no need to have conditional
  1326.     for (j = 0; j < 4; j++)
  1327.     {
  1328.       mb_rres[j << 2 ][0] = rshift_rnd_sf(M4[j][0], 6);
  1329.       mb_rres[j << 2 ][4] = rshift_rnd_sf(M4[j][1], 6);
  1330.     }
  1331.   }
  1333.   //     Quant of chroma AC-coeffs.
  1334.   for (b8=0; b8 < (img->num_blk8x8_uv >> 1); b8++)
  1335.   {
  1336.     for (b4=0; b4 < 4; b4++)
  1337.     {
  1338.       int64 uv_cbpblk = ((int64)1) << cbp_blk_chroma[b8 + uv_scale][b4];      
  1339.       n1 = hor_offset[yuv][b8][b4];
  1340.       n2 = ver_offset[yuv][b8][b4];
  1341.       ACLevel = img->cofAC[4 + b8 + uv_scale][b4][0];
  1342.       ACRun   = img->cofAC[4 + b8 + uv_scale][b4][1];
  1343.       img->subblock_y = subblk_offset_y[img->yuv_format - 1][b8][b4]>>2;
  1344.       img->subblock_x = subblk_offset_x[img->yuv_format - 1][b8][b4]>>2;
  1345.       // Quantization process
  1346.       nonzero[n2>>2][n1>>2] = quant_ac4x4cr(&mb_rres[n2], n2, n1, cur_qp, ACLevel, ACRun, &fadjust4x4[n2], 
  1347.         levelscale, invlevelscale, leveloffset, &coeff_cost, pos_scan, c_cost, CHROMA_AC, is_cavlc);
  1349.       if (nonzero[n2>>2][n1>>2])
  1350.       {
  1351.         currMB->cbp_blk |= uv_cbpblk;
  1352.         cr_cbp_tmp = 2;
  1353.         nonezero = TRUE;
  1354.       }
  1355.     }
  1356.   }
  1358.   // Perform thresholding
  1359.   // * reset chroma coeffs
  1360.   if(nonezero && coeff_cost < _CHROMA_COEFF_COST_)
  1361.   {
  1362.     int64 uv_cbpblk = ((int64)cbpblk_pattern[yuv] << (uv << (1+yuv)));
  1363.     cr_cbp_tmp = 0;
  1365.     for (b8 = 0; b8 < (img->num_blk8x8_uv >> 1); b8++)
  1366.     {
  1367.       for (b4 = 0; b4 < 4; b4++)
  1368.       {
  1369.         n1 = hor_offset[yuv][b8][b4];
  1370.         n2 = ver_offset[yuv][b8][b4];
  1371.         if (nonzero[n2>>2][n1>>2] == TRUE)
  1372.         {
  1373.           nonzero[n2>>2][n1>>2] = FALSE;
  1374.           ACLevel = img->cofAC[4 + b8 + uv_scale][b4][0];
  1375.           ACRun   = img->cofAC[4 + b8 + uv_scale][b4][1];
  1377.           if (DCzero == 0)
  1378.             currMB->cbp_blk &= ~(uv_cbpblk);  // if no chroma DC's: then reset coded-bits of this chroma subblock
  1380.           ACLevel[0] = 0;
  1382.           for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// ac coeff
  1383.           {
  1384.             mb_rres[n2 + pos_scan[coeff_ctr][1]][n1 + pos_scan[coeff_ctr][0]] = 0;
  1385.             ACLevel[coeff_ctr]  = 0;
  1386.           }
  1387.         }
  1388.       }
  1389.     }
  1390.   }
  1392.   //     IDCT.
  1393.   //     Horizontal.
  1394.   if(cr_cbp_tmp == 2)
  1395.     cr_cbp = 2;
  1397.   nonezero = FALSE;
  1398.   for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1399.   {
  1400.     for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1401.     {
  1402.       if (mb_rres[n2][n1] != 0 || nonzero[n2>>2][n1>>2] == TRUE)
  1403.       {
  1404.         inverse4x4(mb_rres, mb_rres, n2, n1);
  1405.         nonezero = TRUE;
  1406.       }
  1407.     }
  1408.   }
  1410.   //  Decoded block moved to memory
  1411.   if (nonezero == TRUE)
  1412.   {
  1413.     SampleReconstruct (enc_picture->imgUV[uv], mb_pred, mb_rres, 0, 0, img->pix_c_y, img->pix_c_x, img->mb_cr_size_x, img->mb_cr_size_y, max_imgpel_value_uv, DQ_BITS);
  1414.   }
  1415.   else
  1416.   {
  1417.     for (j=0; j < img->mb_cr_size_y; j++)
  1418.     {
  1419.       memcpy(&enc_picture->imgUV[uv][img->pix_c_y + j][img->pix_c_x], mb_pred[j], img->mb_cr_size_x * sizeof(imgpel));
  1420.     }
  1421.   }
  1423.   return cr_cbp;
  1424. }
  1427. /*!
  1428.  ************************************************************************
  1429.  * brief
  1430.  *    Transform,quantization,inverse transform for chroma.
  1431.  *    The main reason why this is done in a separate routine is the
  1432.  *    additional 2x2 transform of DC-coeffs. This routine is called
  1433.  *    once for each of the chroma components.
  1434.  *
  1435.  * par Input:
  1436.  *    uv    : Make difference between the U and V chroma component  n
  1437.  *    cr_cbp: chroma coded block pattern
  1438.  *
  1439.  * par Output:
  1440.  *    cr_cbp: Updated chroma coded block pattern.
  1441.  ************************************************************************
  1442.  */
  1443. int dct_chroma_ls(Macroblock *currMB, int uv, int cr_cbp, int is_cavlc)
  1444. {
  1445.   int i,j,n2,n1,coeff_ctr,level ,scan_pos,run;
  1446.   static int m1[BLOCK_SIZE];
  1447.   int coeff_cost;
  1448.   int cr_cbp_tmp;
  1449.   int nonzero = FALSE;
  1450.   static imgpel *orig_img, *pred_img;
  1452.   int   b4;
  1453.   int*  DCLevel = img->cofDC[uv+1][0];
  1454.   int*  DCRun   = img->cofDC[uv+1][1];
  1455.   int*  ACLevel;
  1456.   int*  ACRun;
  1457.   int   intra = IS_INTRA (currMB);
  1458.   int   uv_scale = uv * (img->num_blk8x8_uv >> 1);
  1460.   //FRExt
  1461.   int yuv = img->yuv_format;
  1462.   int b8;
  1463.   static int *m7;
  1464.   static int m3[4][4];
  1466.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  1468.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[uv + 1]; 
  1469.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[uv + 1];
  1470.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[uv + 1]; 
  1472.   fadjust4x4    = img->AdaptiveRounding ? img->fadjust4x4Cr[intra][uv] : NULL;
  1475.   if (yuv == YUV420)
  1476.   {
  1477.     //================== CHROMA DC YUV420 ===================
  1478.     //     2X2 transform of DC coeffs.
  1479.     run=-1;
  1480.     scan_pos=0;    
  1481.     m1[0] = mb_rres[0][0] = mb_ores[0][0];
  1482.     m1[1] = mb_rres[0][4] = mb_ores[0][4];
  1483.     m1[2] = mb_rres[4][0] = mb_ores[4][0];
  1484.     m1[3] = mb_rres[4][4] = mb_ores[4][4];
  1486.     for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  1487.     {
  1488.       run++;
  1490.       level =iabs(m1[coeff_ctr]);
  1492.       if (level  != 0)
  1493.       {
  1494.         if (is_cavlc)
  1495.           level = imin(level, CAVLC_LEVEL_LIMIT);
  1497.         currMB->cbp_blk |= 0xf0000 << (uv << 2) ;    // if one of the 2x2-DC levels is != 0 set the
  1498.         cr_cbp=imax(1, cr_cbp);                     // coded-bit all 4 4x4 blocks (bit 16-19 or 20-23)
  1499.         nonzero = TRUE;
  1500.         level = isignab(level, m1[coeff_ctr]);
  1501.         DCLevel[scan_pos  ] = level;
  1502.         DCRun  [scan_pos++] = run;
  1503.         run=-1;
  1504.       }
  1505.     }
  1506.     DCLevel[scan_pos] = 0;    
  1507.   }
  1508.   else if(yuv == YUV422)
  1509.   {
  1510.     //================== CHROMA DC YUV422 ===================
  1511.     //transform DC coeff
  1512.     //horizontal
  1514.     //pick out DC coeff
  1515.     for (j=0; j < img->mb_cr_size_y; j+=BLOCK_SIZE)
  1516.     {
  1517.       for (i=0; i < img->mb_cr_size_x; i+=BLOCK_SIZE)
  1518.       {
  1519.         m3[i>>2][j>>2] = mb_ores[j][i];
  1520.         mb_rres[j][i]  = mb_ores[j][i];
  1521.       }
  1522.     }
  1525.     run=-1;
  1526.     scan_pos=0;
  1528.     //quant of chroma DC-coeffs
  1529.     for (coeff_ctr=0;coeff_ctr<8;coeff_ctr++)
  1530.     {
  1531.       i=SCAN_YUV422[coeff_ctr][0];
  1532.       j=SCAN_YUV422[coeff_ctr][1];
  1534.       run++;
  1536.       level = iabs(m3[i][j]);
  1537.       M4[i][j]=m3[i][j];
  1539.       if (level != 0)
  1540.       {
  1541.         //YUV422
  1542.         currMB->cbp_blk |= 0xff0000 << (uv << 3) ;   // if one of the DC levels is != 0 set the
  1543.         cr_cbp=imax(1,cr_cbp);                       // coded-bit all 4 4x4 blocks (bit 16-31 or 32-47) //YUV444
  1544.         nonzero = TRUE;
  1546.         DCLevel[scan_pos  ] = isignab(level,M4[i][j]);
  1547.         DCRun  [scan_pos++] = run;
  1548.         run=-1;
  1549.       }
  1550.     }
  1551.     DCLevel[scan_pos]=0;
  1553.     //inverse DC transform
  1554.     //horizontal    
  1555.   }
  1557.   //     Quant of chroma AC-coeffs.
  1558.   coeff_cost=0;
  1559.   cr_cbp_tmp=0;
  1561.   for (b8=0; b8 < (img->num_blk8x8_uv >> 1); b8++)
  1562.   {
  1563.     for (b4=0; b4 < 4; b4++)
  1564.     {
  1565.       int64 uv_cbpblk = ((int64)1) << cbp_blk_chroma[b8 + uv_scale][b4];
  1566.       n1 = hor_offset[yuv][b8][b4];
  1567.       n2 = ver_offset[yuv][b8][b4];
  1568.       ACLevel = img->cofAC[4 + b8 + uv_scale][b4][0];
  1569.       ACRun   = img->cofAC[4 + b8 + uv_scale][b4][1];
  1570.       run=-1;
  1571.       scan_pos=0;
  1573.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// start change rd_quant
  1574.       {
  1575.         i=pos_scan[coeff_ctr][0];
  1576.         j=pos_scan[coeff_ctr][1];
  1578.         ++run;
  1580.         level = iabs(mb_ores[n2+j][n1+i]);
  1581.         mb_rres[n2+j][n1+i] = mb_ores[n2+j][n1+i];
  1583.         if (img->AdaptiveRounding)
  1584.         {
  1585.           fadjust4x4[n2+j][n1+i] = 0;
  1586.         }
  1588.         if (level  != 0)
  1589.         {
  1590.           currMB->cbp_blk |= uv_cbpblk;
  1591.           coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  1593.           cr_cbp_tmp=2;
  1594.           ACLevel[scan_pos  ] = isignab(level, mb_ores[n2+j][n1+i]);
  1595.           ACRun  [scan_pos++] = run;
  1596.           run=-1;
  1598.           level = isignab(level, mb_ores[n2+j][n1+i]);          
  1599.         }
  1600.       }
  1601.       ACLevel[scan_pos] = 0;
  1602.     }
  1603.   }
  1605.   for (j=0; j < img->mb_cr_size_y; j++)
  1606.   {      
  1607.     orig_img = &enc_picture->imgUV[uv][img->pix_c_y + j][img->pix_c_x];
  1608.     m7 = mb_rres[j];
  1609.     pred_img = mb_pred[j];
  1610.     for (i=0; i < img->mb_cr_size_x; i++)
  1611.     {        
  1612.       orig_img[i] = (imgpel) m7[i] + pred_img[i];
  1613.     }
  1614.   }  
  1616.   return cr_cbp;
  1617. }
  1619. /*!
  1620.  ************************************************************************
  1621.  * brief
  1622.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  1623.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  1624.  *    RD constrained quantization also.
  1625.  *
  1626.  * par Input:
  1627.  *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  1628.  *
  1629.  * par Output:
  1630.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.              n
  1631.  *    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
  1632.  *
  1633.  *
  1634.  ************************************************************************
  1635.  */
  1636. int dct_4x4_sp(Macroblock *currMB, ColorPlane pl, int block_x,int block_y,int *coeff_cost, int intra, int is_cavlc)
  1637. {
  1638.   int i,j,coeff_ctr;
  1639.   int qp_const,ilev, level,scan_pos = 0,run = -1;
  1640.   int nonzero = FALSE;
  1642.   imgpel **img_enc = enc_picture->p_curr_img;
  1643.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  1644.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl]; 
  1645.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];
  1646.   int c_err,qp_const2;
  1648.   int   qp = currMB->qp_scaled[pl]; 
  1649.   int   qp_sp = (currMB->qpsp);
  1651.   const byte *c_cost = COEFF_COST4x4[params->disthres];
  1652.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  1654.   int   pos_x   = block_x >> BLOCK_SHIFT;
  1655.   int   pos_y   = block_y >> BLOCK_SHIFT;
  1656.   int   b8      = 2*(pos_y >> 1) + (pos_x >> 1);
  1657.   int   b4      = 2*(pos_y & 0x01) + (pos_x & 0x01);
  1658.   int*  ACLevel = img->cofAC[b8][b4][0];
  1659.   int*  ACRun   = img->cofAC[b8][b4][1];
  1661.   // For encoding optimization
  1662.   int c_err1, c_err2, level1, level2;
  1663.   double D_dis1, D_dis2;
  1664.   int len, info;
  1665.   double lambda_mode   = 0.85 * pow (2, (qp - SHIFT_QP)/3.0) * 4;
  1667.   int qp_per    = qp_per_matrix[qp];
  1668.   int qp_rem    = qp_rem_matrix[qp];
  1669.   int q_bits    = Q_BITS + qp_per;
  1670.   int qp_per_sp = qp_per_matrix[qp_sp];
  1671.   int qp_rem_sp = qp_rem_matrix[qp_sp];
  1672.   int q_bits_sp = Q_BITS + qp_per_sp;
  1674.   levelscale    = LevelScale4x4Comp[pl][intra][qp_rem];
  1675.   invlevelscale = InvLevelScale4x4Comp[pl][intra][qp_rem];
  1676.   leveloffset   = ptLevelOffset4x4[intra][qp];
  1678.   levelscale_sp    = LevelScale4x4Comp[pl][intra][qp_rem_sp];
  1679.   invlevelscale_sp = InvLevelScale4x4Comp[pl][intra][qp_rem_sp];
  1680.   leveloffset_sp   = ptLevelOffset4x4[intra][qp_sp];
  1682.   qp_const  = (1<<q_bits)/6;    // inter
  1683.   qp_const2 = (1<<q_bits_sp)/2;  //sp_pred
  1685.   //  Horizontal transform
  1686.   for (j=block_y; j< block_x + BLOCK_SIZE; j++)
  1687.   {
  1688.     for (i=block_x; i< block_x + BLOCK_SIZE; i++)
  1689.     { 
  1690.       mb_rres[j][i] = mb_ores[j][i];
  1691.       mb_rres[j][i]+=mb_pred[j][i];
  1692.       M1[j][i] = mb_pred[j][i];
  1693.     }
  1694.   }
  1696.   // 4x4 transform
  1697.   forward4x4(mb_rres, mb_rres, block_y, block_x);
  1698.   forward4x4(M1, M1, block_y, block_x);
  1700.   for (coeff_ctr = 0;coeff_ctr < 16;coeff_ctr++)     
  1701.   {
  1702.     i = pos_scan[coeff_ctr][0];
  1703.     j = pos_scan[coeff_ctr][1];
  1705.     run++;
  1706.     ilev=0;
  1708.     // decide prediction
  1710.     // case 1
  1711.     level1 = (iabs (M1[j][i]) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp;
  1712.     level1 = (level1 << q_bits_sp) / levelscale_sp[j][i];
  1713.     c_err1 = mb_rres[j][i] - isignab(level1, M1[j][i]);
  1714.     level1 = (iabs (c_err1) * levelscale[j][i] + qp_const) >> q_bits;
  1716.     // case 2
  1717.     c_err2 = mb_rres[j][i] - M1[j][i];
  1718.     level2 = (iabs (c_err2) * levelscale[j][i] + qp_const) >> q_bits;
  1720.     // select prediction
  1721.     if ((level1 != level2) && (level1 != 0) && (level2 != 0))
  1722.     {
  1723.       D_dis1 = mb_rres[j][i] - ((isignab(level1,c_err1) * invlevelscale[j][i] * A[j][i]<< qp_per) >>6) - M1[j][i];
  1724.       levrun_linfo_inter(level1, run, &len, &info);
  1725.       D_dis1 = D_dis1 * D_dis1 + lambda_mode * len;
  1727.       D_dis2 = mb_rres[j][i] - ((isignab(level2,c_err2)*invlevelscale[j][i] * A[j][i]<< qp_per) >>6) - M1[j][i];
  1728.       levrun_linfo_inter(level2, run, &len, &info);
  1729.       D_dis2 = D_dis2 * D_dis2 + lambda_mode * len;
  1731.       if (D_dis1 == D_dis2)
  1732.         level = (iabs(level1) < iabs(level2)) ? level1 : level2;
  1733.       else if (D_dis1 < D_dis2)
  1734.         level = level1;
  1735.       else
  1736.         level = level2;
  1738.       c_err = (level == level1) ? c_err1 : c_err2;
  1739.     }
  1740.     else if (level1 == level2)
  1741.     {
  1742.       level = level1;
  1743.       c_err = c_err1;
  1744.     }
  1745.     else
  1746.     {
  1747.       level = (level1 == 0) ? level1 : level2;
  1748.       c_err = (level1 == 0) ? c_err1 : c_err2;
  1749.     }
  1751.     if (level != 0)
  1752.     {
  1753.       nonzero = TRUE;
  1755.       *coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];
  1757.       level = isignab(level,c_err);
  1758.       ACLevel[scan_pos] = level;
  1759.       ACRun  [scan_pos] = run;
  1760.       ++scan_pos;
  1761.       run=-1;                     // reset zero level counter
  1762.       ilev=((level * invlevelscale[j][i] * A[j][i] << qp_per) >>6);
  1763.     }
  1765.     ilev += M1[j][i];
  1767.     if(!si_frame_indicator && !sp2_frame_indicator)//stores the SP frame coefficients in lrec, will be useful to encode these and create SI or SP switching frame
  1768.     {
  1769.       lrec[img->pix_y+block_y+j][img->pix_x+block_x+i]=
  1770.         isignab((iabs(ilev) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp, ilev);
  1771.     }    
  1772.     mb_rres[j][i] = isignab((iabs(ilev) * levelscale_sp[j][i] + qp_const2)>> q_bits_sp, ilev) * invlevelscale_sp[j][i] << qp_per_sp;
  1773.   }
  1774.   ACLevel[scan_pos] = 0;
  1776.   // inverse transform
  1777.   // inverse4x4(mb_rres, mb_rres, block_y, block_x);
  1778.   inverse4x4(M1, mb_rres, 0, 0);
  1780.   for (j=0; j < BLOCK_SIZE; j++)
  1781.     for (i=0; i < BLOCK_SIZE; i++)
  1782.     {
  1783.       //printf("%d ",mb_rres[j][i]);
  1784.       mb_rres[j][i] = iClip1 (img->max_imgpel_value, rshift_rnd_sf(mb_rres[j][i], DQ_BITS));
  1785.        //printf("%dn",mb_rres[j][i]);
  1786.     }
  1788.   //  Decoded block moved to frame memory
  1789.   for (j=0; j < BLOCK_SIZE; j++)
  1790.   {
  1791.     for (i=0; i < BLOCK_SIZE; i++)
  1792.     {
  1793.       img_enc[img->pix_y+block_y+j][img->pix_x+block_x+i]= (imgpel) mb_rres[j][i];
  1794.   //printf("%dn",mb_rres[j][i]);
  1795.     }
  1796.   }
  1797.   return nonzero;
  1798. }
  1800. /*!
  1801.  ************************************************************************
  1802.  * brief
  1803.  *    Transform,quantization,inverse transform for chroma.
  1804.  *    The main reason why this is done in a separate routine is the
  1805.  *    additional 2x2 transform of DC-coeffs. This routine is called
  1806.  *    once for each of the chroma components.
  1807.  *
  1808.  * par Input:
  1809.  *    uv    : Make difference between the U and V chroma component               n
  1810.  *    cr_cbp: chroma coded block pattern
  1811.  *
  1812.  * par Output:
  1813.  *    cr_cbp: Updated chroma coded block pattern.
  1814.  ************************************************************************
  1815.  */
  1816. int dct_chroma_sp(Macroblock *currMB, int uv,int cr_cbp, int is_cavlc)
  1817. {
  1818.   int i, j, n2, n1, coeff_ctr;
  1819.   static int m1[BLOCK_SIZE];
  1820.   int coeff_cost = 0;
  1821.   int cr_cbp_tmp = 0;
  1822.   int DCzero = FALSE;
  1823.   int nonzero[4][4] = {{FALSE}};
  1824.   int nonezero = FALSE;
  1826.   const byte *c_cost = COEFF_COST4x4[params->disthres];
  1828.   int   b4;
  1829.   int*  DCLevel = img->cofDC[uv+1][0];
  1830.   int*  DCRun   = img->cofDC[uv+1][1];
  1831.   int*  ACLevel;
  1832.   int*  ACRun;
  1833.   int   intra = IS_INTRA (currMB);
  1834.   int   uv_scale = uv * (img->num_blk8x8_uv >> 1);
  1836.   //FRExt
  1837.   static const int64 cbpblk_pattern[4]={0, 0xf0000, 0xff0000, 0xffff0000};
  1838.   int yuv = img->yuv_format;
  1839.   int b8;  
  1841.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  1842.   int cur_qp = currMB->qpc[uv] + img->bitdepth_chroma_qp_scale;  
  1844.   int qp_rem = qp_rem_matrix[cur_qp];
  1846.   int max_imgpel_value_uv = img->max_imgpel_value_comp[uv + 1];
  1848.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[uv + 1]; 
  1849.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[uv + 1]; 
  1850.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[uv + 1]; 
  1852.   levelscale    = LevelScale4x4Comp   [uv + 1][intra][qp_rem];
  1853.   leveloffset   = LevelOffset4x4Comp  [uv + 1][intra][cur_qp];
  1854.   invlevelscale = InvLevelScale4x4Comp[uv + 1][intra][qp_rem];
  1855.   fadjust4x4    = img->AdaptiveRounding ? img->fadjust4x4Cr[intra][uv] : NULL;
  1857.   //============= dct transform ===============
  1858.   for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1859.   {
  1860.     for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1861.     {
  1862.       forward4x4(mb_ores, mb_rres, n2, n1);
  1863.     }
  1864.   }
  1866.   if (yuv == YUV420)
  1867.   {
  1868.     //================== CHROMA DC YUV420 ===================
  1869.   
  1870.     // forward 2x2 hadamard
  1871.     hadamard2x2(mb_rres, m1);
  1873.     // Quantization process of chroma 2X2 hadamard transformed DC coeffs.
  1874.     DCzero = quant_dc_cr(&m1, cur_qp, DCLevel, DCRun, fadjust2x2, levelscale[0][0], invlevelscale[0][0], leveloffset, pos_scan, is_cavlc);
  1876.     if (DCzero) 
  1877.     {
  1878.         currMB->cbp_blk |= 0xf0000 << (uv << 2) ;    // if one of the 2x2-DC levels is != 0 set the
  1879.         cr_cbp=imax(1,cr_cbp);                     // coded-bit all 4 4x4 blocks (bit 16-19 or 20-23)
  1880.     }
  1882.     //  Inverse transform of 2x2 DC levels
  1883.     ihadamard2x2(m1, m1);
  1885.     mb_rres[0][0] = m1[0];
  1886.     mb_rres[0][4] = m1[1];
  1887.     mb_rres[4][0] = m1[2];
  1888.     mb_rres[4][4] = m1[3];
  1889.   }
  1890.   else if (yuv == YUV422)
  1891.   {
  1892.     //for YUV422 only
  1893.     int cur_qp_dc = currMB->qpc[uv] + 3 + img->bitdepth_chroma_qp_scale;
  1894.     int qp_rem_dc = qp_rem_matrix[cur_qp_dc];
  1896.     invlevelscaleDC = InvLevelScale4x4Comp[uv + 1][intra][qp_rem_dc];
  1897.     levelscaleDC    = LevelScale4x4Comp   [uv + 1][intra][qp_rem_dc];
  1898.     leveloffsetDC   = LevelOffset4x4Comp  [uv + 1][intra][cur_qp_dc];
  1900.     //================== CHROMA DC YUV422 ===================
  1901.     //pick out DC coeff    
  1902.     for (j=0; j < img->mb_cr_size_y; j+=BLOCK_SIZE)
  1903.     {
  1904.       for (i=0; i < img->mb_cr_size_x; i+=BLOCK_SIZE)
  1905.         M4[i>>2][j>>2]= mb_rres[j][i];
  1906.     }
  1908.     // forward hadamard transform. Note that coeffs have been transposed (4x2 instead of 2x4) which makes transform a bit faster
  1909.     hadamard4x2(M4, M4);
  1911.     // Quantization process of chroma transformed DC coeffs.
  1912.     DCzero = quant_dc_cr(M4, cur_qp_dc, DCLevel, DCRun, fadjust4x2, levelscaleDC[0][0], invlevelscaleDC[0][0], leveloffsetDC, SCAN_YUV422, is_cavlc);
  1914.     if (DCzero)
  1915.     {
  1916.       currMB->cbp_blk |= 0xff0000 << (uv << 3) ;   // if one of the DC levels is != 0 set the
  1917.       cr_cbp=imax(1,cr_cbp);                       // coded-bit all 4 4x4 blocks (bit 16-31 or 32-47) //YUV444
  1918.     }
  1920.     //inverse DC transform. Note that now M4 is transposed back
  1921.     ihadamard4x2(M4, M4);    
  1923.     // This code assumes sizeof(int) > 16. Therefore, no need to have conditional
  1924.     for (j = 0; j < 4; j++)
  1925.     {
  1926.       mb_rres[j << 2 ][0] = M4[j][0];
  1927.       mb_rres[j << 2 ][4] = M4[j][1];
  1928.     }
  1929.   }
  1931.   //     Quant of chroma AC-coeffs.
  1932.   for (b8=0; b8 < (img->num_blk8x8_uv >> 1); b8++)
  1933.   {
  1934.     for (b4=0; b4 < 4; b4++)
  1935.     {
  1936.       int64 uv_cbpblk = ((int64)1) << cbp_blk_chroma[b8 + uv_scale][b4];      
  1937.       n1 = hor_offset[yuv][b8][b4];
  1938.       n2 = ver_offset[yuv][b8][b4];
  1939.       ACLevel = img->cofAC[4 + b8 + uv_scale][b4][0];
  1940.       ACRun   = img->cofAC[4 + b8 + uv_scale][b4][1];
  1942.       // Quantization process
  1943.       nonzero[n2>>2][n1>>2] = quant_ac4x4cr(&mb_rres[n2], n2, n1, cur_qp, ACLevel, ACRun, &fadjust4x4[n2], 
  1944.         levelscale, invlevelscale, leveloffset, &coeff_cost, pos_scan, c_cost, CHROMA_AC, is_cavlc);
  1946.       if (nonzero[n2>>2][n1>>2])
  1947.       {
  1948.         currMB->cbp_blk |= uv_cbpblk;
  1949.         cr_cbp_tmp = 2;
  1950.         nonezero = TRUE;
  1951.       }
  1952.     }
  1953.   }
  1955.   // Perform thresholding
  1956.   // * reset chroma coeffs
  1957.   if(nonezero && coeff_cost < _CHROMA_COEFF_COST_)
  1958.   {
  1959.     int64 uv_cbpblk = ((int64)cbpblk_pattern[yuv] << (uv << (1+yuv)));
  1960.     cr_cbp_tmp = 0;
  1962.     for (b8 = 0; b8 < (img->num_blk8x8_uv >> 1); b8++)
  1963.     {
  1964.       for (b4 = 0; b4 < 4; b4++)
  1965.       {
  1966.         n1 = hor_offset[yuv][b8][b4];
  1967.         n2 = ver_offset[yuv][b8][b4];
  1968.         if (nonzero[n2>>2][n1>>2] == TRUE)
  1969.         {
  1970.           nonzero[n2>>2][n1>>2] = FALSE;
  1971.           ACLevel = img->cofAC[4 + b8 + uv_scale][b4][0];
  1972.           ACRun   = img->cofAC[4 + b8 + uv_scale][b4][1];
  1974.           if (DCzero == 0)
  1975.             currMB->cbp_blk &= ~(uv_cbpblk);  // if no chroma DC's: then reset coded-bits of this chroma subblock
  1977.           ACLevel[0] = 0;
  1979.           for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// ac coeff
  1980.           {
  1981.             mb_rres[n2 + pos_scan[coeff_ctr][1]][n1 + pos_scan[coeff_ctr][0]] = 0;
  1982.             ACLevel[coeff_ctr]  = 0;
  1983.           }
  1984.         }
  1985.       }
  1986.     }
  1987.   }
  1989.   //     IDCT.
  1990.   //     Horizontal.
  1991.   if(cr_cbp_tmp == 2)
  1992.     cr_cbp = 2;
  1994.   nonezero = FALSE;
  1995.   for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1996.   {
  1997.     for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1998.     {
  1999.       if (mb_rres[n2][n1] != 0 || nonzero[n2>>2][n1>>2] == TRUE)
  2000.       {
  2001.         inverse4x4(mb_rres, mb_rres, n2, n1);
  2002.         nonezero = TRUE;
  2003.       }
  2004.     }
  2005.   }
  2007.   //  Decoded block moved to memory
  2008.   if (nonezero == TRUE)
  2009.   {
  2010.     SampleReconstruct (enc_picture->imgUV[uv], mb_pred, mb_rres, 0, 0, img->pix_c_y, img->pix_c_x, img->mb_cr_size_x, img->mb_cr_size_y, max_imgpel_value_uv, DQ_BITS);
  2011.   }
  2012.   else
  2013.   {
  2014.     for (j=0; j < img->mb_cr_size_y; j++)
  2015.     {
  2016.       memcpy(&enc_picture->imgUV[uv][img->pix_c_y + j][img->pix_c_x], mb_pred[j], img->mb_cr_size_x * sizeof(imgpel));
  2017.     }
  2018.   }
  2020.   return cr_cbp;
  2021. }
  2023. int dct_chroma_sp_old(Macroblock *currMB, int uv,int cr_cbp, int is_cavlc)
  2024. {
  2025.   int i,j,ilev,n2,n1,coeff_ctr,c_err,level ,scan_pos,run;
  2026.   int m1[BLOCK_SIZE];
  2027.   int coeff_cost;
  2028.   int cr_cbp_tmp;
  2029.   int mp1[BLOCK_SIZE];
  2030.   const byte *c_cost = COEFF_COST4x4[params->disthres];
  2031.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  2033.   int   intra = IS_INTRA (currMB);
  2035.   int   b4;
  2036.   int*  DCLevel = img->cofDC[uv+1][0];
  2037.   int*  DCRun   = img->cofDC[uv+1][1];
  2038.   int*  ACLevel;
  2039.   int*  ACRun;
  2041.   int c_err1, c_err2, level1, level2;
  2042.   int len, info;
  2043.   double D_dis1, D_dis2;
  2044.   double lambda_mode   = 0.85 * pow (2, (currMB->qp -SHIFT_QP)/3.0) * 4;
  2045.   int max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  2047.   int qpChroma = currMB->qpc[uv] + img->bitdepth_chroma_qp_scale;   
  2048.   int qpChromaSP=iClip3(-img->bitdepth_chroma_qp_scale, 51, currMB->qpsp + active_pps->chroma_qp_index_offset);
  2049.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[uv + 1]; 
  2050.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[uv + 1]; 
  2051.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[uv + 1]; 
  2053.   int qp_per    = qp_per_matrix[qpChroma];
  2054.   int qp_rem    = qp_rem_matrix[qpChroma];
  2055.   int q_bits    = Q_BITS + qp_per;
  2056.   int qp_const  = (1<<q_bits)/6;    // inter
  2057.   int qp_per_sp = qp_per_matrix[qpChromaSP];
  2058.   int qp_rem_sp = qp_rem_matrix[qpChromaSP];
  2059.   int q_bits_sp = Q_BITS + qp_per_sp;
  2060.   int qp_const2 = (1<<q_bits_sp)/2;  //sp_pred
  2061.   
  2062.   levelscale    = LevelScale4x4Comp   [uv + 1][intra][qp_rem];
  2063.   invlevelscale = InvLevelScale4x4Comp[uv + 1][intra][qp_rem];
  2064.   leveloffset   = LevelOffset4x4Comp  [uv + 1][intra][qpChroma];
  2066.   levelscale_sp    = LevelScale4x4Comp   [uv + 1][intra][qp_rem_sp];
  2067.   invlevelscale_sp = InvLevelScale4x4Comp[uv + 1][intra][qp_rem_sp];
  2068.   leveloffset_sp   = LevelOffset4x4Comp  [uv + 1][intra][qpChromaSP];
  2070.   for (j=0; j < img->mb_cr_size_y; j++)
  2071.   {
  2072.     for (i=0; i < img->mb_cr_size_x; i++)
  2073.     {
  2074.       mb_rres[j][i]  = mb_ores[j][i];
  2075.       mb_rres[j][i] += mb_pred[j][i];
  2076.       M1[j][i] = mb_pred[j][i];
  2077.     }
  2078.   }
  2079.   
  2080.   for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  2081.   {
  2082.     for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  2083.     {
  2084.       forward4x4(mb_rres, mb_rres, n2, n1);      
  2085.       forward4x4(M1, M1, n2, n1);
  2086.     }
  2087.   }
  2089.   //     2X2 transform of DC coeffs.
  2090.   hadamard2x2(mb_rres, m1);
  2091.   hadamard2x2(M1, mp1);
  2093.   run=-1;
  2094.   scan_pos=0;
  2096.   for (coeff_ctr = 0; coeff_ctr < 4; coeff_ctr++)
  2097.   {
  2098.     run++;
  2099.     ilev=0;
  2101.     // case 1
  2102.     c_err1 = (iabs (mp1[coeff_ctr]) * levelscale_sp[0][0] + 2 * qp_const2) >> (q_bits_sp + 1);
  2103.     c_err1 = (c_err1 << (q_bits_sp + 1)) / levelscale_sp[0][0];
  2104.     c_err1 = m1[coeff_ctr] - isignab(c_err1, mp1[coeff_ctr]);
  2105.     level1 = (iabs(c_err1) * levelscale[0][0] + 2 * qp_const) >> (q_bits+1);
  2107.     // case 2
  2108.     c_err2 = m1[coeff_ctr] - mp1[coeff_ctr];
  2109.     level2 = (iabs(c_err2) * levelscale[0][0] + 2 * qp_const) >> (q_bits+1);
  2111.     if (level1 != level2 && level1 != 0 && level2 != 0)
  2112.     {
  2113.       D_dis1 = m1[coeff_ctr] - ((isignab(level1,c_err1)*invlevelscale[0][0] * A[0][0]<< qp_per) >>5)- mp1[coeff_ctr];
  2114.       levrun_linfo_c2x2(level1, run, &len, &info);
  2115.       D_dis1 = D_dis1 * D_dis1 + lambda_mode * len;
  2117.       D_dis2 = m1[coeff_ctr] - ((isignab(level2,c_err2)*invlevelscale[0][0] * A[0][0]<< qp_per) >>5)- mp1[coeff_ctr];
  2118.       levrun_linfo_c2x2(level2, run, &len, &info);
  2119.       D_dis2 = D_dis2 * D_dis2 + lambda_mode * len;
  2121.       if (D_dis1 == D_dis2)
  2122.         level = (iabs(level1) < iabs(level2)) ? level1 : level2;
  2123.       else if (D_dis1 < D_dis2)
  2124.         level = level1;
  2125.       else
  2126.         level = level2;
  2128.       c_err = (level == level1) ? c_err1 : c_err2;
  2129.     }
  2130.     else if (level1 == level2)
  2131.     {
  2132.       level = level1;
  2133.       c_err = c_err1;
  2134.     }
  2135.     else
  2136.     {
  2137.       level = (level1 == 0) ? level1 : level2;
  2138.       c_err = (level1 == 0) ? c_err1 : c_err2;
  2139.     }
  2141.     if (level  != 0)
  2142.     {
  2143.       if (is_cavlc)
  2144.         level = imin(level, CAVLC_LEVEL_LIMIT);
  2145.       
  2146.       currMB->cbp_blk |= 0xf0000 << (uv << 2) ;  // if one of the 2x2-DC levels is != 0 the coded-bit
  2147.       cr_cbp = imax(1, cr_cbp);
  2148.       DCLevel[scan_pos  ] = isignab(level ,c_err);
  2149.       DCRun  [scan_pos++] = run;
  2150.       run=-1;
  2151.       ilev=((isignab(level,c_err)*invlevelscale[0][0]*A[0][0]<< qp_per) >>5);
  2152.     }
  2154.     ilev+= mp1[coeff_ctr];
  2155.     m1[coeff_ctr]=isignab((iabs(ilev)  * levelscale_sp[0][0] + 2 * qp_const2) >> (q_bits_sp+1), ilev) * invlevelscale_sp[0][0] << qp_per_sp;
  2156.     if(!si_frame_indicator && !sp2_frame_indicator)
  2157.       lrec_uv[uv][img->pix_c_y+4*(coeff_ctr%2)][img->pix_c_x+4*(coeff_ctr/2)]=isignab((iabs(ilev)  * levelscale_sp[0][0] + 2 * qp_const2) >> (q_bits_sp+1), ilev);// stores the SP frames coefficients, will be useful to encode SI or switching SP frame
  2158.   }
  2159.   DCLevel[scan_pos] = 0;
  2161.   //  Inverse transform of 2x2 DC levels
  2162.   ihadamard2x2(m1, m1);
  2164.   mb_rres[0][0]=(m1[0])>>1;
  2165.   mb_rres[0][4]=(m1[1])>>1;
  2166.   mb_rres[4][0]=(m1[2])>>1;
  2167.   mb_rres[4][4]=(m1[3])>>1;
  2169.   //     Quant of chroma AC-coeffs.
  2170.   coeff_cost=0;
  2171.   cr_cbp_tmp=0;
  2173.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2174.   {
  2175.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2176.     {
  2177.       b4      = 2*(n2 >> 2) + (n1 >> 2);
  2178.       ACLevel = img->cofAC[uv+4][b4][0];
  2179.       ACRun   = img->cofAC[uv+4][b4][1];
  2181.       run      = -1;
  2182.       scan_pos =  0;
  2184.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// start change rd_quant
  2185.       {
  2186.         i=pos_scan[coeff_ctr][0];
  2187.         j=pos_scan[coeff_ctr][1];
  2189.         ++run;
  2190.         ilev=0;
  2192.         // quantization on prediction
  2193.         c_err1 = (iabs(M1[n2+j][n1+i]) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp;
  2194.         c_err1 = (c_err1 << q_bits_sp) / levelscale_sp[j][i];
  2195.         c_err1 = mb_rres[n2+j][n1+i] - isignab(c_err1, M1[n2+j][n1+i]);
  2196.         level1 = (iabs(c_err1) * levelscale[j][i] + qp_const) >> q_bits;
  2198.         // no quantization on prediction
  2199.         c_err2 = mb_rres[n2+j][n1+i] - M1[n2+j][n1+i];
  2200.         level2 = (iabs(c_err2) * levelscale[j][i] + qp_const) >> q_bits;
  2202.         if (level1 != level2 && level1 != 0 && level2 != 0)
  2203.         {
  2204.           D_dis1 = mb_rres[n2+j][n1+i] - ((isignab(level1,c_err1)*invlevelscale[j][i]*A[j][i]<< qp_per) >>6) - M1[n2+j][n1+i];
  2206.           levrun_linfo_inter(level1, run, &len, &info);
  2207.           D_dis1 = D_dis1 * D_dis1 + lambda_mode * len;
  2209.           D_dis2 = mb_rres[n2+j][n1+i] - ((isignab(level2,c_err2)*invlevelscale[j][i]*A[j][i]<< qp_per) >>6) - M1[n2+j][n1+i];
  2210.           levrun_linfo_inter(level2, run, &len, &info);
  2211.           D_dis2 = D_dis2 * D_dis2 + lambda_mode * len;
  2213.           if (D_dis1 == D_dis2)
  2214.             level = (iabs(level1) < iabs(level2)) ? level1 : level2;
  2215.           else
  2216.           {
  2217.             if (D_dis1 < D_dis2)
  2218.               level = level1;
  2219.             else
  2220.               level = level2;
  2221.           }
  2222.           c_err = (level == level1) ? c_err1 : c_err2;
  2223.         }
  2224.         else if (level1 == level2)
  2225.         {
  2226.           level = level1;
  2227.           c_err = c_err1;
  2228.         }
  2229.         else
  2230.         {
  2231.           level = (level1 == 0) ? level1 : level2;
  2232.           c_err = (level1 == 0) ? c_err1 : c_err2;
  2233.         }
  2235.         if (level  != 0)
  2236.         {
  2237.           currMB->cbp_blk |=  (int64)1 << (16 + (uv << 2) + ((n2 >> 1) + (n1 >> 2))) ;
  2239.           coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];  // set high cost, shall not be discarded
  2241.           cr_cbp_tmp=2;
  2242.           level = isignab(level,c_err);
  2243.           ACLevel[scan_pos] = level;
  2244.           ACRun  [scan_pos] = run;
  2245.           ++scan_pos;
  2246.           run=-1;
  2247.           ilev=((level * invlevelscale[j][i]*A[j][i]<< qp_per) >>6);
  2248.         }
  2249.         ilev+=M1[n2+j][n1+i];
  2250.         if(!si_frame_indicator && !sp2_frame_indicator)
  2251.           if(!( (n2+j) % 4==0 && (n1+i)%4 ==0 ))
  2252.             lrec_uv[uv][img->pix_c_y+n1+j][img->pix_c_x+n2+i]=isignab((iabs(ilev) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp,ilev);//stores the SP frames coefficients, will be useful to encode SI or switching SP frame
  2253.         mb_rres[n2+j][n1+i] = isignab((iabs(ilev) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp,ilev) * invlevelscale_sp[j][i] << qp_per_sp;
  2254.       }
  2255.       ACLevel[scan_pos] = 0;
  2256.     }
  2257.   }
  2259.   // * reset chroma coeffs
  2261.   if(cr_cbp_tmp==2)
  2262.     cr_cbp=2;
  2263.   //     IDCT.
  2265.   //     Horizontal.
  2266.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2267.   {
  2268.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2269.     {
  2270.       inverse4x4(mb_rres, mb_rres, n2, n1);
  2272.       for (j=0; j < BLOCK_SIZE; j++)
  2273.         for (i=0; i < BLOCK_SIZE; i++)
  2274.         {
  2275.           mb_rres[n2+j][n1+i] = iClip1 (max_imgpel_value_uv,rshift_rnd_sf(mb_rres[n2+j][n1+i], DQ_BITS));
  2276.         }
  2277.     }
  2278.   }
  2280.   //  Decoded block moved to memory
  2281.   for (j=0; j < BLOCK_SIZE*2; j++)
  2282.     for (i=0; i < BLOCK_SIZE*2; i++)
  2283.     {
  2284.       enc_picture->imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= (imgpel) mb_rres[j][i];
  2285.     }
  2287.     return cr_cbp;
  2288. }
  2290. /*!
  2291.  ************************************************************************
  2292.  * brief
  2293.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  2294.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  2295.  *    RD constrained quantization also.
  2296.  *
  2297.  * par Input:
  2298.  *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  2299.  *
  2300.  * par Output:
  2301.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.            n
  2302.  *    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
  2303.  ************************************************************************
  2304.  */
  2305. void copyblock_sp(Macroblock *currMB, ColorPlane pl, int block_x,int block_y)
  2306. {
  2307.   int i, j;
  2309.   int cur_qp = currMB->qpsp + img->bitdepth_luma_qp_scale;  
  2310.   int qp_per = qp_per_matrix[cur_qp];
  2311.   int qp_rem = qp_rem_matrix[cur_qp];
  2312.   int q_bits = Q_BITS + qp_per;
  2313.   int qp_const2=(1<<q_bits)/2;  //sp_pred
  2314.   imgpel **img_enc       = enc_picture->p_curr_img;
  2315.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl]; 
  2316.   int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl]; 
  2317.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl]; 
  2319.   levelscale    = LevelScale4x4Comp[pl][0][qp_rem];
  2320.   invlevelscale = InvLevelScale4x4Comp[pl][0][qp_rem];
  2321.   leveloffset   = ptLevelOffset4x4[0][cur_qp];
  2323.   //  Horizontal transform
  2324.   for (j=0; j< BLOCK_SIZE; j++)
  2325.   {
  2326.     for (i=0; i< BLOCK_SIZE; i++)
  2327.     {
  2328.       mb_rres[j+block_y][i+block_x] = mb_ores[j+block_y][i+block_x];
  2329.       M1[i][j]=mb_pred[j+block_y][i+block_x];
  2330.     }
  2331.   }
  2333.   forward4x4(M1, M1, 0, 0);
  2335.   // Quant
  2336.   for (j=0;j < BLOCK_SIZE; j++)
  2337.   {
  2338.     for (i=0; i < BLOCK_SIZE; i++)
  2339.     {
  2340.       mb_rres[j][i]=isignab((iabs(M1[i][j])* levelscale[i][j]+qp_const2)>> q_bits,M1[i][j])*levelscale[i][j]<<qp_per;
  2341.       if(!si_frame_indicator && !sp2_frame_indicator)
  2342.       {
  2343.         lrec[img->pix_y+block_y+j][img->pix_x+block_x+i] =
  2344.           isignab((iabs(M1[i][j]) * levelscale[i][j] + qp_const2) >> q_bits, M1[i][j]);// stores the SP frames coefficients, will be useful to encode SI or switching SP frame
  2345.       }
  2346.     }
  2347.   }
  2349.   //     IDCT.
  2350.   //     horizontal
  2351.   inverse4x4(mb_rres, mb_rres, 0, 0);
  2353.   //  Decoded block moved to frame memory
  2354.   for (j=0; j < BLOCK_SIZE; j++)
  2355.   {
  2356.     for (i=0; i < BLOCK_SIZE; i++)
  2357.     {
  2358.       mb_rres[j][i] = iClip1 (img->max_imgpel_value, mb_rres[j][i]);
  2359.       img_enc[img->pix_y+block_y+j][img->pix_x+block_x+i]=(imgpel) mb_rres[j][i];
  2360.     }
  2361.   }
  2362. }
  2364. /*!
  2365.  ************************************************************************
  2366.  * brief Eric Setton
  2367.  * Encoding of a secondary SP / SI frame.
  2368.  * For an SI frame the predicted block should only come from spatial pred.
  2369.  * The original image signal is the error coefficients of a primary SP in the raw data stream
  2370.  * the difference with the primary SP are :
  2371.  *  - the prediction signal is transformed and quantized (qpsp) but not dequantized
  2372.  *  - only one kind of prediction is considered and not two
  2373.  *  - the resulting error coefficients are not quantized before being sent to the VLC
  2374.  *
  2375.  * par Input:
  2376.  *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  2377.  *
  2378.  * par Output:
  2379.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.
  2380.  *    coeff_cost: Counter for nonzero coefficients, used to discard expensive levels.
  2381.  *
  2382.  *
  2383.  ************************************************************************
  2384.  */
  2386. int dct_4x4_sp2(Macroblock *currMB, ColorPlane pl, int block_x,int block_y,int *coeff_cost, int intra, int is_cavlc)
  2387. {
  2388.   int i,j,ilev,coeff_ctr;
  2389.   int qp_const,level,scan_pos = 0,run = -1;
  2390.   int nonzero = FALSE;
  2392.   imgpel **img_enc = enc_picture->p_curr_img;
  2393.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[pl];   
  2394. //  int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[pl];   
  2395.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[pl];   
  2396.   int c_err,qp_const2;
  2398.   int   pos_x   = block_x >> BLOCK_SHIFT;
  2399.   int   pos_y   = block_y >> BLOCK_SHIFT;
  2400.   int   b8      = 2*(pos_y >> 1) + (pos_x >> 1);
  2401.   int   b4      = 2*(pos_y & 0x01) + (pos_x & 0x01);
  2402.   int*  ACLevel = img->cofAC[b8][b4][0];
  2403.   int*  ACRun   = img->cofAC[b8][b4][1];
  2404.   const byte *c_cost = COEFF_COST4x4[params->disthres];
  2405.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  2407.   int level1;
  2409.   int   qp    = (currMB->qpsp); // should double check spec why these are equal
  2410.   int   qp_sp = (currMB->qpsp);
  2412.   int qp_per    = qp_per_matrix[qp];
  2413.   int qp_rem    = qp_rem_matrix[qp];
  2414.   int q_bits    = Q_BITS + qp_per;
  2415.   int qp_per_sp = qp_per_matrix[qp_sp];
  2416.   int qp_rem_sp = qp_rem_matrix[qp_sp];
  2417.   int q_bits_sp = Q_BITS + qp_per_sp;
  2419.   levelscale    = LevelScale4x4Comp[pl][intra][qp_rem];
  2420.   invlevelscale = InvLevelScale4x4Comp[pl][intra][qp_rem];
  2421.   leveloffset   = ptLevelOffset4x4[intra][qp];
  2423.   levelscale_sp    = LevelScale4x4Comp[pl][intra][qp_rem_sp];
  2424.   invlevelscale_sp = InvLevelScale4x4Comp[pl][intra][qp_rem_sp];
  2425.   leveloffset_sp   = ptLevelOffset4x4[intra][qp_sp];
  2427.   qp_const=(1<<q_bits)/6;    // inter
  2428.   qp_const2=(1<<q_bits_sp)/2;  //sp_pred
  2430.   for (j=0; j< BLOCK_SIZE; j++)
  2431.   {
  2432.     for (i=0; i< BLOCK_SIZE; i++)
  2433.     {
  2434.       //Coefficients obtained from the prior encoding of the SP frame
  2435.       mb_rres[j][i] = lrec[img->pix_y+block_y+j][img->pix_x+block_x+i];
  2436.       //Predicted block
  2437.       M1[j][i]=mb_pred[j+block_y][i+block_x];
  2438.     }
  2439.   }
  2440.   // forward transform
  2441.   forward4x4(M1, M1, 0, 0);
  2443.   for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)     // 8 times if double scan, 16 normal scan
  2444.   {
  2446.     i=pos_scan[coeff_ctr][0];
  2447.     j=pos_scan[coeff_ctr][1];
  2449.     run++;
  2450.     ilev=0;
  2452.     //quantization of the predicted block
  2453.     level1 = (iabs (M1[j][i]) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp;
  2454.     //substracted from lrec
  2455.     c_err = mb_rres[j][i]-isignab(level1, M1[j][i]);   //substracting the predicted block
  2457.     level = iabs(c_err);
  2458.     if (level != 0)
  2459.     {
  2460.       nonzero=TRUE;
  2462.       *coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];
  2464.       ACLevel[scan_pos] = isignab(level,c_err);
  2465.       ACRun  [scan_pos] = run;
  2466.       ++scan_pos;
  2467.       run=-1;                     // reset zero level counter
  2468.     }
  2469.     //from now on we are in decoder land
  2470.     ilev=c_err + isignab(level1,M1[j][i]) ;  // adding the quantized predicted block
  2471.     mb_rres[j][i] = ilev * invlevelscale_sp[j][i] << qp_per_sp;
  2473.   }
  2474.   ACLevel[scan_pos] = 0;
  2476.   //  Inverse transform
  2477.   inverse4x4(mb_rres, mb_rres, 0, 0);
  2479.   for (j=0; j < BLOCK_SIZE; j++)
  2480.     for (i=0; i < BLOCK_SIZE; i++)
  2481.       img_enc[img->pix_y+block_y+j][img->pix_x+block_x+i] =iClip3 (0, img->max_imgpel_value,rshift_rnd_sf(mb_rres[j][i], DQ_BITS));
  2483.   return nonzero;
  2484. }
  2487. /*!
  2488.  ************************************************************************
  2489.  * brief Eric Setton
  2490.  * Encoding of the chroma of a  secondary SP / SI frame.
  2491.  * For an SI frame the predicted block should only come from spatial pred.
  2492.  * The original image signal is the error coefficients of a primary SP in the raw data stream
  2493.  * the difference with the primary SP are :
  2494.  *  - the prediction signal is transformed and quantized (qpsp) but not dequantized
  2495.  *  - the resulting error coefficients are not quantized before being sent to the VLC
  2496.  *
  2497.  * par Input:
  2498.  *    uv    : Make difference between the U and V chroma component
  2499.  *    cr_cbp: chroma coded block pattern
  2500.  *
  2501.  * par Output:
  2502.  *    cr_cbp: Updated chroma coded block pattern.
  2503.  *
  2504.  ************************************************************************
  2505.  */
  2506. int dct_chroma_sp2(Macroblock *currMB, int uv,int cr_cbp, int is_cavlc)
  2507. {
  2508.   int i,j,ilev,n2,n1,coeff_ctr,c_err,level ,scan_pos = 0,run = -1;
  2509.   int m1[BLOCK_SIZE];
  2510.   int coeff_cost;
  2511.   int cr_cbp_tmp;
  2512.   int mp1[BLOCK_SIZE];
  2513.   const byte *c_cost = COEFF_COST4x4[params->disthres];
  2514.   const byte (*pos_scan)[2] = currMB->is_field_mode ? FIELD_SCAN : SNGL_SCAN;
  2516.   int   b4;
  2517.   int*  DCLevel = img->cofDC[uv+1][0];
  2518.   int*  DCRun   = img->cofDC[uv+1][1];
  2519.   int*  ACLevel;
  2520.   int*  ACRun;
  2521.   int  level1;
  2522.   int    (*mb_rres)[MB_BLOCK_SIZE] = img->mb_rres[uv + 1]; 
  2523.   //int    (*mb_ores)[MB_BLOCK_SIZE] = img->mb_ores[uv + 1]; 
  2524.   imgpel (*mb_pred)[MB_BLOCK_SIZE] = img->mb_pred[uv + 1]; 
  2525.   int   intra = IS_INTRA (currMB);
  2527.   int qpChroma   = currMB->qpc[uv] + img->bitdepth_chroma_qp_scale;   
  2528.   int qpChromaSP = iClip3(-img->bitdepth_chroma_qp_scale, 51, currMB->qpsp + active_pps->chroma_qp_index_offset);
  2530.   int qp_per    = qp_per_matrix[qpChroma];
  2531.   int qp_rem    = qp_rem_matrix[qpChroma];
  2533.   int qp_per_sp = qp_per_matrix[qpChromaSP];
  2534.   int qp_rem_sp = qp_rem_matrix[qpChromaSP];
  2535.   int q_bits_sp = Q_BITS + qp_per;
  2536.   int qp_const2 = (1 << q_bits_sp)/2;  //sp_pred
  2538.   levelscale    = LevelScale4x4Comp[uv + 1][intra][qp_rem];
  2539.   invlevelscale = InvLevelScale4x4Comp[uv + 1][intra][qp_rem];
  2540.   leveloffset   = ptLevelOffset4x4[intra][qpChroma];
  2542.   levelscale_sp    = LevelScale4x4Comp[uv + 1][intra][qp_rem_sp];
  2543.   invlevelscale_sp = InvLevelScale4x4Comp[uv + 1][intra][qp_rem_sp];
  2544.   leveloffset_sp   = ptLevelOffset4x4[intra][qpChromaSP];
  2546.   for (j=0; j < MB_BLOCK_SIZE>>1; j++)
  2547.   {
  2548.     for (i=0; i < MB_BLOCK_SIZE>>1; i++)
  2549.     {
  2550.       M1[j][i]=mb_pred[j][i];
  2551.       mb_rres[j][i]=lrec_uv[uv][img->pix_c_y+j][img->pix_c_x+i];
  2552.     }
  2553.   }
  2556.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2557.   {
  2558.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2559.     {
  2560.       forward4x4(M1, M1, n2, n1);
  2561.     }
  2562.   }
  2564.   //   DC coefficients already transformed and quantized
  2565.   m1[0]= mb_rres[0][0];
  2566.   m1[1]= mb_rres[0][4];
  2567.   m1[2]= mb_rres[4][0];
  2568.   m1[3]= mb_rres[4][4];
  2570.   //     2X2 transform of predicted DC coeffs.
  2571.   hadamard2x2(M1, mp1);
  2573.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  2574.   {
  2575.     run++;
  2576.     ilev=0;
  2578.     //quantization of predicted DC coeff
  2579.     level1 = (iabs (mp1[coeff_ctr]) * levelscale_sp[0][0] + 2 * qp_const2) >> (q_bits_sp + 1);
  2580.     //substratcted from lrecUV
  2581.     c_err = m1[coeff_ctr] - isignab(level1, mp1[coeff_ctr]);
  2582.     level = iabs(c_err);
  2584.     if (level  != 0)
  2585.     {
  2586.       currMB->cbp_blk |= 0xf0000 << (uv << 2) ;  // if one of the 2x2-DC levels is != 0 the coded-bit
  2587.       cr_cbp=imax(1,cr_cbp);
  2588.       DCLevel[scan_pos] = isignab(level ,c_err);
  2589.       DCRun  [scan_pos] = run;
  2590.       scan_pos++;
  2591.       run=-1;
  2592.     }
  2594.     //from now on decoder world
  2595.     ilev = c_err + isignab(level1,mp1[coeff_ctr]) ; // we have perfect reconstruction here
  2597.     m1[coeff_ctr]= ilev  * invlevelscale_sp[0][0] << qp_per_sp;
  2599.   }
  2600.   DCLevel[scan_pos] = 0;
  2602.   //  Inverse transform of 2x2 DC levels
  2603.   ihadamard2x2(m1, m1);
  2605.   mb_rres[0][0]=m1[0]/2;
  2606.   mb_rres[0][4]=m1[1]/2;
  2607.   mb_rres[4][0]=m1[2]/2;
  2608.   mb_rres[4][4]=m1[3]/2;
  2610.   //     Quant of chroma AC-coeffs.
  2611.   coeff_cost=0;
  2612.   cr_cbp_tmp=0;
  2614.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2615.   {
  2616.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2617.     {
  2618.       b4      = 2*(n2/4) + (n1/4);
  2619.       ACLevel = img->cofAC[uv+4][b4][0];
  2620.       ACRun   = img->cofAC[uv+4][b4][1];
  2622.       run      = -1;
  2623.       scan_pos =  0;
  2625.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// start change rd_quant
  2626.       {
  2628.         i=pos_scan[coeff_ctr][0];
  2629.         j=pos_scan[coeff_ctr][1];
  2631.         ++run;
  2632.         ilev=0;
  2633.         // quantization on prediction
  2634.         level1 = (iabs(M1[n2+j][n1+i]) * levelscale_sp[j][i] + qp_const2) >> q_bits_sp;
  2635.         //substracted from lrec
  2636.         c_err  = mb_rres[n2+j][n1+i] - isignab(level1, M1[n2+j][n1+i]);
  2637.         level  = iabs(c_err) ;
  2639.         if (level  != 0)
  2640.         {
  2641.           currMB->cbp_blk |=  (int64)1 << (16 + (uv << 2) + ((n2 >> 1) + (n1 >> 2))) ;
  2643.           coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];
  2645.           cr_cbp_tmp=2;
  2646.           ACLevel[scan_pos] = isignab(level,c_err);
  2647.           ACRun  [scan_pos] = run;
  2648.           ++scan_pos;
  2649.           run=-1;
  2650.         }
  2652.         //from now on decoder land
  2653.         ilev=c_err + isignab(level1,M1[n2+j][n1+i]);
  2654.         mb_rres[n2+j][n1+i] = ilev * invlevelscale_sp[j][i] << qp_per_sp;
  2655.       }
  2656.       ACLevel[scan_pos] = 0;
  2657.     }
  2658.   }
  2659.   // * reset chroma coeffs
  2661.   if(cr_cbp_tmp==2)
  2662.     cr_cbp=2;
  2663.   //     IDCT.
  2665.   //     Horizontal.
  2666.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2667.   {
  2668.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2669.     {
  2670.       inverse4x4(mb_rres, mb_rres, n2, n1);
  2672.       //     Vertical.
  2673.       for (j=0; j < BLOCK_SIZE; j++)
  2674.       {
  2675.         for (i=0; i < BLOCK_SIZE; i++)
  2676.         {
  2677.           enc_picture->imgUV[uv][img->pix_c_y+j+n2][img->pix_c_x+i +n1 ] = iClip3 (0, img->max_imgpel_value,rshift_rnd_sf(mb_rres[n2+j][n1+i], DQ_BITS));
  2678.         }
  2679.       }
  2680.     }
  2681.   }
  2683.   return cr_cbp;
  2684. }
  2687. void select_dct(ImageParameters *img, Macroblock *currMB)
  2688. {
  2689.   if (img->type!=SP_SLICE)
  2690.   {
  2691.     if (img->lossless_qpprime_flag == 1)
  2692.     {
  2693.       if (currMB->qp_scaled[img->colour_plane_id] == 0)
  2694.       {
  2695.         pDCT_4x4   = dct_4x4_ls;
  2696.         pDCT_16x16 = dct_16x16_ls;
  2697.         pDCT_8x8   = dct_8x8_ls;
  2698.       }
  2699.       else
  2700.       {
  2701.         pDCT_4x4   = dct_4x4;
  2702.         pDCT_16x16 = dct_16x16;
  2703.         if (img->currentSlice->symbol_mode == CAVLC)
  2704.           pDCT_8x8   = dct_8x8_cavlc;
  2705.         else
  2706.           pDCT_8x8   = dct_8x8;
  2707.         dct_cr_4x4[0] = dct_chroma;
  2708.         dct_cr_4x4[1] = dct_chroma;
  2709.       }
  2711.       if (currMB->qp_scaled[1] == 0)
  2712.       {
  2713.         dct_cr_4x4[0] = dct_chroma_ls;
  2714.       }
  2715.       if (currMB->qp_scaled[2] == 0)
  2716.       {
  2717.         dct_cr_4x4[1] = dct_chroma_ls;
  2718.       }
  2719.     }
  2720.     else
  2721.     {
  2722.       pDCT_4x4   = dct_4x4;
  2723.       pDCT_16x16 = dct_16x16;
  2724.       if (img->currentSlice->symbol_mode == CAVLC)
  2725.         pDCT_8x8   = dct_8x8_cavlc;
  2726.       else
  2727.         pDCT_8x8   = dct_8x8;
  2729.       dct_cr_4x4[0] = dct_chroma;
  2730.       dct_cr_4x4[1] = dct_chroma;
  2731.     }
  2732.   }
  2733.   else if(!si_frame_indicator && !sp2_frame_indicator)
  2734.   {
  2735.     pDCT_4x4 = dct_4x4_sp;
  2736.     pDCT_16x16 = dct_16x16;
  2737.     if (img->currentSlice->symbol_mode == CAVLC)
  2738.       pDCT_8x8   = dct_8x8_cavlc;
  2739.     else
  2740.       pDCT_8x8   = dct_8x8;
  2742.     dct_cr_4x4[0]  = dct_chroma_sp;
  2743.     dct_cr_4x4[1]  = dct_chroma_sp;
  2744.   }
  2745.   else
  2746.   {
  2747.     pDCT_4x4 = dct_4x4_sp2;
  2748.     pDCT_16x16 = dct_16x16;
  2749.     if (img->currentSlice->symbol_mode == CAVLC)
  2750.       pDCT_8x8   = dct_8x8_cavlc;
  2751.     else
  2752.       pDCT_8x8   = dct_8x8;
  2754.     dct_cr_4x4[0]  = dct_chroma_sp2;
  2755.     dct_cr_4x4[1]  = dct_chroma_sp2;
  2756.   }
  2757. }