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

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

Audio

开发平台：

Visual C++

block.c：源码内容
  2. /*!
  3.  ***********************************************************************
  4.  *  file
  5.  *      block.c
  6.  *
  7.  *  brief
  8.  *      Block functions
  9.  *
  10.  *  author
  11.  *      Main contributors (see contributors.h for copyright, address and affiliation details)
  12.  *      - Inge Lille-Langoy          <inge.lille-langoy@telenor.com>
  13.  *      - Rickard Sjoberg            <rickard.sjoberg@era.ericsson.se>
  14.  ***********************************************************************
  15.  */
  17. #include "contributors.h"
  19. #include "global.h"
  20. #include "block.h"
  21. #include "image.h"
  22. #include "mb_access.h"
  23. #include "transform.h"
  24. #include "quant.h"
  26. // Notation for comments regarding prediction and predictors.
  27. // The pels of the 4x4 block are labelled a..p. The predictor pels above
  28. // are labelled A..H, from the left I..L, and from above left X, as follows:
  29. //
  30. //  X A B C D E F G H
  31. //  I a b c d
  32. //  J e f g h
  33. //  K i j k l
  34. //  L m n o p
  35. //
  37. // Predictor array index definitions
  38. #define P_X (PredPel[0])
  39. #define P_A (PredPel[1])
  40. #define P_B (PredPel[2])
  41. #define P_C (PredPel[3])
  42. #define P_D (PredPel[4])
  43. #define P_E (PredPel[5])
  44. #define P_F (PredPel[6])
  45. #define P_G (PredPel[7])
  46. #define P_H (PredPel[8])
  47. #define P_I (PredPel[9])
  48. #define P_J (PredPel[10])
  49. #define P_K (PredPel[11])
  50. #define P_L (PredPel[12])
  52.   static int M4[BLOCK_SIZE][BLOCK_SIZE];
  53.   static int PBlock[MB_BLOCK_SIZE][MB_BLOCK_SIZE];
  55. static void intra_chroma_DC_single(imgpel **curr_img, int up_avail, int left_avail, PixelPos up, PixelPos left[17], int blk_x, int blk_y, int *pred, int direction )
  56. {
  57.   static int i;
  58.   int s0 = 0;
  60.   if ((direction && up_avail) || (!left_avail && up_avail))
  61.   {
  62.     for (i = blk_x; i < (blk_x + 4);i++)  
  63.       s0 += curr_img[up.pos_y][up.pos_x + i];
  64.     *pred = (s0 + 2) >> 2;
  65.   }
  66.   else if (left_avail)  
  67.   {
  68.     for (i = blk_y; i < (blk_y + 4);i++)  
  69.       s0 += curr_img[left[i].pos_y][left[i].pos_x];
  70.     *pred = (s0 + 2) >> 2;
  71.   }
  72. }
  75. static void intra_chroma_DC_all(imgpel **curr_img, int up_avail, int left_avail, PixelPos up, PixelPos left[17], int blk_x, int blk_y, int *pred )
  76. {
  77.   static int i;
  78.   int s0 = 0, s1 = 0;
  80.   if (up_avail)       
  81.     for (i = blk_x; i < (blk_x + 4);i++)  
  82.       s0 += curr_img[up.pos_y][up.pos_x + i];
  83.   
  84.   if (left_avail)  
  85.     for (i = blk_y; i < (blk_y + 4);i++)  
  86.       s1 += curr_img[left[i].pos_y][left[i].pos_x];
  87.   
  88.   if (up_avail && left_avail)
  89.     *pred = (s0 + s1 + 4) >> 3;
  90.   else if (up_avail)
  91.     *pred = (s0 + 2) >> 2;
  92.   else if (left_avail)
  93.     *pred = (s1 + 2) >> 2;
  94. }
  96. /*!
  97.  ***********************************************************************
  98.  * brief
  99.  *    makes and returns 4x4 blocks with all 5 intra prediction modes
  100.  *
  101.  * return
  102.  *    DECODING_OK   decoding of intraprediction mode was sucessfull            n
  103.  *    SEARCH_SYNC   search next sync element as errors while decoding occured
  104.  ***********************************************************************
  105.  */
  106. int intrapred(ImageParameters *img,  //!< image parameters 
  107.               Macroblock *currMB, 
  108.               ColorPlane pl,               
  109.               int ioff,             //!< pixel offset X within MB
  110.               int joff,             //!< pixel offset Y within MB
  111.               int img_block_x,      //!< location of block X, multiples of 4
  112.               int img_block_y)      //!< location of block Y, multiples of 4
  113. {
  114.   int i,j;
  115.   int s0;  
  116.   imgpel PredPel[13];  // array of predictor pels
  117.   int uv = pl-1;
  118.   imgpel **imgY = (pl) ? dec_picture->imgUV[uv] : dec_picture->imgY;
  120.   PixelPos pix_a[4];
  121.   PixelPos pix_b, pix_c, pix_d;
  123.   int block_available_up;
  124.   int block_available_left;
  125.   int block_available_up_left;
  126.   int block_available_up_right;
  128.   byte predmode = img->ipredmode[img_block_y][img_block_x];
  129.   int jpos0 = joff, jpos1 = joff + 1, jpos2 = joff + 2, jpos3 = joff + 3;
  130.   int ipos0 = ioff, ipos1 = ioff + 1, ipos2 = ioff + 2, ipos3 = ioff + 3;
  131.   imgpel *predrow, prediction, (*mpr)[16] = img->mb_pred[pl];
  133.   ipmode_DPCM = predmode; //For residual DPCM
  135.   for (i=0;i<4;i++)
  136.   {
  137.     getNeighbour(currMB, ioff -1 , joff +i , img->mb_size[IS_LUMA], &pix_a[i]);
  138.   }
  140.   getNeighbour(currMB, ioff    , joff -1 , img->mb_size[IS_LUMA], &pix_b);
  141.   getNeighbour(currMB, ioff +4 , joff -1 , img->mb_size[IS_LUMA], &pix_c);
  142.   getNeighbour(currMB, ioff -1 , joff -1 , img->mb_size[IS_LUMA], &pix_d);
  144.   pix_c.available = pix_c.available && !((ioff==4) && ((joff==4)||(joff==12)));
  146.   if (active_pps->constrained_intra_pred_flag)
  147.   {
  148.     for (i=0, block_available_left=1; i<4;i++)
  149.       block_available_left  &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
  150.     block_available_up       = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
  151.     block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
  152.     block_available_up_left  = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
  153.   }
  154.   else
  155.   {
  156.     block_available_left     = pix_a[0].available;
  157.     block_available_up       = pix_b.available;
  158.     block_available_up_right = pix_c.available;
  159.     block_available_up_left  = pix_d.available;
  160.   }
  162.   // form predictor pels
  163.   if (block_available_up)
  164.   {
  165.     P_A = imgY[pix_b.pos_y][pix_b.pos_x + 0];
  166.     P_B = imgY[pix_b.pos_y][pix_b.pos_x + 1];
  167.     P_C = imgY[pix_b.pos_y][pix_b.pos_x + 2];
  168.     P_D = imgY[pix_b.pos_y][pix_b.pos_x + 3];
  170.   }
  171.   else
  172.   {
  173.     P_A = P_B = P_C = P_D = (imgpel) img->dc_pred_value_comp[pl];
  174.   }
  176.   if (block_available_up_right)
  177.   {
  178.     P_E = imgY[pix_c.pos_y][pix_c.pos_x + 0];
  179.     P_F = imgY[pix_c.pos_y][pix_c.pos_x + 1];
  180.     P_G = imgY[pix_c.pos_y][pix_c.pos_x + 2];
  181.     P_H = imgY[pix_c.pos_y][pix_c.pos_x + 3];
  182.   }
  183.   else
  184.   {
  185.     P_E = P_F = P_G = P_H = P_D;
  186.   }
  188.   if (block_available_left)
  189.   {
  190.     P_I = imgY[pix_a[0].pos_y][pix_a[0].pos_x];
  191.     P_J = imgY[pix_a[1].pos_y][pix_a[1].pos_x];
  192.     P_K = imgY[pix_a[2].pos_y][pix_a[2].pos_x];
  193.     P_L = imgY[pix_a[3].pos_y][pix_a[3].pos_x];
  194.   }
  195.   else
  196.   {
  197.     P_I = P_J = P_K = P_L = (imgpel) img->dc_pred_value_comp[pl];
  198.   }
  200.   if (block_available_up_left)
  201.   {
  202.     P_X = imgY[pix_d.pos_y][pix_d.pos_x];
  203.   }
  204.   else
  205.   {
  206.     P_X = (imgpel) img->dc_pred_value_comp[pl];
  207.   }
  210.   switch (predmode)
  211.   {
  212.   case DC_PRED:                         /* DC prediction */
  214.     s0 = 0;
  215.     if (block_available_up && block_available_left)
  216.     {
  217.       // no edge
  218.       s0 = (P_A + P_B + P_C + P_D + P_I + P_J + P_K + P_L + 4)>>3;
  219.     }
  220.     else if (!block_available_up && block_available_left)
  221.     {
  222.       // upper edge
  223.       s0 = (P_I + P_J + P_K + P_L + 2)>>2;
  224.     }
  225.     else if (block_available_up && !block_available_left)
  226.     {
  227.       // left edge
  228.       s0 = (P_A + P_B + P_C + P_D + 2)>>2;
  229.     }
  230.     else //if (!block_available_up && !block_available_left)
  231.     {
  232.       // top left corner, nothing to predict from
  233.       s0 = img->dc_pred_value_comp[pl];
  234.     }
  236.     for (j=joff; j < joff + BLOCK_SIZE; j++)
  237.     {
  238.       for (i=ioff; i < ioff + BLOCK_SIZE; i++)
  239.       {
  240.         // store DC prediction
  241.         mpr[j][i] = (imgpel) s0;
  242.       }
  243.     }
  244.     break;
  246.   case VERT_PRED:                       /* vertical prediction from block above */
  247.     if (!block_available_up)
  248.       printf ("warning: Intra_4x4_Vertical prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  250.     for(j = joff; j < joff + BLOCK_SIZE; j++) /* store predicted 4x4 block */
  251.       memcpy(&(mpr[j][ioff]), &(imgY[pix_b.pos_y][pix_b.pos_x]), BLOCK_SIZE * sizeof(imgpel));
  252.     break;
  254.   case HOR_PRED:                        /* horizontal prediction from left block */
  255.     if (!block_available_left)
  256.       printf ("warning: Intra_4x4_Horizontal prediction mode not allowed at mb %dn",(int) img->current_mb_nr);
  258.     for(j=0;j<BLOCK_SIZE;j++)
  259.     {
  260.       predrow = mpr[j+joff];
  261.       prediction = imgY[pix_a[j].pos_y][pix_a[j].pos_x];
  262.       for(i = ioff;i < ioff + BLOCK_SIZE;i++)
  263.         predrow[i]= prediction; /* store predicted 4x4 block */
  264.     }
  265.     break;
  267.   case DIAG_DOWN_RIGHT_PRED:
  268.     if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
  269.       printf ("warning: Intra_4x4_Diagonal_Down_Right prediction mode not allowed at mb %dn",(int) img->current_mb_nr);
  271.     mpr[jpos3][ipos0] = (imgpel) ((P_L + 2*P_K + P_J + 2) >> 2);
  272.     mpr[jpos2][ipos0] =
  273.     mpr[jpos3][ipos1] = (imgpel) ((P_K + 2*P_J + P_I + 2) >> 2);
  274.     mpr[jpos1][ipos0] =
  275.     mpr[jpos2][ipos1] =
  276.     mpr[jpos3][ipos2] = (imgpel) ((P_J + 2*P_I + P_X + 2) >> 2);
  277.     mpr[jpos0][ipos0] =
  278.     mpr[jpos1][ipos1] =
  279.     mpr[jpos2][ipos2] =
  280.     mpr[jpos3][ipos3] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
  281.     mpr[jpos0][ipos1] =
  282.     mpr[jpos1][ipos2] =
  283.     mpr[jpos2][ipos3] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
  284.     mpr[jpos0][ipos2] =
  285.     mpr[jpos1][ipos3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  286.     mpr[jpos0][ipos3] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
  287.     break;
  289.   case DIAG_DOWN_LEFT_PRED:
  290.     if (!block_available_up)
  291.       printf ("warning: Intra_4x4_Diagonal_Down_Left prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  293.     mpr[jpos0][ipos0] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
  294.     mpr[jpos0][ipos1] =
  295.     mpr[jpos1][ipos0] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
  296.     mpr[jpos0][ipos2] =
  297.     mpr[jpos1][ipos1] =
  298.     mpr[jpos2][ipos0] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
  299.     mpr[jpos0][ipos3] =
  300.     mpr[jpos1][ipos2] =
  301.     mpr[jpos2][ipos1] =
  302.     mpr[jpos3][ipos0] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
  303.     mpr[jpos1][ipos3] =
  304.     mpr[jpos2][ipos2] =
  305.     mpr[jpos3][ipos1] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
  306.     mpr[jpos2][ipos3] =
  307.     mpr[jpos3][ipos2] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
  308.     mpr[jpos3][ipos3] = (imgpel) ((P_G + 3*(P_H) + 2) >> 2);
  309.     break;
  311.   case  VERT_RIGHT_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  312.     if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
  313.       printf ("warning: Intra_4x4_Vertical_Right prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  315.     mpr[jpos0][ipos0] =
  316.     mpr[jpos2][ipos1] = (imgpel) ((P_X + P_A + 1) >> 1);
  317.     mpr[jpos0][ipos1] =
  318.     mpr[jpos2][ipos2] = (imgpel) ((P_A + P_B + 1) >> 1);
  319.     mpr[jpos0][ipos2] =
  320.     mpr[jpos2][ipos3] = (imgpel) ((P_B + P_C + 1) >> 1);
  321.     mpr[jpos0][ipos3] = (imgpel) ((P_C + P_D + 1) >> 1);
  322.     mpr[jpos1][ipos0] =
  323.     mpr[jpos3][ipos1] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
  324.     mpr[jpos1][ipos1] =
  325.     mpr[jpos3][ipos2] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
  326.     mpr[jpos1][ipos2] =
  327.     mpr[jpos3][ipos3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  328.     mpr[jpos1][ipos3] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
  329.     mpr[jpos2][ipos0] = (imgpel) ((P_X + 2*P_I + P_J + 2) >> 2);
  330.     mpr[jpos3][ipos0] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
  331.     break;
  333.   case  VERT_LEFT_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  334.     if (!block_available_up)
  335.       printf ("warning: Intra_4x4_Vertical_Left prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  337.     mpr[jpos0][ipos0] = (imgpel) ((P_A + P_B + 1) >> 1);
  338.     mpr[jpos0][ipos1] =
  339.     mpr[jpos2][ipos0] = (imgpel) ((P_B + P_C + 1) >> 1);
  340.     mpr[jpos0][ipos2] =
  341.     mpr[jpos2][ipos1] = (imgpel) ((P_C + P_D + 1) >> 1);
  342.     mpr[jpos0][ipos3] =
  343.     mpr[jpos2][ipos2] = (imgpel) ((P_D + P_E + 1) >> 1);
  344.     mpr[jpos2][ipos3] = (imgpel) ((P_E + P_F + 1) >> 1);
  345.     mpr[jpos1][ipos0] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  346.     mpr[jpos1][ipos1] =
  347.     mpr[jpos3][ipos0] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
  348.     mpr[jpos1][ipos2] =
  349.     mpr[jpos3][ipos1] = (imgpel) ((P_C + 2*P_D + P_E + 2) >> 2);
  350.     mpr[jpos1][ipos3] =
  351.     mpr[jpos3][ipos2] = (imgpel) ((P_D + 2*P_E + P_F + 2) >> 2);
  352.     mpr[jpos3][ipos3] = (imgpel) ((P_E + 2*P_F + P_G + 2) >> 2);
  353.     break;
  355.   case  HOR_UP_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  356.     if (!block_available_left)
  357.       printf ("warning: Intra_4x4_Horizontal_Up prediction mode not allowed at mb %dn",(int) img->current_mb_nr);
  359.     mpr[jpos0][ipos0] = (imgpel) ((P_I + P_J + 1) >> 1);
  360.     mpr[jpos0][ipos1] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
  361.     mpr[jpos0][ipos2] =
  362.     mpr[jpos1][ipos0] = (imgpel) ((P_J + P_K + 1) >> 1);
  363.     mpr[jpos0][ipos3] =
  364.     mpr[jpos1][ipos1] = (imgpel) ((P_J + 2*P_K + P_L + 2) >> 2);
  365.     mpr[jpos1][ipos2] =
  366.     mpr[jpos2][ipos0] = (imgpel) ((P_K + P_L + 1) >> 1);
  367.     mpr[jpos1][ipos3] =
  368.     mpr[jpos2][ipos1] = (imgpel) ((P_K + 2*P_L + P_L + 2) >> 2);
  369.     mpr[jpos2][ipos3] =
  370.     mpr[jpos3][ipos1] =
  371.     mpr[jpos3][ipos0] =
  372.     mpr[jpos2][ipos2] =
  373.     mpr[jpos3][ipos2] =
  374.     mpr[jpos3][ipos3] = (imgpel) P_L;
  375.     break;
  377.   case  HOR_DOWN_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  378.     if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
  379.       printf ("warning: Intra_4x4_Horizontal_Down prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  381.     mpr[jpos0][ipos0] =
  382.     mpr[jpos1][ipos2] = (imgpel) ((P_X + P_I + 1) >> 1);
  383.     mpr[jpos0][ipos1] =
  384.     mpr[jpos1][ipos3] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
  385.     mpr[jpos0][ipos2] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
  386.     mpr[jpos0][ipos3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
  387.     mpr[jpos1][ipos0] =
  388.     mpr[jpos2][ipos2] = (imgpel) ((P_I + P_J + 1) >> 1);
  389.     mpr[jpos1][ipos1] =
  390.     mpr[jpos2][ipos3] = (imgpel) ((P_X + 2*P_I + P_J + 2) >> 2);
  391.     mpr[jpos2][ipos0] =
  392.     mpr[jpos3][ipos2] = (imgpel) ((P_J + P_K + 1) >> 1);
  393.     mpr[jpos2][ipos1] =
  394.     mpr[jpos3][ipos3] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
  395.     mpr[jpos3][ipos0] = (imgpel) ((P_K + P_L + 1) >> 1);
  396.     mpr[jpos3][ipos1] = (imgpel) ((P_J + 2*P_K + P_L + 2) >> 2);
  397.     break;
  399.   default:
  400.     printf("Error: illegal intra_4x4 prediction mode: %dn", (int) predmode);
  401.     return SEARCH_SYNC;
  402.     break;
  403.   }
  405.   return DECODING_OK;
  406. }
  409. /*!
  410.  ***********************************************************************
  411.  * return
  412.  *    best SAD
  413.  ***********************************************************************
  414.  */ 
  415. int intrapred_luma_16x16(ImageParameters *img, //!< image parameters
  416.                          Macroblock *currMB,  //!< Current Macroblock
  417.                          ColorPlane pl,       //!< Current colorplane (for 4:4:4)                         
  418.                          int predmode)        //!< prediction mode
  419. {
  420.   int s0 = 0, s1, s2;
  422.   int i,j;
  424.   int ih,iv;
  425.   int ib,ic,iaa;
  427.   int uv = pl-1;
  428.   imgpel **imgY = (pl) ? dec_picture->imgUV[uv] : dec_picture->imgY;
  429.   imgpel (*mpr)[MB_BLOCK_SIZE] = &(img->mb_pred[pl][0]); 
  430.   imgpel *mpr_line;
  431.   imgpel prediction;
  432.   int max_imgpel_value = img->max_imgpel_value_comp[pl];
  434.   PixelPos up;          //!< pixel position p(0,-1)
  435.   PixelPos left[17];    //!< pixel positions p(-1, -1..15)
  437.   int up_avail, left_avail, left_up_avail;
  439.   s1=s2=0;
  441.   for (i=0;i<17;i++)
  442.   {
  443.     getNeighbour(currMB, -1 ,  i-1 , img->mb_size[IS_LUMA], &left[i]);
  444.   }
  445.   getNeighbour(currMB, 0     ,  -1 , img->mb_size[IS_LUMA], &up);
  447.   if (!active_pps->constrained_intra_pred_flag)
  448.   {
  449.     up_avail   = up.available;
  450.     left_avail = left[1].available;
  451.     left_up_avail = left[0].available;
  452.   }
  453.   else
  454.   {
  455.     up_avail      = up.available ? img->intra_block[up.mb_addr] : 0;
  456.     for (i=1, left_avail=1; i<17;i++)
  457.       left_avail  &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
  458.     left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  459.   }
  461.   switch (predmode)
  462.   {
  463.   case VERT_PRED_16:                       // vertical prediction from block above
  464.     if (!up_avail)
  465.       error ("invalid 16x16 intra pred Mode VERT_PRED_16",500);
  466.     for(j=0;j<MB_BLOCK_SIZE;j++)
  467.       memcpy(img->mb_pred[pl][j], &(imgY[up.pos_y][up.pos_x]), MB_BLOCK_SIZE * sizeof(imgpel));
  468.     break;
  469.   case HOR_PRED_16:                        // horizontal prediction from left block
  470.     if (!left_avail)
  471.       error ("invalid 16x16 intra pred Mode HOR_PRED_16",500);
  472.     for(j = 0; j < MB_BLOCK_SIZE; j++)
  473.     {
  474.       prediction = imgY[left[j+1].pos_y][left[j+1].pos_x];
  475.       for(i=0;i<MB_BLOCK_SIZE;i++)
  476.         mpr[j][i]= prediction; // store predicted 16x16 block
  477.     }
  478.     break;
  479.   case DC_PRED_16:                         // DC prediction
  480.     s1=s2=0;
  481.     for (i = 0; i < MB_BLOCK_SIZE; i++)
  482.     {
  483.       if (up_avail)
  484.         s1 += imgY[up.pos_y][up.pos_x+i];    // sum hor pix
  485.       if (left_avail)
  486.         s2 += imgY[left[i + 1].pos_y][left[i + 1].pos_x];    // sum vert pix
  487.     }
  488.     if (up_avail && left_avail)
  489.       s0 = (s1 + s2 + 16)>>5;       // no edge
  490.     if (!up_avail && left_avail)
  491.       s0 = (s2 + 8)>>4;              // upper edge
  492.     if (up_avail && !left_avail)
  493.       s0 = (s1 + 8)>>4;              // left edge
  494.     if (!up_avail && !left_avail)
  495.       s0 = img->dc_pred_value_comp[pl];                            // top left corner, nothing to predict from
  497.     for(j = 0; j < MB_BLOCK_SIZE; j++)
  498.       for(i = 0; i < MB_BLOCK_SIZE; i++)
  499.       {
  500.         mpr[j][i]=(imgpel) s0;
  501.       }
  503.     break;
  504.   case PLANE_16:// 16 bit integer plan pred
  505.     if (!up_avail || !left_up_avail  || !left_avail)
  506.       error ("invalid 16x16 intra pred Mode PLANE_16",500);
  508.     ih=0;
  509.     iv=0;
  511.     mpr_line = &imgY[up.pos_y][up.pos_x+7];
  512.     for (i = 1; i < 8; i++)
  513.     {
  514.       ih += i*(mpr_line[i] - mpr_line[-i]);
  515.       iv += i*(imgY[left[8+i].pos_y][left[8+i].pos_x] - imgY[left[8-i].pos_y][left[8-i].pos_x]);
  516.     }
  518.     ih += 8*(mpr_line[8] - imgY[left[0].pos_y][left[0].pos_x]);
  519.     iv += 8*(imgY[left[16].pos_y][left[16].pos_x] - imgY[left[0].pos_y][left[0].pos_x]);
  521.     ib=(5*ih+32)>>6;
  522.     ic=(5*iv+32)>>6;
  524.     iaa=16*(mpr_line[8] + imgY[left[16].pos_y][left[16].pos_x]);
  525.     for (j=0;j< MB_BLOCK_SIZE;j++)
  526.     {
  527.       for (i=0;i< MB_BLOCK_SIZE;i++)
  528.       {
  529.         mpr[j][i]=(imgpel) iClip1(max_imgpel_value,((iaa+(i-7)*ib +(j-7)*ic + 16)>>5));
  530.       }
  531.     }// store plane prediction
  532.     break;
  534.   default:
  535.     {                                    // indication of fault in bitstream,exit
  536.       printf("illegal 16x16 intra prediction mode input: %dn",predmode);
  537.       return SEARCH_SYNC;
  538.     }
  539.   }
  541.   return DECODING_OK;
  542. }
  544. /*!
  545.  ************************************************************************
  546.  * brief
  547.  *    Chroma Intra prediction. Note that many operations can be moved
  548.  *    outside since they are repeated for both components for no reason.
  549.  ************************************************************************
  550.  */
  552. void intrapred_chroma(ImageParameters *img, Macroblock *currMB, int uv)
  553. {
  554.   int i,j, ii, jj;
  556.   imgpel **imgUV = dec_picture->imgUV[uv];
  557.   imgpel (*mpr)[16] = img->mb_pred[uv + 1];
  558.   int     max_imgpel_value = img->max_imgpel_value_comp[uv + 1];
  559.   
  560.   int ih, iv, ib, ic, iaa;
  562.   int        b8, b4;
  563.   int        yuv = dec_picture->chroma_format_idc - 1;
  564.   int        blk_x, blk_y;
  565.   int        pred;
  566.   static int block_pos[3][4][4]= //[yuv][b8][b4]
  567.   {
  568.     { {0, 1, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0},{0, 0, 0, 0}},
  569.     { {0, 1, 2, 3},{2, 3, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0}},
  570.     { {0, 1, 2, 3},{1, 1, 3, 3},{2, 3, 2, 3},{3, 3, 3, 3}}
  571.   };
  573.   PixelPos up;        //!< pixel position  p(0,-1)
  574.   PixelPos left[17];  //!< pixel positions p(-1, -1..16)
  576.   int up_avail, left_avail[2], left_up_avail;
  578.   int cr_MB_x = img->mb_cr_size_x;
  579.   int cr_MB_y = img->mb_cr_size_y;
  580.   int cr_MB_y2 = (cr_MB_y >> 1);
  581.   int cr_MB_x2 = (cr_MB_x >> 1);
  583.   for (i=0; i < cr_MB_y + 1 ; i++)
  584.   {
  585.     getNeighbour(currMB, -1, i-1, img->mb_size[IS_CHROMA], &left[i]);
  586.   }
  588.   getNeighbour(currMB, 0, -1, img->mb_size[IS_CHROMA], &up);
  590.   if (!active_pps->constrained_intra_pred_flag)
  591.   {
  592.     up_avail      = up.available;
  593.     left_avail[0] = left_avail[1] = left[1].available;
  594.     left_up_avail = left[0].available;
  595.   }
  596.   else
  597.   {
  598.     up_avail = up.available ? img->intra_block[up.mb_addr] : 0;
  599.     for (i=0, left_avail[0] = 1; i < cr_MB_y2;i++)
  600.       left_avail[0]  &= left[i + 1].available ? img->intra_block[left[i + 1].mb_addr]: 0;
  601.     for (i = cr_MB_y2, left_avail[1] = 1; i<cr_MB_y;i++)
  602.       left_avail[1]  &= left[i + 1].available ? img->intra_block[left[i + 1].mb_addr]: 0;
  603.     left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  604.   }
  606.   switch (currMB->c_ipred_mode)
  607.   {
  608.   case DC_PRED_8:
  609.     // DC prediction
  610.     // Note that unlike what is stated in many presentations and papers, this mode does not operate
  611.     // the same way as I_16x16 DC prediction.
  612.     for(b8 = 0; b8 < (img->num_uv_blocks) ;b8++)
  613.     {
  614.       for (b4 = 0; b4 < 4; b4++)
  615.       {
  616.         blk_y = subblk_offset_y[yuv][b8][b4];
  617.         blk_x = subblk_offset_x[yuv][b8][b4];
  619.         pred = img->dc_pred_value_comp[1];
  621.         //===== get prediction value =====
  622.         switch (block_pos[yuv][b8][b4])
  623.         {
  624.         case 0:  //===== TOP LEFT =====
  625.           intra_chroma_DC_all   (imgUV, up_avail, left_avail[0], up, left, blk_x, blk_y + 1, &pred);
  626.           break;
  627.         case 1: //===== TOP RIGHT =====
  628.           intra_chroma_DC_single(imgUV, up_avail, left_avail[0], up, left, blk_x, blk_y + 1, &pred, 1);
  629.           break;
  630.         case 2: //===== BOTTOM LEFT =====
  631.           intra_chroma_DC_single(imgUV, up_avail, left_avail[1], up, left, blk_x, blk_y + 1, &pred, 0);
  632.           break;
  633.         case 3: //===== BOTTOM RIGHT =====
  634.           intra_chroma_DC_all   (imgUV, up_avail, left_avail[1], up, left, blk_x, blk_y + 1, &pred);          
  635.           break;
  636.         }
  637.         
  638.         for (jj = blk_y; jj < blk_y + BLOCK_SIZE; jj++)
  639.           for (ii = blk_x; ii < blk_x + BLOCK_SIZE; ii++)
  640.           {
  641.             mpr[jj][ii]=(imgpel) pred;
  642.           }
  643.       }
  644.     }
  645.     break;
  646.   case HOR_PRED_8:
  647.     // Horizontal Prediction
  648.     if (!left_avail[0] || !left_avail[1])
  649.       error("unexpected HOR_PRED_8 chroma intra prediction mode",-1);
  651.     for (j = 0; j < cr_MB_y; j++)
  652.     {
  653.       pred = imgUV[left[1 + j].pos_y][left[1 + j].pos_x];
  654.       for (i = 0; i < cr_MB_x; i++)
  655.         mpr[j][i]=(imgpel) pred;
  656.     }
  658.     break;
  659.   case VERT_PRED_8:
  660.     // Vertical Prediction
  661.     if (!up_avail)
  662.       error("unexpected VERT_PRED_8 chroma intra prediction mode",-1);
  664.     for (j = 0; j < cr_MB_y; j++)
  665.     {
  666.       memcpy(&(mpr[j][0]), &(imgUV[up.pos_y][up.pos_x]), cr_MB_x * sizeof(imgpel));
  667.     }
  668.     break;
  669.   case PLANE_8:
  670.     // plane prediction
  671.     if (!left_up_avail || !left_avail[0] || !left_avail[1] || !up_avail)
  672.       error("unexpected PLANE_8 chroma intra prediction mode",-1);
  673.     else
  674.     {
  675.       imgpel *upPred = &imgUV[up.pos_y][up.pos_x];
  677.       ih = cr_MB_x2 * (upPred[cr_MB_x - 1] - imgUV[left[0].pos_y][left[0].pos_x]);
  678.       for (i = 0; i < cr_MB_x2 - 1; i++)
  679.         ih += (i + 1) * (upPred[cr_MB_x2 + i] - upPred[cr_MB_x2 - 2 - i]);
  681.       iv = cr_MB_y2 * (imgUV[left[cr_MB_y].pos_y][left[cr_MB_y].pos_x] - imgUV[left[0].pos_y][left[0].pos_x]);
  682.       for (i = 0; i < cr_MB_y2 - 1; i++)
  683.         iv += (i + 1)*(imgUV[left[cr_MB_y2 + 1 + i].pos_y][left[cr_MB_y2 + 1 + i].pos_x] -
  684.         imgUV[left[cr_MB_y2 - 1 - i].pos_y][left[cr_MB_y2 - 1 - i].pos_x]);
  686.       ib= ((cr_MB_x == 8 ? 17 : 5) * ih + 2 * cr_MB_x)>>(cr_MB_x == 8 ? 5 : 6);
  687.       ic= ((cr_MB_y == 8 ? 17 : 5) * iv + 2 * cr_MB_y)>>(cr_MB_y == 8 ? 5 : 6);
  689.       iaa=16*(imgUV[left[cr_MB_y].pos_y][left[cr_MB_y].pos_x] + upPred[cr_MB_x-1]);
  691.       for (j = 0; j < cr_MB_y; j++)
  692.         for (i = 0; i < cr_MB_x; i++)
  693.           mpr[j][i]=(imgpel) iClip1(max_imgpel_value, ((iaa + (i - cr_MB_x2 + 1) * ib + (j - cr_MB_y2 + 1) * ic + 16) >> 5));  }
  694.     break;
  695.   default:
  696.     error("illegal chroma intra prediction mode", 600);
  697.     break;
  698.   }
  699. }
  701. /*!
  702.  ***********************************************************************
  703.  * brief
  704.  *    Inverse 4x4 transformation, transforms cof to m7
  705.  ***********************************************************************
  706.  */
  707. void itrans4x4(ImageParameters *img, //!< image parameters
  708.                ColorPlane pl,              
  709.                int ioff,            //!< index to 4x4 block
  710.                int joff)            //!<
  711. {
  712.   static int i,j;
  714.   int max_imgpel_value = img->max_imgpel_value_comp[pl];
  716.   imgpel (*mpr)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  717.   int    (*m7) [MB_BLOCK_SIZE] = img->mb_rres[pl];
  719.   inverse4x4(img->cof[pl],m7,joff,ioff);
  721.   for (j = joff; j < joff + BLOCK_SIZE; j++)
  722.   {
  723.     for (i = ioff; i < ioff + BLOCK_SIZE; i++)
  724.     {      
  725.       m7[j][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS)), DQ_BITS));
  726.     }
  727.   }
  728. }
  730. /*!
  731.  ***********************************************************************
  732.  * brief
  733.  *    Inverse 4x4 lossless_qpprime transformation, transforms cof to m7
  734.  ***********************************************************************
  735.  */
  736. void itrans4x4_ls(ImageParameters *img, //!< image parameters
  737.                   ColorPlane pl,        //!< Color plane (for 4:4:4)                  
  738.                   int ioff,             //!< index to 4x4 block
  739.                   int joff)             //!<
  740. {
  741.   static int i,j;
  743.   int max_imgpel_value = img->max_imgpel_value_comp[pl];
  745.   imgpel (*mpr)[16] = img->mb_pred[pl];
  746.   int    ( *m7)[16] = img->mb_rres [pl];
  748.   inverse4x4(img->cof[pl],m7,joff,ioff);
  750.   for (j = joff; j < joff + BLOCK_SIZE; j++)
  751.   {
  752.     for (i = ioff; i < ioff + BLOCK_SIZE; i++)
  753.     {      
  754.       m7[j][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS)), DQ_BITS));
  755.     }
  756.   }
  757. }
  759. /*!
  760. ************************************************************************
  761. * brief
  762. *    Inverse residual DPCM for Intra lossless coding
  763. *
  764. * par Input:
  765. *    ioff_x,joff_y: Block position inside a macro block (0,4,8,12).
  766. ************************************************************************
  767. */  //For residual DPCM
  768. void Inv_Residual_trans_4x4(ImageParameters *img, //!< image parameters
  769.                             ColorPlane pl,                            
  770.                             int ioff,            //!< index to 4x4 block
  771.                             int joff)
  772. {
  773.   int i,j;
  774.   int temp[4][4];
  775.   imgpel (*mpr)[MB_BLOCK_SIZE] = img->mb_pred[pl];
  776.   int    (*m7) [MB_BLOCK_SIZE] = img->mb_rres[pl];
  777.   int    (*cof)[MB_BLOCK_SIZE] = img->cof[pl];
  779.   if(ipmode_DPCM==VERT_PRED)
  780.   {
  781.     for(i=0; i<4; i++)
  782.     {
  783.       temp[0][i] = cof[joff + 0][ioff + i];
  784.       temp[1][i] = cof[joff + 1][ioff + i] + temp[0][i];
  785.       temp[2][i] = cof[joff + 2][ioff + i] + temp[1][i];
  786.       temp[3][i] = cof[joff + 3][ioff + i] + temp[2][i];
  787.     }
  788.     for(i=0; i<4; i++)
  789.     {
  790.       m7[joff    ][ioff + i]=temp[0][i];
  791.       m7[joff + 1][ioff + i]=temp[1][i];
  792.       m7[joff + 2][ioff + i]=temp[2][i];
  793.       m7[joff + 3][ioff + i]=temp[3][i];
  794.     }
  795.   }
  796.   else if(ipmode_DPCM==HOR_PRED)
  797.   {
  798.     for(j=0; j<4; j++)
  799.     {
  800.       temp[j][0] = cof[joff + j][ioff    ];
  801.       temp[j][1] = cof[joff + j][ioff + 1] + temp[j][0];
  802.       temp[j][2] = cof[joff + j][ioff + 2] + temp[j][1];
  803.       temp[j][3] = cof[joff + j][ioff + 3] + temp[j][2];
  804.     }
  805.     for(j=0; j<4; j++)
  806.     {
  807.       m7[joff + j][ioff    ]=temp[j][0];
  808.       m7[joff + j][ioff + 1]=temp[j][1];
  809.       m7[joff + j][ioff + 2]=temp[j][2];
  810.       m7[joff + j][ioff + 3]=temp[j][3];
  811.     }
  812.   }
  813.   else
  814.   {
  815.     for (j = 0; j < BLOCK_SIZE; j++)
  816.       for (i = 0; i < BLOCK_SIZE; i++)
  817.         m7[joff+j][ioff+i] = cof[joff+j][ioff+i];
  818.   }
  819.   for (j = 0; j < BLOCK_SIZE; j++)
  820.     for (i = 0; i < BLOCK_SIZE; i++)
  821.       m7[joff+j][ioff+i] +=  (long)mpr[joff+j][ioff+i];
  823. }
  825. /*!
  826. ************************************************************************
  827. * brief
  828. *    Inverse residual DPCM for Intra lossless coding
  829. *
  830. * par Input:
  831. *    ioff_x,joff_y: Block position inside a macro block (0,8).
  832. ************************************************************************
  833. */
  834. //For residual DPCM
  835. void Inv_Residual_trans_8x8(ImageParameters *img, Macroblock *currMB, ColorPlane pl, int ioff,int joff)
  836. {
  837.   int i, j;
  838.   int temp[8][8];
  839.   imgpel (*mpr)[16] = img->mb_pred[pl];
  840.   int    (*m7) [16] = img->mb_rres[pl];
  841.   
  843.   if(ipmode_DPCM==VERT_PRED)
  844.     {
  845.       for(i=0; i<8; i++)
  846.       {
  847.         temp[0][i] = m7[joff + 0][ioff + i];
  848.         temp[1][i] = m7[joff + 1][ioff + i] + temp[0][i];
  849.         temp[2][i] = m7[joff + 2][ioff + i] + temp[1][i];
  850.         temp[3][i] = m7[joff + 3][ioff + i] + temp[2][i];
  851.         temp[4][i] = m7[joff + 4][ioff + i] + temp[3][i];
  852.         temp[5][i] = m7[joff + 5][ioff + i] + temp[4][i];
  853.         temp[6][i] = m7[joff + 6][ioff + i] + temp[5][i];
  854.         temp[7][i] = m7[joff + 7][ioff + i] + temp[6][i];
  855.       }
  856.       for(i=0; i<8; i++)
  857.       {
  858.         m7[joff  ][ioff+i]=temp[0][i];
  859.         m7[joff+1][ioff+i]=temp[1][i];
  860.         m7[joff+2][ioff+i]=temp[2][i];
  861.         m7[joff+3][ioff+i]=temp[3][i];
  862.         m7[joff+4][ioff+i]=temp[4][i];
  863.         m7[joff+5][ioff+i]=temp[5][i];
  864.         m7[joff+6][ioff+i]=temp[6][i];
  865.         m7[joff+7][ioff+i]=temp[7][i];
  866.       }
  867.     }
  868.     else if(ipmode_DPCM==HOR_PRED)//HOR_PRED
  869.     {
  870.       for(i=0; i<8; i++)
  871.       {
  872.         temp[i][0] = m7[joff + i][ioff + 0];
  873.         temp[i][1] = m7[joff + i][ioff + 1] + temp[i][0];
  874.         temp[i][2] = m7[joff + i][ioff + 2] + temp[i][1];
  875.         temp[i][3] = m7[joff + i][ioff + 3] + temp[i][2];
  876.         temp[i][4] = m7[joff + i][ioff + 4] + temp[i][3];
  877.         temp[i][5] = m7[joff + i][ioff + 5] + temp[i][4];
  878.         temp[i][6] = m7[joff + i][ioff + 6] + temp[i][5];
  879.         temp[i][7] = m7[joff + i][ioff + 7] + temp[i][6];
  880.       }
  881.       for(i=0; i<8; i++)
  882.       {
  883.         m7[joff+i][ioff+0]=temp[i][0];
  884.         m7[joff+i][ioff+1]=temp[i][1];
  885.         m7[joff+i][ioff+2]=temp[i][2];
  886.         m7[joff+i][ioff+3]=temp[i][3];
  887.         m7[joff+i][ioff+4]=temp[i][4];
  888.         m7[joff+i][ioff+5]=temp[i][5];
  889.         m7[joff+i][ioff+6]=temp[i][6];
  890.         m7[joff+i][ioff+7]=temp[i][7];
  891.       }
  892.     }
  893.     for (j = 0; j < BLOCK_SIZE*2; j++)
  894.       for (i = 0; i < BLOCK_SIZE*2; i++)
  895.         m7[j+joff][i+ioff] +=  (long)mpr[j+joff][i+ioff];
  896. }
  900. /*!
  901.  ***********************************************************************
  902.  * brief
  903.  *    Luma DC inverse transform
  904.  ***********************************************************************
  905.  */ 
  906. void itrans_2(ImageParameters *img, Macroblock *currMB, ColorPlane pl) //!< image parameters
  907. {
  908.   int i,j;
  910.   int (*cof)[16] = img->cof[pl];
  911.   int qp_scaled = currMB->qp_scaled[pl];
  913.   int qp_per = qp_per_matrix[ qp_scaled ];
  914.   int qp_rem = qp_rem_matrix[ qp_scaled ];    
  916.   int invLevelScale = InvLevelScale4x4_Intra[pl][qp_rem][0][0];
  918.   // horizontal
  919.   for (j=0; j < 4;j++) 
  920.   {
  921.     for (i=0; i < 4;i++) 
  922.     {
  923.       M4[j][i]=cof[j<<2][i<<2];
  924.     }
  925.   }
  927.   ihadamard4x4(M4, M4);
  929.   // vertical
  930.   for (j=0; j < 4;j++) 
  931.   {
  932.     for (i=0; i < 4;i++) 
  933.     {
  934.       cof[j<<2][i<<2] = rshift_rnd((( M4[j][i] * invLevelScale) << qp_per), 6);
  935.     }
  936.   }
  937. }
  940. void itrans_sp(ImageParameters *img,  //!< image parameters
  941.                ColorPlane pl, 
  942.                int ioff,             //!< index to 4x4 block
  943.                int joff)              //!<
  944. {
  945.   int i,j;  
  946.   int ilev, icof;
  948.   int qp = (img->type == SI_SLICE) ? img->qpsp : img->qp;
  949.   int qp_per = qp_per_matrix[ qp ];
  950.   int qp_rem = qp_rem_matrix[ qp ];
  952.   int qp_per_sp = qp_per_matrix[ img->qpsp ];
  953.   int qp_rem_sp = qp_rem_matrix[ img->qpsp ];
  954.   int q_bits_sp = Q_BITS + qp_per_sp;
  956.   imgpel (*mpr)[16] = img->mb_pred[pl];
  957.   int    (*m7) [16] = img->mb_rres[pl];
  958.   int    (*cof)[16] = img->cof[pl];
  959.   int max_imgpel_value = img->max_imgpel_value_comp[pl];
  960.   
  961.   //int (*InvLevelScale4x4)[4] = InvLevelScale4x4_Intra[0][qp_rem];
  962.   const int (*InvLevelScale4x4)  [4] = dequant_coef[qp_rem];
  963.   const int (*InvLevelScale4x4SP)[4] = dequant_coef[qp_rem_sp];
  966.   for (j=0; j< BLOCK_SIZE; j++)
  967.     for (i=0; i< BLOCK_SIZE; i++)
  968.       PBlock[j][i] = mpr[j+joff][i+ioff];
  970.   forward4x4(PBlock, PBlock, 0, 0);
  972.   if(img->sp_switch || img->type==SI_SLICE)
  973.   {    
  974.     for (j=0;j<BLOCK_SIZE;j++)
  975.     {
  976.       for (i=0;i<BLOCK_SIZE;i++)
  977.       {
  978.         // recovering coefficient since they are already dequantized earlier
  979.         icof = (cof[joff + j][ioff + i] >> qp_per) / InvLevelScale4x4[j][i];
  980.         //icof = ((cof[joff + j][ioff + i] * quant_coef[qp_rem][j][i])>> (qp_per + 15)) ;
  981.         // icof  = rshift_rnd_sf(cof[joff + j][ioff + i] * quant_coef[qp_rem][j][i], qp_per + 15);
  982.         ilev  = rshift_rnd_sf(iabs(PBlock[j][i]) * quant_coef[qp_rem_sp][j][i], q_bits_sp);
  983.         ilev  = isignab(ilev, PBlock[j][i]) + icof;
  984.         cof[joff + j][ioff + i] = ilev * InvLevelScale4x4SP[j][i] << qp_per_sp;
  985.       }
  986.     }
  987.   }
  988.   else
  989.   {
  990.     for (j=0;j<BLOCK_SIZE;j++)
  991.     {
  992.       for (i=0;i<BLOCK_SIZE;i++)
  993.       {
  994.         // recovering coefficient since they are already dequantized earlier
  995.         icof = (cof[joff + j][ioff + i] >> qp_per) / InvLevelScale4x4[j][i];
  996.         //icof = cof[joff + j][ioff + i];
  997.         //icof  = rshift_rnd_sf(cof[joff + j][ioff + i] * quant_coef[qp_rem][j][i], qp_per + 15);
  998.         ilev = PBlock[j][i] + ((icof * InvLevelScale4x4[j][i] * A[j][i] <<  qp_per) >> 6);
  999.         ilev  = isign(ilev) * rshift_rnd_sf(iabs(ilev) * quant_coef[qp_rem_sp][j][i], q_bits_sp);
  1000.         //cof[joff + j][ioff + i] = ilev * InvLevelScale4x4SP[j][i] << qp_per_sp;
  1001.         cof[joff + j][ioff + i] = ilev * dequant_coef[qp_rem_sp][j][i] << qp_per_sp;
  1002.       }
  1003.     }
  1004.   }
  1006.   inverse4x4(cof, m7, joff, ioff);
  1008.   for (j=0;j<BLOCK_SIZE;j++)
  1009.     for (i=0;i<BLOCK_SIZE;i++)
  1010.       m7[j + joff][i + ioff] = iClip1(max_imgpel_value,rshift_rnd_sf(m7[j + joff][i + ioff], DQ_BITS));
  1011. }
  1014. void itrans_sp_cr(ImageParameters *img, int uv)
  1015. {
  1016.   int i,j,ilev, icof, n2,n1;
  1017.   int mp1[BLOCK_SIZE];
  1018.   int qp_per,qp_rem;
  1019.   int qp_per_sp,qp_rem_sp,q_bits_sp;
  1020.   imgpel (*mpr)[MB_BLOCK_SIZE] = img->mb_pred[uv + 1];
  1021.   int    (*cof)[MB_BLOCK_SIZE] = img->cof[uv + 1];
  1023.   qp_per    = qp_per_matrix[ ((img->qp < 0 ? img->qp : QP_SCALE_CR[img->qp]))];
  1024.   qp_rem    = qp_rem_matrix[ ((img->qp < 0 ? img->qp : QP_SCALE_CR[img->qp]))];
  1026.   qp_per_sp = qp_per_matrix[ ((img->qpsp < 0 ? img->qpsp : QP_SCALE_CR[img->qpsp]))];
  1027.   qp_rem_sp = qp_rem_matrix[ ((img->qpsp < 0 ? img->qpsp : QP_SCALE_CR[img->qpsp]))];
  1028.   q_bits_sp = Q_BITS + qp_per_sp;  
  1030.   if (img->type == SI_SLICE)
  1031.   {
  1032.     qp_per = qp_per_sp;
  1033.     qp_rem = qp_rem_sp;
  1034.   }
  1036.   for (j=0; j < img->mb_cr_size_y; j++)
  1037.   {
  1038.     for (i=0; i < img->mb_cr_size_x; i++)
  1039.     {
  1040.       PBlock[j][i] = mpr[j][i];
  1041.       mpr[j][i] = 0;
  1042.     }
  1043.   }
  1045.   for (n2=0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1046.   {
  1047.     for (n1=0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1048.     {
  1049.       forward4x4(PBlock, PBlock, n2, n1);
  1050.     }
  1051.   }
  1053.   //     2X2 transform of DC coeffs.
  1054.   mp1[0] = (PBlock[0][0] + PBlock[4][0] + PBlock[0][4] + PBlock[4][4]);
  1055.   mp1[1] = (PBlock[0][0] - PBlock[4][0] + PBlock[0][4] - PBlock[4][4]);
  1056.   mp1[2] = (PBlock[0][0] + PBlock[4][0] - PBlock[0][4] - PBlock[4][4]);
  1057.   mp1[3] = (PBlock[0][0] - PBlock[4][0] - PBlock[0][4] + PBlock[4][4]);
  1059.   if (img->sp_switch || img->type==SI_SLICE)  
  1060.   {        
  1061.     for (n2=0; n2 < 2; n2 ++)
  1062.     {
  1063.       for (n1=0; n1 < 2; n1 ++)
  1064.       {
  1065.         //quantization fo predicted block
  1066.         ilev = rshift_rnd_sf(iabs (mp1[n1+n2*2]) * quant_coef[qp_rem_sp][0][0], q_bits_sp + 1);
  1067.         //addition
  1068.         ilev = isignab(ilev, mp1[n1+n2*2]) + cof[n2<<2][n1<<2];
  1069.         //dequantization
  1070.         mp1[n1+n2*2] =ilev * dequant_coef[qp_rem_sp][0][0] << qp_per_sp;
  1071.       }
  1072.     }
  1074.     for (n2 = 0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1075.     {
  1076.       for (n1 = 0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1077.       {
  1078.         for (j = 0; j < BLOCK_SIZE; j++)
  1079.         {
  1080.           for (i = 0; i < BLOCK_SIZE; i++)
  1081.           {
  1082.             // recovering coefficient since they are already dequantized earlier
  1083.             cof[n2 + j][n1 + i] = (cof[n2 + j][n1 + i] >> qp_per) / dequant_coef[qp_rem][j][i];
  1085.             //quantization of the predicted block
  1086.             ilev = rshift_rnd_sf(iabs(PBlock[n2 + j][n1 + i]) * quant_coef[qp_rem_sp][j][i], q_bits_sp);
  1087.             //addition of the residual
  1088.             ilev = isignab(ilev,PBlock[n2 + j][n1 + i]) + cof[n2 + j][n1 + i];
  1089.             // Inverse quantization
  1090.             cof[n2 + j][n1 + i] = ilev * dequant_coef[qp_rem_sp][j][i] << qp_per_sp;
  1091.           }
  1092.         }
  1093.       }
  1094.     }
  1095.   }
  1096.   else
  1097.   {
  1098.     for (n2=0; n2 < 2; n2 ++)
  1099.     {
  1100.       for (n1=0; n1 < 2; n1 ++)
  1101.       {
  1102.         ilev = mp1[n1+n2*2] + (((cof[n2<<2][n1<<2] * dequant_coef[qp_rem][0][0] * A[0][0]) << qp_per) >> 5);
  1103.         ilev = isign(ilev) * rshift_rnd_sf(iabs(ilev) * quant_coef[qp_rem_sp][0][0], q_bits_sp + 1);
  1104.         //ilev = isignab(rshift_rnd_sf(iabs(ilev)* quant_coef[qp_rem_sp][0][0], q_bits_sp + 1), ilev);
  1105.         mp1[n1+n2*2] = ilev * dequant_coef[qp_rem_sp][0][0] << qp_per_sp;
  1106.       }
  1107.     }
  1109.     for (n2 = 0; n2 < img->mb_cr_size_y; n2 += BLOCK_SIZE)
  1110.     {
  1111.       for (n1 = 0; n1 < img->mb_cr_size_x; n1 += BLOCK_SIZE)
  1112.       {
  1113.         for (j = 0; j< BLOCK_SIZE; j++)
  1114.         {
  1115.           for (i = 0; i< BLOCK_SIZE; i++)
  1116.           {
  1117.             // recovering coefficient since they are already dequantized earlier
  1118.             //icof = ((((cof[n2 + j][n1 + i] << 4) + qp_per/2)>> qp_per) + dequant_coef[qp_rem][j][i]/2) / dequant_coef[qp_rem][j][i];
  1119.             icof = (cof[n2 + j][n1 + i] >> qp_per) / dequant_coef[qp_rem][j][i];
  1120.             //dequantization and addition of the predicted block      
  1121.             ilev = PBlock[n2 + j][n1 + i] + ((icof * dequant_coef[qp_rem][j][i] * A[j][i] << qp_per) >> 6);
  1122.             //quantization and dequantization
  1123.             ilev = isign(ilev) * rshift_rnd_sf(iabs(ilev) * quant_coef[qp_rem_sp][j][i], q_bits_sp);
  1124.             cof[n2 + j][n1 + i] = ilev * dequant_coef[qp_rem_sp][j][i] << qp_per_sp;
  1125.             //printf( " %d %d %dn", j, i, quant_coef[qp_rem_sp][j][i]);
  1126.           }
  1127.         }
  1128.       }
  1129.     }
  1130.   }
  1132.   cof[0][0] = (mp1[0] + mp1[1] + mp1[2] + mp1[3]) >> 1;
  1133.   cof[0][4] = (mp1[0] + mp1[1] - mp1[2] - mp1[3]) >> 1;
  1134.   cof[4][0] = (mp1[0] - mp1[1] + mp1[2] - mp1[3]) >> 1;
  1135.   cof[4][4] = (mp1[0] - mp1[1] - mp1[2] + mp1[3]) >> 1;
  1136. }
  1138. static const byte decode_block_scan[16] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15};
  1140. void iMBtrans4x4(ColorPlane pl, ImageParameters *img, int smb)
  1141. {
  1142.   int i_pos;
  1143.   int jj, ii;
  1144.   int block8x8;
  1145.   int i, j, k;  
  1146.   int    (*m7) [16] = img->mb_rres[pl];
  1147.   imgpel **curr_img = pl ? &(dec_picture->imgUV[pl - 1][img->pix_y]): &dec_picture->imgY[img->pix_y];
  1149.   //For residual DPCM
  1150.   Boolean lossless_qpprime = (Boolean) (((img->qp + img->bitdepth_luma_qp_scale) == 0) && (img->lossless_qpprime_flag == 1));  
  1152.   // =============== 4x4 itrans ================
  1153.   // -------------------------------------------
  1155.   itrans_4x4 = (smb) ? itrans_sp : ((!lossless_qpprime) ? itrans4x4 : Inv_Residual_trans_4x4);
  1157.   i_pos = img->pix_x;
  1159.   for (block8x8=0; block8x8 < MB_BLOCK_SIZE; block8x8 += 4)
  1160.   { 
  1161.     for (k = block8x8; k < block8x8 + 4; k ++)
  1162.     {
  1163.       jj = ((decode_block_scan[k] >> 2) & 3) << BLOCK_SHIFT;
  1164.       ii = (decode_block_scan[k] & 3) << BLOCK_SHIFT;
  1166.       itrans_4x4(img, pl, ii, jj);   // use DCT transform and make 4x4 block m7 from prediction block mpr
  1167.       
  1168.       for(j = jj; j < jj + BLOCK_SIZE; j++)
  1169.       {
  1170.         for(i = ii; i < ii + BLOCK_SIZE; i++)
  1171.         {
  1172.           curr_img[j][i_pos + i] = (imgpel) m7[j][i]; // construct picture from 4x4 blocks
  1173.         }
  1174.       }
  1175.     }
  1176.   }
  1177. }
  1179. void iMBtrans8x8(ImageParameters *img,  Macroblock *currMB, ColorPlane pl)
  1180. {
  1181.   imgpel **curr_img = pl ? &dec_picture->imgUV[pl - 1][img->pix_y]: &dec_picture->imgY[img->pix_y];
  1182.   int    (*m7)[MB_BLOCK_SIZE] = img->mb_rres[pl];
  1183.   int block8x8;
  1184.   int i,j;
  1185.   int ioff, joff;
  1187.   for (block8x8=0; block8x8<4; block8x8++)
  1188.   {
  1189.     // =============== 8x8 itrans ================
  1190.     // -------------------------------------------
  1191.     ioff = 8 * (block8x8 & 0x01);
  1192.     joff = 8 * (block8x8 >> 1);
  1194.     itrans8x8(img, currMB, pl, ioff, joff);      // use DCT transform and make 8x8 block m7 from prediction block mpr
  1196.     for(j = joff; j < joff + 8; j++)
  1197.     {
  1198.       for(i = ioff; i < ioff + 8; i++)
  1199.       {
  1200.         curr_img[j][img->pix_x + i] = (imgpel) m7[j][i];
  1201.       }
  1202.     }
  1203.   }
  1204. }
  1206. void iTransform(ImageParameters *img,  Macroblock *currMB, ColorPlane pl, int need_4x4_transform, int smb)
  1207. {
  1208.   static imgpel (*mpr) [16];
  1209.   static imgpel **curr_img;
  1210.   int j, uv = pl-1; 
  1212.   if ((currMB->cbp & 15) != 0 || smb)
  1213.   {
  1214.     if(need_4x4_transform) // 4x4 inverse transform
  1215.     {
  1216.       iMBtrans4x4(pl, img, smb); 
  1217.     }
  1218.     else // 8x8 inverse transform
  1219.     {  
  1220.       iMBtrans8x8(img, currMB, pl);    
  1221.     }
  1222.   }
  1223.   else
  1224.   {
  1225.     mpr = img->mb_pred[pl]; 
  1226.     curr_img = pl ? &dec_picture->imgUV[uv][img->pix_y] : &dec_picture->imgY[img->pix_y];
  1227.     for(j = 0; j < MB_BLOCK_SIZE; j++)
  1228.     { 
  1229.       memcpy(&(curr_img[j][img->pix_x]), &(img->mb_pred[pl][j][0]), MB_BLOCK_SIZE * sizeof(imgpel));
  1230.     }
  1231.   }
  1233.   if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444)) 
  1234.   {
  1235.     static imgpel **curUV, *cur_line;
  1236.     static int b4, b8;
  1237.     static int ioff, joff, ii, jj;
  1238.     static int (*m7UV)[16], *m7;
  1240.     for(uv=0;uv<2;uv++)
  1241.     {
  1242.       Boolean lossless_qpprime = (Boolean) ((img->lossless_qpprime_flag == 1) &&((img->qp + dec_picture->chroma_qp_offset[uv] + img->bitdepth_chroma_qp_scale) == 0));  
  1243.       itrans_4x4 = (!lossless_qpprime) ? itrans4x4 : itrans4x4_ls;
  1245.       // =============== 4x4 itrans ================
  1246.       // -------------------------------------------
  1247.       curUV = &dec_picture->imgUV[uv][img->pix_c_y]; 
  1248.       m7UV  = img->mb_rres[uv+1];
  1250.       if (!smb && (currMB->cbp>>4))
  1251.       {
  1252.         for (b8 = 0; b8 < (img->num_uv_blocks); b8++)
  1253.         {
  1254.           for(b4 = 0; b4 < 4; b4++)
  1255.           {
  1256.             joff = subblk_offset_y[1][b8][b4];
  1257.             ioff = subblk_offset_x[1][b8][b4];
  1259.             itrans_4x4(img, (ColorPlane) (uv + 1), ioff, joff);
  1261.             for(jj=joff;jj<joff + 4;jj++)
  1262.             {
  1263.               cur_line = &curUV[jj][img->pix_c_x + ioff];
  1264.               m7 = &m7UV[jj][ioff];
  1265.               for(ii=0;ii<4;ii++)
  1266.               {
  1267.                 *(cur_line++) = (imgpel) *(m7++);
  1268.               }
  1269.             }
  1270.           }
  1271.         }
  1272.       }
  1273.       else if (smb)
  1274.       {
  1275.         itrans_sp_cr(img, uv);
  1277.         for (joff = 0; joff < img->mb_cr_size_y; joff += BLOCK_SIZE)
  1278.         {
  1279.           for(ioff = 0; ioff < img->mb_cr_size_x ;ioff += BLOCK_SIZE)
  1280.           {
  1281.             itrans_4x4(img, (ColorPlane) (uv + 1), ioff, joff);
  1283.             for(jj=joff;jj<joff + 4;jj++)
  1284.               for(ii=ioff;ii<ioff + 4;ii++)
  1285.               {
  1286.                 curUV[jj][img->pix_c_x+ii]= (imgpel) m7UV[jj][ii];
  1287.               }
  1288.           }
  1289.         }
  1290.       }
  1291.       else 
  1292.       {
  1293.         mpr = img->mb_pred[uv + 1];
  1294.         for(jj = 0; jj < img->mb_size[1][1]; jj++)
  1295.           memcpy(&(curUV[jj][img->pix_c_x]), &(mpr[jj][0]), img->mb_size[1][0] * sizeof(imgpel));
  1296.       }
  1297.     }
  1298.   }
  1299. }