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

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

Audio

开发平台：

Visual C++

q_offsets.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file q_offsets.c
  5.  *
  6.  * brief
  7.  *    read Quantization Offset matrix parameters from input file: q_OffsetMatrix.cfg
  8.  *
  9.  *************************************************************************************
  10.  */
  12. #include "global.h"
  13. #include "memalloc.h"
  14. #include "q_matrix.h"
  15. #include "q_offsets.h"
  17. extern char *GetConfigFileContent (char *Filename, int error_type);
  19. #define MAX_ITEMS_TO_PARSE  2000
  21. int offset4x4_check[6] = { 0, 0, 0, 0, 0, 0 };
  22. int offset8x8_check[6] = { 0, 0, 0, 0, 0, 0 };
  24. static const char OffsetType4x4[15][24] = {
  25.   "INTRA4X4_LUMA_INTRA",
  26.   "INTRA4X4_CHROMAU_INTRA",
  27.   "INTRA4X4_CHROMAV_INTRA",
  28.   "INTRA4X4_LUMA_INTERP",
  29.   "INTRA4X4_CHROMAU_INTERP",
  30.   "INTRA4X4_CHROMAV_INTERP",
  31.   "INTRA4X4_LUMA_INTERB",
  32.   "INTRA4X4_CHROMAU_INTERB",
  33.   "INTRA4X4_CHROMAV_INTERB",
  34.   "INTER4X4_LUMA_INTERP",
  35.   "INTER4X4_CHROMAU_INTERP",
  36.   "INTER4X4_CHROMAV_INTERP",
  37.   "INTER4X4_LUMA_INTERB",
  38.   "INTER4X4_CHROMAU_INTERB",
  39.   "INTER4X4_CHROMAV_INTERB"
  40. };
  42. static const char OffsetType8x8[15][24] = {
  43.   "INTRA8X8_LUMA_INTRA",
  44.   "INTRA8X8_LUMA_INTERP",
  45.   "INTRA8X8_LUMA_INTERB",
  46.   "INTER8X8_LUMA_INTERP",
  47.   "INTER8X8_LUMA_INTERB",
  48.   "INTRA8X8_CHROMAU_INTRA",
  49.   "INTRA8X8_CHROMAU_INTERP",
  50.   "INTRA8X8_CHROMAU_INTERB",
  51.   "INTER8X8_CHROMAU_INTERP",
  52.   "INTER8X8_CHROMAU_INTERB",
  53.   "INTRA8X8_CHROMAV_INTRA",
  54.   "INTRA8X8_CHROMAV_INTERP",
  55.   "INTRA8X8_CHROMAV_INTERB",
  56.   "INTER8X8_CHROMAV_INTERP",
  57.   "INTER8X8_CHROMAV_INTERB"
  58. };
  61. int *****LevelOffset4x4Comp;
  62. int *****LevelOffset8x8Comp;
  64. // global pointers for level offset matrices
  65. int ****ptLevelOffset4x4;
  66. int ****ptLevelOffset8x8;
  68. int AdaptRndWeight;
  69. int AdaptRndCrWeight;
  71. short **OffsetList4x4input;
  72. short **OffsetList8x8input;
  73. short ***OffsetList4x4;
  74. short ***OffsetList8x8;
  76. void InitOffsetParam ();
  78. const int OffsetBits = 11;
  80. static const short Offset_intra_default_intra[16] = {
  81.   682, 682, 682, 682,
  82.   682, 682, 682, 682,
  83.   682, 682, 682, 682,
  84.   682, 682, 682, 682
  85. };
  87. static const short Offset_intra_default_chroma[16] = {
  88.   682, 682, 682, 682,
  89.   682, 682, 682, 682,
  90.   682, 682, 682, 682,
  91.   682, 682, 682, 682
  92. };
  95. static const short Offset_intra_default_inter[16] = {
  96.   342, 342, 342, 342,
  97.   342, 342, 342, 342,
  98.   342, 342, 342, 342,
  99.   342, 342, 342, 342,
  100. };
  102. static const short Offset_inter_default[16] = {
  103.   342, 342, 342, 342,
  104.   342, 342, 342, 342,
  105.   342, 342, 342, 342,
  106.   342, 342, 342, 342,
  107. };
  109. static const short Offset8_intra_default_intra[64] = {
  110.   682, 682, 682, 682, 682, 682, 682, 682,
  111.   682, 682, 682, 682, 682, 682, 682, 682,
  112.   682, 682, 682, 682, 682, 682, 682, 682,
  113.   682, 682, 682, 682, 682, 682, 682, 682,
  114.   682, 682, 682, 682, 682, 682, 682, 682,
  115.   682, 682, 682, 682, 682, 682, 682, 682,
  116.   682, 682, 682, 682, 682, 682, 682, 682,
  117.   682, 682, 682, 682, 682, 682, 682, 682
  118. };
  120. static const short Offset8_intra_default_chroma[64] = {
  121.   682, 682, 682, 682, 682, 682, 682, 682,
  122.   682, 682, 682, 682, 682, 682, 682, 682,
  123.   682, 682, 682, 682, 682, 682, 682, 682,
  124.   682, 682, 682, 682, 682, 682, 682, 682,
  125.   682, 682, 682, 682, 682, 682, 682, 682,
  126.   682, 682, 682, 682, 682, 682, 682, 682,
  127.   682, 682, 682, 682, 682, 682, 682, 682,
  128.   682, 682, 682, 682, 682, 682, 682, 682
  129. };
  131. static const short Offset8_intra_default_inter[64] = {
  132.   342, 342, 342, 342, 342, 342, 342, 342,
  133.   342, 342, 342, 342, 342, 342, 342, 342,
  134.   342, 342, 342, 342, 342, 342, 342, 342,
  135.   342, 342, 342, 342, 342, 342, 342, 342,
  136.   342, 342, 342, 342, 342, 342, 342, 342,
  137.   342, 342, 342, 342, 342, 342, 342, 342,
  138.   342, 342, 342, 342, 342, 342, 342, 342,
  139.   342, 342, 342, 342, 342, 342, 342, 342
  140. };
  142. static const short Offset8_inter_default[64] = {
  143.   342, 342, 342, 342, 342, 342, 342, 342,
  144.   342, 342, 342, 342, 342, 342, 342, 342,
  145.   342, 342, 342, 342, 342, 342, 342, 342,
  146.   342, 342, 342, 342, 342, 342, 342, 342,
  147.   342, 342, 342, 342, 342, 342, 342, 342,
  148.   342, 342, 342, 342, 342, 342, 342, 342,
  149.   342, 342, 342, 342, 342, 342, 342, 342,
  150.   342, 342, 342, 342, 342, 342, 342, 342
  151. };
  153. /*!
  154.  ***********************************************************************
  155.  * brief
  156.  *    Allocate Q matrix arrays
  157.  ***********************************************************************
  158.  */
  159. void allocate_QOffsets ()
  160. {
  161.   int max_bitdepth = imax(params->output.bit_depth[0], params->output.bit_depth[1]);
  162.   int max_qp = (3 + 6*(max_bitdepth));
  164.   get_mem5Dint(&LevelOffset4x4Comp, 3, 2, max_qp + 1, 4, 4);
  165.   get_mem5Dint(&LevelOffset8x8Comp, 3, 2, max_qp + 1, 8, 8);
  167.   if (params->AdaptRoundingFixed)
  168.   {
  169.     get_mem3Dshort(&OffsetList4x4, 1, 25, 16);
  170.     get_mem3Dshort(&OffsetList8x8, 1, 15, 64);    
  171.   }
  172.   else
  173.   {
  174.     get_mem3Dshort(&OffsetList4x4, max_qp + 1, 25, 16);
  175.     get_mem3Dshort(&OffsetList8x8, max_qp + 1, 15, 64);    
  176.   }
  178.   get_mem2Dshort(&OffsetList4x4input, 25, 16);
  179.   get_mem2Dshort(&OffsetList8x8input, 15, 64);
  180. }
  182. /*!
  183.  ***********************************************************************
  184.  * brief
  185.  *    Free Q matrix arrays
  186.  ***********************************************************************
  187.  */
  188. void free_QOffsets ()
  189. {
  190.   free_mem5Dint(LevelOffset4x4Comp);
  191.   free_mem5Dint(LevelOffset8x8Comp);
  193.   if (params->AdaptRoundingFixed)
  194.   {
  195.     free_mem3Dshort(OffsetList8x8);
  196.     free_mem3Dshort(OffsetList4x4);    
  197.   }
  198.   else
  199.   {
  200.     free_mem3Dshort(OffsetList8x8);
  201.     free_mem3Dshort(OffsetList4x4);    
  202.   }
  204.   free_mem2Dshort(OffsetList8x8input);
  205.   free_mem2Dshort(OffsetList4x4input);
  206. }
  209. /*!
  210.  ***********************************************************************
  211.  * brief
  212.  *    Check the parameter name.
  213.  * param s
  214.  *    parameter name string
  215.  * param type
  216.  *    4x4 or 8x8 offset matrix type
  217.  * return
  218.  *    the index number if the string is a valid parameter name,         n
  219.  *    -1 for error
  220.  ***********************************************************************
  221.  */
  223. int CheckOffsetParameterName (char *s, int *type)
  224. {
  225.   int i = 0;
  227.   *type = 0;
  228.   while ((OffsetType4x4[i] != NULL) && (i < 15))
  229.   {
  230.     if (0 == strcmp (OffsetType4x4[i], s))
  231.       return i;
  232.     else
  233.       i++;
  234.   }
  236.   i = 0;
  237.   *type = 1;
  238.   while ((OffsetType8x8[i] != NULL) && (i < 15))
  239.   {
  240.     if (0 == strcmp (OffsetType8x8[i], s))
  241.       return i;
  242.     else
  243.       i++;
  244.   }
  246.   return -1;
  247. }
  249. /*!
  250.  ***********************************************************************
  251.  * brief
  252.  *    Parse the Q Offset Matrix values read from cfg file.
  253.  * param buf
  254.  *    buffer to be parsed
  255.  * param bufsize
  256.  *    buffer size of buffer
  257.  ***********************************************************************
  258.  */
  259. void ParseQOffsetMatrix (char *buf, int bufsize)
  260. {
  261.   char *items[MAX_ITEMS_TO_PARSE];
  262.   int MapIdx;
  263.   int item = 0;
  264.   int InString = 0, InItem = 0;
  265.   char *p = buf;
  266.   char *bufend = &buf[bufsize];
  267.   int IntContent;
  268.   int i, j, range, type, cnt;
  269.   short *OffsetList;
  271.   while (p < bufend)
  272.   {
  273.     switch (*p)
  274.     {
  275.       case 13:
  276.         p++;
  277.         break;
  278.       case '#':                 // Found comment
  279.         *p = '';              // Replace '#' with '' in case of comment immediately following integer or string
  280.         while (*p != 'n' && p < bufend)  // Skip till EOL or EOF, whichever comes first
  281.           p++;
  282.         InString = 0;
  283.         InItem = 0;
  284.         break;
  285.       case 'n':
  286.         InItem = 0;
  287.         InString = 0;
  288.       *p++ = '';
  289.         break;
  290.       case ' ':
  291.       case 't':              // Skip whitespace, leave state unchanged
  292.         if (InString)
  293.           p++;
  294.         else
  295.         {                     // Terminate non-strings once whitespace is found
  296.           *p++ = '';
  297.           InItem = 0;
  298.         }
  299.         break;
  301.       case '"':               // Begin/End of String
  302.         *p++ = '';
  303.         if (!InString)
  304.         {
  305.           items[item++] = p;
  306.           InItem = ~InItem;
  307.         }
  308.         else
  309.           InItem = 0;
  310.         InString = ~InString; // Toggle
  311.         break;
  313.       case ',':
  314.         p++;
  315.         InItem = 0;
  316.         break;
  318.       default:
  319.         if (!InItem)
  320.         {
  321.           items[item++] = p;
  322.           InItem = ~InItem;
  323.         }
  324.         p++;
  325.     }
  326.   }
  328.   item--;
  330.   for (i = 0; i < item; i += cnt)
  331.   {
  332.     cnt = 0;
  333.     if (0 > (MapIdx = CheckOffsetParameterName (items[i + cnt], &type)))
  334.     {
  335.       snprintf (errortext, ET_SIZE,
  336.         " Parsing error in config file: Parameter Name '%s' not recognized.",
  337.         items[i + cnt]);
  338.       error (errortext, 300);
  339.     }
  340.     cnt++;
  341.     if (strcmp ("=", items[i + cnt]))
  342.     {
  343.       snprintf (errortext, ET_SIZE,
  344.         " Parsing error in config file: '=' expected as the second token in each item.");
  345.       error (errortext, 300);
  346.     }
  347.     cnt++;
  349.     if (!type) //4x4 Matrix
  350.     {
  351.       range = 16;
  352.       OffsetList = OffsetList4x4input[MapIdx];
  353.       offset4x4_check[MapIdx] = 1; //to indicate matrix found in cfg file
  354.     }
  355.     else //8x8 matrix
  356.     {
  357.       range = 64;
  358.       OffsetList = OffsetList8x8input[MapIdx];
  359.       offset8x8_check[MapIdx] = 1; //to indicate matrix found in cfg file
  360.     }
  362.     for (j = 0; j < range; j++)
  363.     {
  364.       if (1 != sscanf (items[i + cnt + j], "%d", &IntContent))
  365.       {
  366.         snprintf (errortext, ET_SIZE,
  367.           " Parsing error: Expected numerical value for Parameter of %s, found '%s'.",
  368.           items[i], items[i + cnt + j]);
  369.         error (errortext, 300);
  370.       }
  372.       OffsetList[j] = (short) IntContent; //save value in matrix
  373.     }
  374.     cnt += j;
  375.     printf (".");
  376.   }
  377. }
  380. /*!
  381.  ***********************************************************************
  382.  * brief
  383.  *    Initialise Q offset matrix values.
  384.  ***********************************************************************
  385.  */
  386. void Init_QOffsetMatrix ()
  387. {
  388.   char *content;
  390.   allocate_QOffsets ();
  392.   if (params->OffsetMatrixPresentFlag)
  393.   {
  394.     printf ("Parsing Quantization Offset Matrix file %s ",
  395.       params->QOffsetMatrixFile);
  396.     content = GetConfigFileContent (params->QOffsetMatrixFile, 0);
  397.     if (content != '')
  398.       ParseQOffsetMatrix (content, strlen (content));
  399.     else
  400.     {
  401.       printf
  402.         ("nError: %snProceeding with default values for all matrices.",
  403.         errortext);
  404.       params->OffsetMatrixPresentFlag = 0;
  405.     }
  407.     printf ("n");
  409.     free (content);
  410.   }
  411.   //! Now set up all offset params. This process could be reused if we wish to re-init offsets
  412.   InitOffsetParam ();
  413. }
  415. /*!
  416.  ************************************************************************
  417.  * brief
  418.  *    Intit quantization offset params
  419.  *
  420.  * par Input:
  421.  *    none
  422.  *
  423.  * par Output:
  424.  *    none
  425.  ************************************************************************
  426.  */
  428. void InitOffsetParam ()
  429. {
  430.   int i, k;
  431.   int max_qp_luma = (4 + 6*(params->output.bit_depth[0]));
  432.   int max_qp_cr   = (4 + 6*(params->output.bit_depth[1]));
  434.   for (i = 0; i < (params->AdaptRoundingFixed ? 1 : imax(max_qp_luma, max_qp_cr)); i++)
  435.   {
  436.     if (params->OffsetMatrixPresentFlag)
  437.     {
  438.       memcpy(&(OffsetList4x4[i][0][0]),&(OffsetList4x4input[0][0]), 400 * sizeof(short)); // 25 * 16
  439.       memcpy(&(OffsetList8x8[i][0][0]),&(OffsetList8x8input[0][0]), 960 * sizeof(short)); // 15 * 64
  440.     }
  441.     else
  442.     {
  443.       // 0 (INTRA4X4_LUMA_INTRA)
  444.       memcpy(&(OffsetList4x4[i][0][0]),&(Offset_intra_default_intra[0]), 16 * sizeof(short));
  445.       for (k = 1; k < 3; k++) // 1,2 (INTRA4X4_CHROMA_INTRA)
  446.         memcpy(&(OffsetList4x4[i][k][0]),&(Offset_intra_default_chroma[0]),  16 * sizeof(short));
  447.       for (k = 3; k < 9; k++) // 3,4,5,6,7,8 (INTRA4X4_LUMA/CHROMA_INTERP/INTERB)
  448.         memcpy(&(OffsetList4x4[i][k][0]),&(Offset_intra_default_inter[0]),  16 * sizeof(short));
  449.       for (k = 9; k < 25; k++) // 9,10,11,12,13,14 (INTER4X4)
  450.         memcpy(&(OffsetList4x4[i][k][0]),&(Offset_inter_default[0]),  16 * sizeof(short));
  452.       // 0 (INTRA8X8_LUMA_INTRA)
  453.       memcpy(&(OffsetList8x8[i][0][0]),&(Offset8_intra_default_intra[0]), 64 * sizeof(short));
  454.       for (k = 1; k < 3; k++)  // 1,2 (INTRA8X8_LUMA_INTERP/INTERB)
  455.         memcpy(&(OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
  456.       for (k = 3; k < 5; k++)  // 3,4 (INTER8X8_LUMA_INTERP/INTERB)
  457.         memcpy(&(OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
  459.       // 5 (INTRA8X8_CHROMAU_INTRA)
  460.       memcpy(&(OffsetList8x8[i][5][0]),&(Offset8_intra_default_chroma[0]), 64 * sizeof(short));
  461.       for (k = 6; k < 8; k++)  // 6,7 (INTRA8X8_CHROMAU_INTERP/INTERB)
  462.         memcpy(&(OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
  463.       for (k = 8; k < 10; k++)  // 8,9 (INTER8X8_CHROMAU_INTERP/INTERB)
  464.         memcpy(&(OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
  466.       // 10 (INTRA8X8_CHROMAV_INTRA)
  467.       memcpy(&(OffsetList8x8[i][10][0]),&(Offset8_intra_default_chroma[0]), 64 * sizeof(short));
  468.       for (k = 11; k < 13; k++)  // 11,12 (INTRA8X8_CHROMAV_INTERP/INTERB)
  469.         memcpy(&(OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
  470.       for (k = 13; k < 15; k++)  // 8,9 (INTER8X8_CHROMAV_INTERP/INTERB)
  471.         memcpy(&(OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
  472.     }
  473.   }  
  474. }
  477. /*!
  478.  ************************************************************************
  479.  * brief
  480.  *    Calculation of the quantization offset params at the frame level
  481.  *
  482.  * par Input:
  483.  *    none
  484.  *
  485.  * par Output:
  486.  *    none
  487.  ************************************************************************
  488.  */
  489. void CalculateOffsetParam ()
  490. {
  491.   int i, j, k, temp;  
  492.   int qp_per, qp;
  493.   short **OffsetList;
  494.   static int **LevelOffsetCmp0Intra, **LevelOffsetCmp1Intra, **LevelOffsetCmp2Intra;
  495.   static int **LevelOffsetCmp0Inter, **LevelOffsetCmp1Inter, **LevelOffsetCmp2Inter;
  496.   int img_type = (img->type == SI_SLICE ? I_SLICE : (img->type == SP_SLICE ? P_SLICE : img->type));
  498.   int max_qp_scale = imax(img->bitdepth_luma_qp_scale, img->bitdepth_chroma_qp_scale);
  499.   int max_qp = 51 + max_qp_scale;
  501.   AdaptRndWeight = params->AdaptRndWFactor[img->nal_reference_idc != 0][img_type];
  502.   AdaptRndCrWeight = params->AdaptRndCrWFactor[img->nal_reference_idc != 0][img_type];
  504.   if (img_type == I_SLICE )
  505.   {
  506.     for (qp = 0; qp < max_qp + 1; qp++)
  507.     {
  508.       k = qp_per_matrix [qp];
  509.       qp_per = Q_BITS + k - OffsetBits;
  510.       OffsetList = OffsetList4x4[params->AdaptRoundingFixed ? 0 : qp];
  511.       LevelOffsetCmp0Intra = LevelOffset4x4Comp[0][1][qp];
  512.       LevelOffsetCmp1Intra = LevelOffset4x4Comp[1][1][qp];
  513.       LevelOffsetCmp2Intra = LevelOffset4x4Comp[2][1][qp];
  515.       temp = 0;
  516.       for (j = 0; j < 4; j++)
  517.       {
  518.         for (i = 0; i < 4; i++, temp++)
  519.         {
  520.           LevelOffsetCmp0Intra[j][i] = (int) OffsetList[0][temp] << qp_per;
  521.           LevelOffsetCmp1Intra[j][i] = (int) OffsetList[1][temp] << qp_per;
  522.           LevelOffsetCmp2Intra[j][i] = (int) OffsetList[2][temp] << qp_per;
  523.         }
  524.       }
  525.     }
  526.   }
  527.   else if (img_type == B_SLICE)
  528.   {
  529.     for (qp = 0; qp < max_qp + 1; qp++)
  530.     {
  531.       k = qp_per_matrix [qp];
  532.       qp_per = Q_BITS + k - OffsetBits;
  533.       OffsetList = OffsetList4x4[params->AdaptRoundingFixed ? 0 : qp];
  534.       LevelOffsetCmp0Intra = LevelOffset4x4Comp[0][1][qp];
  535.       LevelOffsetCmp1Intra = LevelOffset4x4Comp[1][1][qp];
  536.       LevelOffsetCmp2Intra = LevelOffset4x4Comp[2][1][qp];
  537.       LevelOffsetCmp0Inter = LevelOffset4x4Comp[0][0][qp];
  538.       LevelOffsetCmp1Inter = LevelOffset4x4Comp[1][0][qp];
  539.       LevelOffsetCmp2Inter = LevelOffset4x4Comp[2][0][qp];
  542.       for (temp = 0, j = 0; j < 4; j++)
  543.       {
  544.         for (i = 0; i < 4; i++, temp++)
  545.         {          
  546.           // intra
  547.           LevelOffsetCmp0Intra[j][i] = (int) OffsetList[6][temp] << qp_per;
  548.           LevelOffsetCmp1Intra[j][i] = (int) OffsetList[7][temp] << qp_per;
  549.           LevelOffsetCmp2Intra[j][i] = (int) OffsetList[8][temp] << qp_per;
  550.         }
  551.       }
  553.       for (temp = 0, j = 0; j < 4; j++)
  554.       {
  555.         for (i = 0; i < 4; i++, temp++)
  556.         {          
  557.           // inter
  558.           LevelOffsetCmp0Inter[j][i] = (int) OffsetList[12][temp] << qp_per;
  559.           LevelOffsetCmp1Inter[j][i] = (int) OffsetList[13][temp] << qp_per;
  560.           LevelOffsetCmp2Inter[j][i] = (int) OffsetList[14][temp] << qp_per;
  561.         }
  562.       }
  564.     }
  565.   }
  566.   else
  567.   {
  568.     for (qp = 0; qp < max_qp + 1; qp++)
  569.     {
  570.       k = qp_per_matrix [qp];
  571.       qp_per = Q_BITS + k - OffsetBits;
  572.       OffsetList = OffsetList4x4[params->AdaptRoundingFixed ? 0 : qp];
  573.       LevelOffsetCmp0Intra = LevelOffset4x4Comp[0][1][qp];
  574.       LevelOffsetCmp1Intra = LevelOffset4x4Comp[1][1][qp];
  575.       LevelOffsetCmp2Intra = LevelOffset4x4Comp[2][1][qp];
  576.       LevelOffsetCmp0Inter = LevelOffset4x4Comp[0][0][qp];
  577.       LevelOffsetCmp1Inter = LevelOffset4x4Comp[1][0][qp];
  578.       LevelOffsetCmp2Inter = LevelOffset4x4Comp[2][0][qp];
  580.       temp = 0;
  581.       for (j = 0; j < 4; j++)
  582.       {
  583.         for (i = 0; i < 4; i++, temp++)
  584.         {
  585.           // intra
  586.           LevelOffsetCmp0Intra[j][i] = (int) OffsetList[3][temp] << qp_per;
  587.           LevelOffsetCmp1Intra[j][i] = (int) OffsetList[4][temp] << qp_per;
  588.           LevelOffsetCmp2Intra[j][i] = (int) OffsetList[5][temp] << qp_per;
  589.           // inter
  590.           LevelOffsetCmp0Inter[j][i] = (int) OffsetList[9 ][temp] << qp_per;
  591.           LevelOffsetCmp1Inter[j][i] = (int) OffsetList[10][temp] << qp_per;
  592.           LevelOffsetCmp2Inter[j][i] = (int) OffsetList[11][temp] << qp_per;
  593.         }
  594.       }      
  595.     }
  596.   }
  598.   // setting for 4x4 luma quantization offset
  599.   if( IS_INDEPENDENT(params) )
  600.   {
  601.     if( img->colour_plane_id == 0 )
  602.     {
  603.       ptLevelOffset4x4 = LevelOffset4x4Comp[0];
  604.     }
  605.     else if( img->colour_plane_id == 1 )
  606.     {
  607.       ptLevelOffset4x4   = LevelOffset4x4Comp[1];
  608.     }
  609.     else if( img->colour_plane_id == 2 )
  610.     {
  611.       ptLevelOffset4x4   = LevelOffset4x4Comp[2];
  612.     }
  613.   }
  614.   else
  615.   {
  616.     ptLevelOffset4x4 = LevelOffset4x4Comp[0];
  617.   }
  618. }
  620. /*!
  621.  ************************************************************************
  622.  * brief
  623.  *    Calculate the quantisation offset parameters
  624.  *
  625.  ************************************************************************
  626. */
  627. void CalculateOffset8Param ()
  628. {
  629.   int i, j, k, temp;
  630.   int q_bits, qp;
  632.   int max_qp_scale = imax(img->bitdepth_luma_qp_scale, img->bitdepth_chroma_qp_scale);
  633.   int max_qp = 51 + max_qp_scale;
  635.   if (img->type == I_SLICE || img->type == SI_SLICE )
  636.   {
  637.     for (qp = 0; qp < max_qp + 1; qp++)
  638.     {
  639.       q_bits = Q_BITS_8 + qp_per_matrix[qp] - OffsetBits;
  640.       k = params->AdaptRoundingFixed ? 0 : qp;
  641.       for (j = 0; j < 8; j++)
  642.       {
  643.         temp = (j << 3);
  644.         for (i = 0; i < 8; i++)
  645.         {          
  646.           // INTRA8X8
  647.           LevelOffset8x8Comp[0][1][qp][j][i] = (int) OffsetList8x8[k][0][temp] << q_bits;
  649.           // INTRA8X8 CHROMAU
  650.           LevelOffset8x8Comp[1][1][qp][j][i] = (int) OffsetList8x8[k][5][temp] << q_bits;
  652.           // INTRA8X8 CHROMAV
  653.           LevelOffset8x8Comp[2][1][qp][j][i] = (int) OffsetList8x8[k][10][temp++] << q_bits;
  654.         }
  655.       }
  656.     }
  657.   }
  658.   else if ((img->type == P_SLICE) || (img->type == SP_SLICE))
  659.   {
  660.     for (qp = 0; qp < max_qp + 1; qp++)
  661.     {
  662.       q_bits = Q_BITS_8 + qp_per_matrix[qp] - OffsetBits;
  663.       k = params->AdaptRoundingFixed ? 0 : qp;
  664.       for (j = 0; j < 8; j++)
  665.       {
  666.         temp = (j << 3);
  667.         for (i = 0; i < 8; i++)
  668.         {
  669.           // INTRA8X8
  670.           LevelOffset8x8Comp[0][1][qp][j][i] = (int) OffsetList8x8[k][1][temp] << q_bits;
  672.           // INTER8X8
  673.           LevelOffset8x8Comp[0][0][qp][j][i] = (int) OffsetList8x8[k][3][temp] << q_bits;
  675.           // INTRA8X8 CHROMAU
  676.           LevelOffset8x8Comp[1][1][qp][j][i] = (int) OffsetList8x8[k][6][temp] << q_bits;
  678.           // INTER8X8 CHROMAU
  679.           LevelOffset8x8Comp[1][0][qp][j][i] = (int) OffsetList8x8[k][8][temp] << q_bits;
  681.           // INTRA8X8 CHROMAV
  682.           LevelOffset8x8Comp[2][1][qp][j][i] = (int) OffsetList8x8[k][11][temp] << q_bits;
  684.           // INTER8X8 CHROMAV
  685.           LevelOffset8x8Comp[2][0][qp][j][i] = (int) OffsetList8x8[k][13][temp++] << q_bits;
  686.         }
  687.       }
  688.     }
  689.   }
  690.   else
  691.   {
  692.     for (qp = 0; qp < max_qp + 1; qp++)
  693.     {
  694.       q_bits = Q_BITS_8 + qp_per_matrix[qp] - OffsetBits;
  695.       k = params->AdaptRoundingFixed ? 0 : qp;
  696.       for (j = 0; j < 8; j++)
  697.       {
  698.         temp = (j << 3);
  699.         for (i = 0; i < 8; i++)
  700.         {
  701.           // INTRA8X8
  702.           LevelOffset8x8Comp[0][1][qp][j][i] = (int) OffsetList8x8[k][2][temp] << q_bits;
  703.           // INTER8X8
  704.           LevelOffset8x8Comp[0][0][qp][j][i] = (int) OffsetList8x8[k][4][temp] << q_bits;
  706.           // INTRA8X8 CHROMAU
  707.           LevelOffset8x8Comp[1][1][qp][j][i] = (int) OffsetList8x8[k][7][temp] << q_bits;
  709.           // INTER8X8 CHROMAU
  710.           LevelOffset8x8Comp[1][0][qp][j][i] = (int) OffsetList8x8[k][9][temp] << q_bits;
  712.           // INTRA8X8 CHROMAV
  713.           LevelOffset8x8Comp[2][1][qp][j][i] = (int) OffsetList8x8[k][12][temp] << q_bits;
  715.           // INTER8X8 CHROMAV
  716.           LevelOffset8x8Comp[2][0][qp][j][i] = (int) OffsetList8x8[k][14][temp++] << q_bits;
  717.         }
  718.       }
  719.     }
  720.   }
  722.   // setting for 8x8 luma quantization offset
  723.   if( IS_INDEPENDENT(params) )
  724.   {
  725.     if( img->colour_plane_id == 0 )
  726.     {
  727.       ptLevelOffset8x8 = LevelOffset8x8Comp[0];
  728.     }
  729.     else if( img->colour_plane_id == 1 )
  730.     {
  731.       ptLevelOffset8x8 = LevelOffset8x8Comp[1];
  732.     }
  733.     else if( img->colour_plane_id == 2 )
  734.     {
  735.       ptLevelOffset8x8 = LevelOffset8x8Comp[2];
  736.     }
  737.   }
  738.   else
  739.   {
  740.     ptLevelOffset8x8 = LevelOffset8x8Comp[0];
  741.   }
  742. }
  744. void SelectColorType (int colour_id)
  745. {
  746.   switch (colour_id)
  747.   {
  748.   case 0:
  749.   default:
  750.     ptLevelOffset8x8   = LevelOffset8x8Comp[0];
  751.     break;
  752.   case 1:
  753.     ptLevelOffset8x8   = LevelOffset8x8Comp[1];
  754.     break;
  755.   case 2:
  756.     ptLevelOffset8x8   = LevelOffset8x8Comp[2];
  757.     break;
  758.   }
  759. }