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

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

Audio

开发平台：

Visual C++

transform8x8.c：源码内容
  2. /*!
  3.  ***************************************************************************
  4.  * file transform8x8.c
  5.  *
  6.  * brief
  7.  *    8x8 transform functions
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Yuri Vatis
  12.  *    - Jan Muenster
  13.  *
  14.  * date
  15.  *    12. October 2003
  16.  **************************************************************************
  17.  */
  19. #include "global.h"
  21. #include "image.h"
  22. #include "mb_access.h"
  23. #include "elements.h"
  24. #include "transform8x8.h"
  25. #include "transform.h"
  26. #include "quant.h"
  30. // function declarations
  31. void   LowPassForIntra8x8Pred(imgpel *PredPel, int block_up_left, int block_up, int block_left);
  34. // Notation for comments regarding prediction and predictors.
  35. // The pels of the 4x4 block are labeled a..p. The predictor pels above
  36. // are labeled A..H, from the left I..P, and from above left X, as follows:
  37. //
  38. //  Z  A  B  C  D  E  F  G  H  I  J  K  L  M   N  O  P
  39. //  Q  a1 b1 c1 d1 e1 f1 g1 h1
  40. //  R  a2 b2 c2 d2 e2 f2 g2 h2
  41. //  S  a3 b3 c3 d3 e3 f3 g3 h3
  42. //  T  a4 b4 c4 d4 e4 f4 g4 h4
  43. //  U  a5 b5 c5 d5 e5 f5 g5 h5
  44. //  V  a6 b6 c6 d6 e6 f6 g6 h6
  45. //  W  a7 b7 c7 d7 e7 f7 g7 h7
  46. //  X  a8 b8 c8 d8 e8 f8 g8 h8
  49. // Predictor array index definitions
  50. #define P_Z (PredPel[0])
  51. #define P_A (PredPel[1])
  52. #define P_B (PredPel[2])
  53. #define P_C (PredPel[3])
  54. #define P_D (PredPel[4])
  55. #define P_E (PredPel[5])
  56. #define P_F (PredPel[6])
  57. #define P_G (PredPel[7])
  58. #define P_H (PredPel[8])
  59. #define P_I (PredPel[9])
  60. #define P_J (PredPel[10])
  61. #define P_K (PredPel[11])
  62. #define P_L (PredPel[12])
  63. #define P_M (PredPel[13])
  64. #define P_N (PredPel[14])
  65. #define P_O (PredPel[15])
  66. #define P_P (PredPel[16])
  67. #define P_Q (PredPel[17])
  68. #define P_R (PredPel[18])
  69. #define P_S (PredPel[19])
  70. #define P_T (PredPel[20])
  71. #define P_U (PredPel[21])
  72. #define P_V (PredPel[22])
  73. #define P_W (PredPel[23])
  74. #define P_X (PredPel[24])
  76. /*!
  77.  ************************************************************************
  78.  * brief
  79.  *    Make intra 8x8 prediction according to all 9 prediction modes.
  80.  *    The routine uses left and upper neighbouring points from
  81.  *    previous coded blocks to do this (if available). Notice that
  82.  *    inaccessible neighbouring points are signalled with a negative
  83.  *    value in the predmode array .
  84.  *
  85.  *  par Input:
  86.  *     Starting point of current 8x8 block image position
  87.  *
  88.  ************************************************************************
  89.  */
  90. int intrapred8x8(ImageParameters *img,  //!< image parameters
  91.                  Macroblock *currMB,   //!< Current Macroblock 
  92.                  ColorPlane pl,        //!< Current Colorplane                 
  93.                  int b8)
  95. {
  96.   int i,j;
  97.   int s0;
  98.   imgpel PredPel[25];  // array of predictor pels
  99.   int uv = pl-1;
  100.   imgpel **imgY = (pl) ? dec_picture->imgUV[uv] : dec_picture->imgY; // For MB level frame/field coding tools -- set default to imgY
  102.   PixelPos pix_a[8];
  103.   PixelPos pix_b, pix_c, pix_d;
  105.   int block_available_up;
  106.   int block_available_left;
  107.   int block_available_up_left;
  108.   int block_available_up_right;
  109.   int img_block_x = (img->mb_x << 2) + ((b8 & 0x01) << 1);
  110.   int img_block_y = (img->mb_y << 2) + ((b8  >>  1) << 1);
  111.   int ioff = (b8 & 0x01) << 3;
  112.   int joff = (b8 >> 1  ) << 3;
  113.   int jpos0 = joff    , jpos1 = joff + 1, jpos2 = joff + 2, jpos3 = joff + 3;
  114.   int jpos4 = joff + 4, jpos5 = joff + 5, jpos6 = joff + 6, jpos7 = joff + 7;
  115.   int ipos0 = ioff    , ipos1 = ioff + 1, ipos2 = ioff + 2, ipos3 = ioff + 3;
  116.   int ipos4 = ioff + 4, ipos5 = ioff + 5, ipos6 = ioff + 6, ipos7 = ioff + 7;
  117.   int jpos, ipos;
  118.   imgpel *pred_pels, (*mpr)[16] = img->mb_pred[pl];
  119.   int *mb_size = img->mb_size[IS_LUMA];
  121.   byte predmode = img->ipredmode[img_block_y][img_block_x];
  122.   ipmode_DPCM = predmode;  //For residual DPCM
  124.   for (i=0;i<8;i++)
  125.   {
  126.     getNeighbour(currMB, ioff - 1, joff + i, mb_size, &pix_a[i]);
  127.   }
  129.   getNeighbour(currMB, ioff    , joff - 1, mb_size, &pix_b);
  130.   getNeighbour(currMB, ioff + 8, joff - 1, mb_size, &pix_c);
  131.   getNeighbour(currMB, ioff - 1, joff - 1, mb_size, &pix_d);
  133.   pix_c.available = pix_c.available &&!(ioff == 8 && joff == 8);
  135.   if (active_pps->constrained_intra_pred_flag)
  136.   {
  137.     for (i=0, block_available_left=1; i<8;i++)
  138.       block_available_left  &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
  139.     block_available_up       = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
  140.     block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
  141.     block_available_up_left  = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
  142.   }
  143.   else
  144.   {
  145.     block_available_left     = pix_a[0].available;
  146.     block_available_up       = pix_b.available;
  147.     block_available_up_right = pix_c.available;
  148.     block_available_up_left  = pix_d.available;
  149.   }
  151.   // form predictor pels
  152.   if (block_available_up)
  153.   {
  154.     pred_pels = &imgY[pix_b.pos_y][pix_b.pos_x];
  155.     P_A = pred_pels[0];
  156.     P_B = pred_pels[1];
  157.     P_C = pred_pels[2];
  158.     P_D = pred_pels[3];
  159.     P_E = pred_pels[4];
  160.     P_F = pred_pels[5];
  161.     P_G = pred_pels[6];
  162.     P_H = pred_pels[7];
  163.   }
  164.   else
  165.   {
  166.     P_A = P_B = P_C = P_D = P_E = P_F = P_G = P_H = (imgpel) img->dc_pred_value_comp[pl];
  167.   }
  169.   if (block_available_up_right)
  170.   {
  171.     pred_pels = &imgY[pix_c.pos_y][pix_c.pos_x];
  172.     P_I = pred_pels[0];
  173.     P_J = pred_pels[1];
  174.     P_K = pred_pels[2];
  175.     P_L = pred_pels[3];
  176.     P_M = pred_pels[4];
  177.     P_N = pred_pels[5];
  178.     P_O = pred_pels[6];
  179.     P_P = pred_pels[7];
  181.   }
  182.   else
  183.   {
  184.     P_I = P_J = P_K = P_L = P_M = P_N = P_O = P_P = P_H;
  185.   }
  187.   if (block_available_left)
  188.   {
  189.     P_Q = imgY[pix_a[0].pos_y][pix_a[0].pos_x];
  190.     P_R = imgY[pix_a[1].pos_y][pix_a[1].pos_x];
  191.     P_S = imgY[pix_a[2].pos_y][pix_a[2].pos_x];
  192.     P_T = imgY[pix_a[3].pos_y][pix_a[3].pos_x];
  193.     P_U = imgY[pix_a[4].pos_y][pix_a[4].pos_x];
  194.     P_V = imgY[pix_a[5].pos_y][pix_a[5].pos_x];
  195.     P_W = imgY[pix_a[6].pos_y][pix_a[6].pos_x];
  196.     P_X = imgY[pix_a[7].pos_y][pix_a[7].pos_x];
  197.   }
  198.   else
  199.   {
  200.     P_Q = P_R = P_S = P_T = P_U = P_V = P_W = P_X = (imgpel) img->dc_pred_value_comp[pl];
  201.   }
  203.   if (block_available_up_left)
  204.   {
  205.     P_Z = imgY[pix_d.pos_y][pix_d.pos_x];
  206.   }
  207.   else
  208.   {
  209.     P_Z = (imgpel) img->dc_pred_value_comp[pl];
  210.   }
  212.   LowPassForIntra8x8Pred(&(P_Z), block_available_up_left, block_available_up, block_available_left);
  214.   switch(predmode)
  215.   {
  216.   case DC_PRED:
  217.     s0 = 0;
  218.     if (block_available_up && block_available_left)
  219.     {
  220.       // no edge
  221.       s0 = (P_A + P_B + P_C + P_D + P_E + P_F + P_G + P_H + P_Q + P_R + P_S + P_T + P_U + P_V + P_W + P_X + 8) >> 4;
  222.     }
  223.     else if (!block_available_up && block_available_left)
  224.     {
  225.       // upper edge
  226.       s0 = (P_Q + P_R + P_S + P_T + P_U + P_V + P_W + P_X + 4) >> 3;
  227.     }
  228.     else if (block_available_up && !block_available_left)
  229.     {
  230.       // left edge
  231.       s0 = (P_A + P_B + P_C + P_D + P_E + P_F + P_G + P_H + 4) >> 3;
  232.     }
  233.     else //if (!block_available_up && !block_available_left)
  234.     {
  235.       // top left corner, nothing to predict from
  236.       s0 = img->dc_pred_value_comp[pl];
  237.     }
  238.     for(j = joff; j < joff + BLOCK_SIZE_8x8; j++)
  239.       for(i = ioff; i < ioff + BLOCK_SIZE_8x8; i++)
  240.         mpr[j][i] = (imgpel) s0;
  241.     break;
  242.   case VERT_PRED:
  243.     if (!block_available_up)
  244.       printf ("warning: Intra_8x8_Vertical prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  246.     for (i=0; i < BLOCK_SIZE_8x8; i++)
  247.     {
  248.       ipos = i+ioff;
  249.       mpr[jpos0][ipos] =
  250.       mpr[jpos1][ipos] =
  251.       mpr[jpos2][ipos] =
  252.       mpr[jpos3][ipos] =
  253.       mpr[jpos4][ipos] =
  254.       mpr[jpos5][ipos] =
  255.       mpr[jpos6][ipos] =
  256.       mpr[jpos7][ipos] = (imgpel) (&P_A)[i];
  257.     }
  258.     break;
  259.   case HOR_PRED:
  260.     if (!block_available_left)
  261.       printf ("warning: Intra_8x8_Horizontal prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  263.     for (j=0; j < BLOCK_SIZE_8x8; j++)
  264.     {
  265.       jpos = j + joff;
  266.       mpr[jpos][ipos0]  =
  267.       mpr[jpos][ipos1]  =
  268.       mpr[jpos][ipos2]  =
  269.       mpr[jpos][ipos3]  =
  270.       mpr[jpos][ipos4]  =
  271.       mpr[jpos][ipos5]  =
  272.       mpr[jpos][ipos6]  =
  273.       mpr[jpos][ipos7]  = (imgpel) (&P_Q)[j];
  274.     }
  275.     break;
  277.   case DIAG_DOWN_LEFT_PRED:
  278.     if (!block_available_up)
  279.       printf ("warning: Intra_8x8_Diagonal_Down_Left prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  280.     // Mode DIAG_DOWN_LEFT_PRED
  281.     mpr[jpos0][ipos0] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
  282.     mpr[jpos1][ipos0] =
  283.     mpr[jpos0][ipos1] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
  284.     mpr[jpos2][ipos0] =
  285.     mpr[jpos1][ipos1] =
  286.     mpr[jpos0][ipos2] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
  287.     mpr[jpos3][ipos0] =
  288.     mpr[jpos2][ipos1] =
  289.     mpr[jpos1][ipos2] =
  290.     mpr[jpos0][ipos3] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
  291.     mpr[jpos4][ipos0] =
  292.     mpr[jpos3][ipos1] =
  293.     mpr[jpos2][ipos2] =
  294.     mpr[jpos1][ipos3] =
  295.     mpr[jpos0][ipos4] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
  296.     mpr[jpos5][ipos0] =
  297.     mpr[jpos4][ipos1] =
  298.     mpr[jpos3][ipos2] =
  299.     mpr[jpos2][ipos3] =
  300.     mpr[jpos1][ipos4] =
  301.     mpr[jpos0][ipos5] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
  302.     mpr[jpos6][ipos0] =
  303.     mpr[jpos5][ipos1] =
  304.     mpr[jpos4][ipos2] =
  305.     mpr[jpos3][ipos3] =
  306.     mpr[jpos2][ipos4] =
  307.     mpr[jpos1][ipos5] =
  308.     mpr[jpos0][ipos6] = (imgpel) ((P_G + P_I + 2*(P_H) + 2) >> 2);
  309.     mpr[jpos7][ipos0] =
  310.     mpr[jpos6][ipos1] =
  311.     mpr[jpos5][ipos2] =
  312.     mpr[jpos4][ipos3] =
  313.     mpr[jpos3][ipos4] =
  314.     mpr[jpos2][ipos5] =
  315.     mpr[jpos1][ipos6] =
  316.     mpr[jpos0][ipos7] = (imgpel) ((P_H + P_J + 2*(P_I) + 2) >> 2);
  317.     mpr[jpos7][ipos1] =
  318.     mpr[jpos6][ipos2] =
  319.     mpr[jpos5][ipos3] =
  320.     mpr[jpos4][ipos4] =
  321.     mpr[jpos3][ipos5] =
  322.     mpr[jpos2][ipos6] =
  323.     mpr[jpos1][ipos7] = (imgpel) ((P_I + P_K + 2*(P_J) + 2) >> 2);
  324.     mpr[jpos7][ipos2] =
  325.     mpr[jpos6][ipos3] =
  326.     mpr[jpos5][ipos4] =
  327.     mpr[jpos4][ipos5] =
  328.     mpr[jpos3][ipos6] =
  329.     mpr[jpos2][ipos7] = (imgpel) ((P_J + P_L + 2*(P_K) + 2) >> 2);
  330.     mpr[jpos7][ipos3] =
  331.     mpr[jpos6][ipos4] =
  332.     mpr[jpos5][ipos5] =
  333.     mpr[jpos4][ipos6] =
  334.     mpr[jpos3][ipos7] = (imgpel) ((P_K + P_M + 2*(P_L) + 2) >> 2);
  335.     mpr[jpos7][ipos4] =
  336.     mpr[jpos6][ipos5] =
  337.     mpr[jpos5][ipos6] =
  338.     mpr[jpos4][ipos7] = (imgpel) ((P_L + P_N + 2*(P_M) + 2) >> 2);
  339.     mpr[jpos7][ipos5] =
  340.     mpr[jpos6][ipos6] =
  341.     mpr[jpos5][ipos7] = (imgpel) ((P_M + P_O + 2*(P_N) + 2) >> 2);
  342.     mpr[jpos7][ipos6] =
  343.     mpr[jpos6][ipos7] = (imgpel) ((P_N + P_P + 2*(P_O) + 2) >> 2);
  344.     mpr[jpos7][ipos7] = (imgpel) ((P_O + 3*(P_P) + 2) >> 2);
  345.     break;
  347.   case VERT_LEFT_PRED:
  348.     if (!block_available_up)
  349.       printf ("warning: Intra_4x4_Vertical_Left prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  351.     mpr[jpos0][ipos0] = (imgpel) ((P_A + P_B + 1) >> 1);
  352.     mpr[jpos0][ipos1] =
  353.     mpr[jpos2][ipos0] = (imgpel) ((P_B + P_C + 1) >> 1);
  354.     mpr[jpos0][ipos2] =
  355.     mpr[jpos2][ipos1] =
  356.     mpr[jpos4][ipos0] = (imgpel) ((P_C + P_D + 1) >> 1);
  357.     mpr[jpos0][ipos3] =
  358.     mpr[jpos2][ipos2] =
  359.     mpr[jpos4][ipos1] =
  360.     mpr[jpos6][ipos0] = (imgpel) ((P_D + P_E + 1) >> 1);
  361.     mpr[jpos0][ipos4] =
  362.     mpr[jpos2][ipos3] =
  363.     mpr[jpos4][ipos2] =
  364.     mpr[jpos6][ipos1] = (imgpel) ((P_E + P_F + 1) >> 1);
  365.     mpr[jpos0][ipos5] =
  366.     mpr[jpos2][ipos4] =
  367.     mpr[jpos4][ipos3] =
  368.     mpr[jpos6][ipos2] = (imgpel) ((P_F + P_G + 1) >> 1);
  369.     mpr[jpos0][ipos6] =
  370.     mpr[jpos2][ipos5] =
  371.     mpr[jpos4][ipos4] =
  372.     mpr[jpos6][ipos3] = (imgpel) ((P_G + P_H + 1) >> 1);
  373.     mpr[jpos0][ipos7] =
  374.     mpr[jpos2][ipos6] =
  375.     mpr[jpos4][ipos5] =
  376.     mpr[jpos6][ipos4] = (imgpel) ((P_H + P_I + 1) >> 1);
  377.     mpr[jpos2][ipos7] =
  378.     mpr[jpos4][ipos6] =
  379.     mpr[jpos6][ipos5] = (imgpel) ((P_I + P_J + 1) >> 1);
  380.     mpr[jpos4][ipos7] =
  381.     mpr[jpos6][ipos6] = (imgpel) ((P_J + P_K + 1) >> 1);
  382.     mpr[jpos6][ipos7] = (imgpel) ((P_K + P_L + 1) >> 1);
  383.     mpr[jpos1][ipos0] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
  384.     mpr[jpos1][ipos1] =
  385.     mpr[jpos3][ipos0] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
  386.     mpr[jpos1][ipos2] =
  387.     mpr[jpos3][ipos1] =
  388.     mpr[jpos5][ipos0] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
  389.     mpr[jpos1][ipos3] =
  390.     mpr[jpos3][ipos2] =
  391.     mpr[jpos5][ipos1] =
  392.     mpr[jpos7][ipos0] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
  393.     mpr[jpos1][ipos4] =
  394.     mpr[jpos3][ipos3] =
  395.     mpr[jpos5][ipos2] =
  396.     mpr[jpos7][ipos1] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
  397.     mpr[jpos1][ipos5] =
  398.     mpr[jpos3][ipos4] =
  399.     mpr[jpos5][ipos3] =
  400.     mpr[jpos7][ipos2] = (imgpel) ((P_F + P_H + 2*P_G + 2) >> 2);
  401.     mpr[jpos1][ipos6] =
  402.     mpr[jpos3][ipos5] =
  403.     mpr[jpos5][ipos4] =
  404.     mpr[jpos7][ipos3] = (imgpel) ((P_G + P_I + 2*P_H + 2) >> 2);
  405.     mpr[jpos1][ipos7] =
  406.     mpr[jpos3][ipos6] =
  407.     mpr[jpos5][ipos5] =
  408.     mpr[jpos7][ipos4] = (imgpel) ((P_H + P_J + 2*P_I + 2) >> 2);
  409.     mpr[jpos3][ipos7] =
  410.     mpr[jpos5][ipos6] =
  411.     mpr[jpos7][ipos5] = (imgpel) ((P_I + P_K + 2*P_J + 2) >> 2);
  412.     mpr[jpos5][ipos7] =
  413.     mpr[jpos7][ipos6] = (imgpel) ((P_J + P_L + 2*P_K + 2) >> 2);
  414.     mpr[jpos7][ipos7] = (imgpel) ((P_K + P_M + 2*P_L + 2) >> 2);
  415.     break;
  418.   case DIAG_DOWN_RIGHT_PRED:
  419.     if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
  420.       printf ("warning: Intra_8x8_Diagonal_Down_Right prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  422.     // Mode DIAG_DOWN_RIGHT_PRED
  423.     mpr[jpos7][ipos0] = (imgpel) ((P_X + P_V + 2*(P_W) + 2) >> 2);
  424.     mpr[jpos6][ipos0] =
  425.     mpr[jpos7][ipos1] = (imgpel) ((P_W + P_U + 2*(P_V) + 2) >> 2);
  426.     mpr[jpos5][ipos0] =
  427.     mpr[jpos6][ipos1] =
  428.     mpr[jpos7][ipos2] = (imgpel) ((P_V + P_T + 2*(P_U) + 2) >> 2);
  429.     mpr[jpos4][ipos0] =
  430.     mpr[jpos5][ipos1] =
  431.     mpr[jpos6][ipos2] =
  432.     mpr[jpos7][ipos3] = (imgpel) ((P_U + P_S + 2*(P_T) + 2) >> 2);
  433.     mpr[jpos3][ipos0] =
  434.     mpr[jpos4][ipos1] =
  435.     mpr[jpos5][ipos2] =
  436.     mpr[jpos6][ipos3] =
  437.     mpr[jpos7][ipos4] = (imgpel) ((P_T + P_R + 2*(P_S) + 2) >> 2);
  438.     mpr[jpos2][ipos0] =
  439.     mpr[jpos3][ipos1] =
  440.     mpr[jpos4][ipos2] =
  441.     mpr[jpos5][ipos3] =
  442.     mpr[jpos6][ipos4] =
  443.     mpr[jpos7][ipos5] = (imgpel) ((P_S + P_Q + 2*(P_R) + 2) >> 2);
  444.     mpr[jpos1][ipos0] =
  445.     mpr[jpos2][ipos1] =
  446.     mpr[jpos3][ipos2] =
  447.     mpr[jpos4][ipos3] =
  448.     mpr[jpos5][ipos4] =
  449.     mpr[jpos6][ipos5] =
  450.     mpr[jpos7][ipos6] = (imgpel) ((P_R + P_Z + 2*(P_Q) + 2) >> 2);
  451.     mpr[jpos0][ipos0] =
  452.     mpr[jpos1][ipos1] =
  453.     mpr[jpos2][ipos2] =
  454.     mpr[jpos3][ipos3] =
  455.     mpr[jpos4][ipos4] =
  456.     mpr[jpos5][ipos5] =
  457.     mpr[jpos6][ipos6] =
  458.     mpr[jpos7][ipos7] = (imgpel) ((P_Q + P_A + 2*(P_Z) + 2) >> 2);
  459.     mpr[jpos0][ipos1] =
  460.     mpr[jpos1][ipos2] =
  461.     mpr[jpos2][ipos3] =
  462.     mpr[jpos3][ipos4] =
  463.     mpr[jpos4][ipos5] =
  464.     mpr[jpos5][ipos6] =
  465.     mpr[jpos6][ipos7] = (imgpel) ((P_Z + P_B + 2*(P_A) + 2) >> 2);
  466.     mpr[jpos0][ipos2] =
  467.     mpr[jpos1][ipos3] =
  468.     mpr[jpos2][ipos4] =
  469.     mpr[jpos3][ipos5] =
  470.     mpr[jpos4][ipos6] =
  471.     mpr[jpos5][ipos7] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
  472.     mpr[jpos0][ipos3] =
  473.     mpr[jpos1][ipos4] =
  474.     mpr[jpos2][ipos5] =
  475.     mpr[jpos3][ipos6] =
  476.     mpr[jpos4][ipos7] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
  477.     mpr[jpos0][ipos4] =
  478.     mpr[jpos1][ipos5] =
  479.     mpr[jpos2][ipos6] =
  480.     mpr[jpos3][ipos7] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
  481.     mpr[jpos0][ipos5] =
  482.     mpr[jpos1][ipos6] =
  483.     mpr[jpos2][ipos7] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
  484.     mpr[jpos0][ipos6] =
  485.     mpr[jpos1][ipos7] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
  486.     mpr[jpos0][ipos7] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
  487.     break;
  489.   case  VERT_RIGHT_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  490.     if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
  491.       printf ("warning: Intra_8x8_Vertical_Right prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  493.     mpr[jpos0][ipos0] =
  494.     mpr[jpos2][ipos1] =
  495.     mpr[jpos4][ipos2] =
  496.     mpr[jpos6][ipos3] = (imgpel) ((P_Z + P_A + 1) >> 1);
  497.     mpr[jpos0][ipos1] =
  498.     mpr[jpos2][ipos2] =
  499.     mpr[jpos4][ipos3] =
  500.     mpr[jpos6][ipos4] = (imgpel) ((P_A + P_B + 1) >> 1);
  501.     mpr[jpos0][ipos2] =
  502.     mpr[jpos2][ipos3] =
  503.     mpr[jpos4][ipos4] =
  504.     mpr[jpos6][ipos5] = (imgpel) ((P_B + P_C + 1) >> 1);
  505.     mpr[jpos0][ipos3] =
  506.     mpr[jpos2][ipos4] =
  507.     mpr[jpos4][ipos5] =
  508.     mpr[jpos6][ipos6] = (imgpel) ((P_C + P_D + 1) >> 1);
  509.     mpr[jpos0][ipos4] =
  510.     mpr[jpos2][ipos5] =
  511.     mpr[jpos4][ipos6] =
  512.     mpr[jpos6][ipos7] = (imgpel) ((P_D + P_E + 1) >> 1);
  513.     mpr[jpos0][ipos5] =
  514.     mpr[jpos2][ipos6] =
  515.     mpr[jpos4][ipos7] = (imgpel) ((P_E + P_F + 1) >> 1);
  516.     mpr[jpos0][ipos6] =
  517.     mpr[jpos2][ipos7] = (imgpel) ((P_F + P_G + 1) >> 1);
  518.     mpr[jpos0][ipos7] = (imgpel) ((P_G + P_H + 1) >> 1);
  519.     mpr[jpos1][ipos0] =
  520.     mpr[jpos3][ipos1] =
  521.     mpr[jpos5][ipos2] =
  522.     mpr[jpos7][ipos3] = (imgpel) ((P_Q + P_A + 2*P_Z + 2) >> 2);
  523.     mpr[jpos1][ipos1] =
  524.     mpr[jpos3][ipos2] =
  525.     mpr[jpos5][ipos3] =
  526.     mpr[jpos7][ipos4] = (imgpel) ((P_Z + P_B + 2*P_A + 2) >> 2);
  527.     mpr[jpos1][ipos2] =
  528.     mpr[jpos3][ipos3] =
  529.     mpr[jpos5][ipos4] =
  530.     mpr[jpos7][ipos5] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
  531.     mpr[jpos1][ipos3] =
  532.     mpr[jpos3][ipos4] =
  533.     mpr[jpos5][ipos5] =
  534.     mpr[jpos7][ipos6] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
  535.     mpr[jpos1][ipos4] =
  536.     mpr[jpos3][ipos5] =
  537.     mpr[jpos5][ipos6] =
  538.     mpr[jpos7][ipos7] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
  539.     mpr[jpos1][ipos5] =
  540.     mpr[jpos3][ipos6] =
  541.     mpr[jpos5][ipos7] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
  542.     mpr[jpos1][ipos6] =
  543.     mpr[jpos3][ipos7] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
  544.     mpr[jpos1][ipos7] = (imgpel) ((P_F + P_H + 2*P_G + 2) >> 2);
  545.     mpr[jpos2][ipos0] =
  546.     mpr[jpos4][ipos1] =
  547.     mpr[jpos6][ipos2] = (imgpel) ((P_R + P_Z + 2*P_Q + 2) >> 2);
  548.     mpr[jpos3][ipos0] =
  549.     mpr[jpos5][ipos1] =
  550.     mpr[jpos7][ipos2] = (imgpel) ((P_S + P_Q + 2*P_R + 2) >> 2);
  551.     mpr[jpos4][ipos0] =
  552.     mpr[jpos6][ipos1] = (imgpel) ((P_T + P_R + 2*P_S + 2) >> 2);
  553.     mpr[jpos5][ipos0] =
  554.     mpr[jpos7][ipos1] = (imgpel) ((P_U + P_S + 2*P_T + 2) >> 2);
  555.     mpr[jpos6][ipos0] = (imgpel) ((P_V + P_T + 2*P_U + 2) >> 2);
  556.     mpr[jpos7][ipos0] = (imgpel) ((P_W + P_U + 2*P_V + 2) >> 2);
  557.     break;
  559.   case  HOR_DOWN_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  560.     if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
  561.       printf ("warning: Intra_8x8_Horizontal_Down prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  563.     mpr[jpos0][ipos0] =
  564.     mpr[jpos1][ipos2] =
  565.     mpr[jpos2][ipos4] =
  566.     mpr[jpos3][ipos6] = (imgpel) ((P_Q + P_Z + 1) >> 1);
  567.     mpr[jpos1][ipos0] =
  568.     mpr[jpos2][ipos2] =
  569.     mpr[jpos3][ipos4] =
  570.     mpr[jpos4][ipos6] = (imgpel) ((P_R + P_Q + 1) >> 1);
  571.     mpr[jpos2][ipos0] =
  572.     mpr[jpos3][ipos2] =
  573.     mpr[jpos4][ipos4] =
  574.     mpr[jpos5][ipos6] = (imgpel) ((P_S + P_R + 1) >> 1);
  575.     mpr[jpos3][ipos0] =
  576.     mpr[jpos4][ipos2] =
  577.     mpr[jpos5][ipos4] =
  578.     mpr[jpos6][ipos6] = (imgpel) ((P_T + P_S + 1) >> 1);
  579.     mpr[jpos4][ipos0] =
  580.     mpr[jpos5][ipos2] =
  581.     mpr[jpos6][ipos4] =
  582.     mpr[jpos7][ipos6] = (imgpel) ((P_U + P_T + 1) >> 1);
  583.     mpr[jpos5][ipos0] =
  584.     mpr[jpos6][ipos2] =
  585.     mpr[jpos7][ipos4] = (imgpel) ((P_V + P_U + 1) >> 1);
  586.     mpr[jpos6][ipos0] =
  587.     mpr[jpos7][ipos2] = (imgpel) ((P_W + P_V + 1) >> 1);
  588.     mpr[jpos7][ipos0] = (imgpel) ((P_X + P_W + 1) >> 1);
  589.     mpr[jpos0][ipos1] =
  590.     mpr[jpos1][ipos3] =
  591.     mpr[jpos2][ipos5] =
  592.     mpr[jpos3][ipos7] = (imgpel) ((P_Q + P_A + 2*P_Z + 2) >> 2);
  593.     mpr[jpos1][ipos1] =
  594.     mpr[jpos2][ipos3] =
  595.     mpr[jpos3][ipos5] =
  596.     mpr[jpos4][ipos7] = (imgpel) ((P_Z + P_R + 2*P_Q + 2) >> 2);
  597.     mpr[jpos2][ipos1] =
  598.     mpr[jpos3][ipos3] =
  599.     mpr[jpos4][ipos5] =
  600.     mpr[jpos5][ipos7] = (imgpel) ((P_Q + P_S + 2*P_R + 2) >> 2);
  601.     mpr[jpos3][ipos1] =
  602.     mpr[jpos4][ipos3] =
  603.     mpr[jpos5][ipos5] =
  604.     mpr[jpos6][ipos7] = (imgpel) ((P_R + P_T + 2*P_S + 2) >> 2);
  605.     mpr[jpos4][ipos1] =
  606.     mpr[jpos5][ipos3] =
  607.     mpr[jpos6][ipos5] =
  608.     mpr[jpos7][ipos7] = (imgpel) ((P_S + P_U + 2*P_T + 2) >> 2);
  609.     mpr[jpos5][ipos1] =
  610.     mpr[jpos6][ipos3] =
  611.     mpr[jpos7][ipos5] = (imgpel) ((P_T + P_V + 2*P_U + 2) >> 2);
  612.     mpr[jpos6][ipos1] =
  613.     mpr[jpos7][ipos3] = (imgpel) ((P_U + P_W + 2*P_V + 2) >> 2);
  614.     mpr[jpos7][ipos1] = (imgpel) ((P_V + P_X + 2*P_W + 2) >> 2);
  615.     mpr[jpos0][ipos2] =
  616.     mpr[jpos1][ipos4] =
  617.     mpr[jpos2][ipos6] = (imgpel) ((P_Z + P_B + 2*P_A + 2) >> 2);
  618.     mpr[jpos0][ipos3] =
  619.     mpr[jpos1][ipos5] =
  620.     mpr[jpos2][ipos7] = (imgpel) ((P_A + P_C + 2*P_B + 2) >> 2);
  621.     mpr[jpos0][ipos4] =
  622.     mpr[jpos1][ipos6] = (imgpel) ((P_B + P_D + 2*P_C + 2) >> 2);
  623.     mpr[jpos0][ipos5] =
  624.     mpr[jpos1][ipos7] = (imgpel) ((P_C + P_E + 2*P_D + 2) >> 2);
  625.     mpr[jpos0][ipos6] = (imgpel) ((P_D + P_F + 2*P_E + 2) >> 2);
  626.     mpr[jpos0][ipos7] = (imgpel) ((P_E + P_G + 2*P_F + 2) >> 2);
  627.     break;
  629.   case  HOR_UP_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
  630.     if (!block_available_left)
  631.       printf ("warning: Intra_8x8_Horizontal_Up prediction mode not allowed at mb %dn", (int) img->current_mb_nr);
  633.     mpr[jpos0][ipos0] = (imgpel) ((P_Q + P_R + 1) >> 1);
  634.     mpr[jpos1][ipos0] =
  635.     mpr[jpos0][ipos2] = (imgpel) ((P_R + P_S + 1) >> 1);
  636.     mpr[jpos2][ipos0] =
  637.     mpr[jpos1][ipos2] =
  638.     mpr[jpos0][ipos4] = (imgpel) ((P_S + P_T + 1) >> 1);
  639.     mpr[jpos3][ipos0] =
  640.     mpr[jpos2][ipos2] =
  641.     mpr[jpos1][ipos4] =
  642.     mpr[jpos0][ipos6] = (imgpel) ((P_T + P_U + 1) >> 1);
  643.     mpr[jpos4][ipos0] =
  644.     mpr[jpos3][ipos2] =
  645.     mpr[jpos2][ipos4] =
  646.     mpr[jpos1][ipos6] = (imgpel) ((P_U + P_V + 1) >> 1);
  647.     mpr[jpos5][ipos0] =
  648.     mpr[jpos4][ipos2] =
  649.     mpr[jpos3][ipos4] =
  650.     mpr[jpos2][ipos6] = (imgpel) ((P_V + P_W + 1) >> 1);
  651.     mpr[jpos6][ipos0] =
  652.     mpr[jpos5][ipos2] =
  653.     mpr[jpos4][ipos4] =
  654.     mpr[jpos3][ipos6] = (imgpel) ((P_W + P_X + 1) >> 1);
  655.     mpr[jpos4][ipos6] =
  656.     mpr[jpos4][ipos7] =
  657.     mpr[jpos5][ipos4] =
  658.     mpr[jpos5][ipos5] =
  659.     mpr[jpos5][ipos6] =
  660.     mpr[jpos5][ipos7] =
  661.     mpr[jpos6][ipos2] =
  662.     mpr[jpos6][ipos3] =
  663.     mpr[jpos6][ipos4] =
  664.     mpr[jpos6][ipos5] =
  665.     mpr[jpos6][ipos6] =
  666.     mpr[jpos6][ipos7] =
  667.     mpr[jpos7][ipos0] =
  668.     mpr[jpos7][ipos1] =
  669.     mpr[jpos7][ipos2] =
  670.     mpr[jpos7][ipos3] =
  671.     mpr[jpos7][ipos4] =
  672.     mpr[jpos7][ipos5] =
  673.     mpr[jpos7][ipos6] =
  674.     mpr[jpos7][ipos7] = (imgpel) P_X;
  675.     mpr[jpos6][ipos1] =
  676.     mpr[jpos5][ipos3] =
  677.     mpr[jpos4][ipos5] =
  678.     mpr[jpos3][ipos7] = (imgpel) ((P_W + 3*P_X + 2) >> 2);
  679.     mpr[jpos5][ipos1] =
  680.     mpr[jpos4][ipos3] =
  681.     mpr[jpos3][ipos5] =
  682.     mpr[jpos2][ipos7] = (imgpel) ((P_X + P_V + 2*P_W + 2) >> 2);
  683.     mpr[jpos4][ipos1] =
  684.     mpr[jpos3][ipos3] =
  685.     mpr[jpos2][ipos5] =
  686.     mpr[jpos1][ipos7] = (imgpel) ((P_W + P_U + 2*P_V + 2) >> 2);
  687.     mpr[jpos3][ipos1] =
  688.     mpr[jpos2][ipos3] =
  689.     mpr[jpos1][ipos5] =
  690.     mpr[jpos0][ipos7] = (imgpel) ((P_V + P_T + 2*P_U + 2) >> 2);
  691.     mpr[jpos2][ipos1] =
  692.     mpr[jpos1][ipos3] =
  693.     mpr[jpos0][ipos5] = (imgpel) ((P_U + P_S + 2*P_T + 2) >> 2);
  694.     mpr[jpos1][ipos1] =
  695.     mpr[jpos0][ipos3] = (imgpel) ((P_T + P_R + 2*P_S + 2) >> 2);
  696.     mpr[jpos0][ipos1] = (imgpel) ((P_S + P_Q + 2*P_R + 2) >> 2);
  697.     break;
  699.   default:
  700.     printf("Error: illegal intra_4x4 prediction mode: %dn",predmode);
  701.     return SEARCH_SYNC;
  702.     break;
  703.   }
  704.   return DECODING_OK;
  705. }
  709. /*!
  710.  *************************************************************************************
  711.  * brief
  712.  *    Prefiltering for Intra8x8 prediction
  713.  *************************************************************************************
  714.  */
  715. void LowPassForIntra8x8Pred(imgpel *PredPel, int block_up_left, int block_up, int block_left)
  716. {
  717.   int i;
  718.   imgpel LoopArray[25];
  720.   memcpy(&LoopArray[0], &PredPel[0], 25 * sizeof(imgpel));
  722.   if(block_up_left)
  723.   {
  724.     if(block_up && block_left)
  725.     {
  726.       LoopArray[0] = (imgpel) ((P_Q + (P_Z<<1) + P_A +2)>>2);
  727.     }
  728.     else
  729.     {
  730.       if(block_up)
  731.         LoopArray[0] = (imgpel) ((P_Z + (P_Z<<1) + P_A +2)>>2);
  732.       else if (block_left)
  733.         LoopArray[0] = (imgpel) ((P_Z + (P_Z<<1) + P_Q +2)>>2);
  734.     }
  735.   }
  736.   
  737.   if(block_up)
  738.   {    
  739.     if(block_up_left)
  740.     {
  741.       LoopArray[1] = (imgpel) ((PredPel[0] + (PredPel[1]<<1) + PredPel[2] + 2)>>2);
  742.     }
  743.     else
  744.       LoopArray[1] = (imgpel) ((PredPel[1] + (PredPel[1]<<1) + PredPel[2] + 2)>>2);
  747.     for(i = 2; i <16; i++)
  748.     {
  749.       LoopArray[i] = (imgpel) ((PredPel[i-1] + (PredPel[i]<<1) + PredPel[i+1] + 2)>>2);
  750.     }
  751.     LoopArray[16] = (imgpel) ((P_P + (P_P<<1) + P_O + 2)>>2);
  752.   }
  755.   if(block_left)
  756.   {
  757.     if(block_up_left)
  758.       LoopArray[17] = (imgpel) ((P_Z + (P_Q<<1) + P_R + 2)>>2);
  759.     else
  760.       LoopArray[17] = (imgpel) ((P_Q + (P_Q<<1) + P_R + 2)>>2);
  762.     for(i = 18; i <24; i++)
  763.     {
  764.       LoopArray[i] = (imgpel) ((PredPel[i-1] + (PredPel[i]<<1) + PredPel[i+1] + 2)>>2);
  765.     }
  766.     LoopArray[24] = (imgpel) ((P_W + (P_X<<1) + P_X + 2) >> 2);
  767.   }
  769.   memcpy(&PredPel[0], &LoopArray[0], 25 * sizeof(imgpel));
  770. }
  774. /*!
  775.  ***********************************************************************
  776.  * brief
  777.  *    Inverse 8x8 transformation
  778.  ***********************************************************************
  779.  */ 
  780. void itrans8x8(ImageParameters *img, //!< image parameters
  781.                Macroblock *currMB,
  782.                ColorPlane pl,               
  783.                int ioff,            //!< index to 4x4 block
  784.                int joff)            //!<
  785. {
  786.   int i,j;
  787.   Boolean lossless_qpprime = (Boolean) (currMB->qp_scaled[pl] == 0 && img->lossless_qpprime_flag==1);
  789.   imgpel (*mpr)[16] = img->mb_pred[pl];
  790.   int    (*m7)[16]  = img->mb_rres[pl];
  791.   int     max_imgpel_value = img->max_imgpel_value_comp[pl];
  793.   if(lossless_qpprime)
  794.   {
  795.     for( j = joff; j < joff + 8; j++)
  796.     {
  797.       for( i = ioff; i < ioff + 8; i++)
  798.         m7[j][i] = iClip1(max_imgpel_value, (m7[j][i] + (long)mpr[j][i])); 
  799.     }
  800.   }
  801.   else
  802.   {
  803.     inverse8x8(m7, m7, joff, ioff);
  804.     for( j = joff; j < joff + 8; j++)
  805.     {
  806.       for( i = ioff; i < ioff + 8; i++)
  807.         m7[j][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS_8)), DQ_BITS_8)); 
  808.     }
  809.   }
  810. }