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

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

Audio

开发平台：

Visual C++

q_matrix.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file q_matrix.c
  5.  *
  6.  * brief
  7.  *    read q_matrix parameters from input file: q_matrix.cfg
  8.  *
  9.  *************************************************************************************
  10.  */
  12. #include "global.h"
  13. #include "memalloc.h"
  15. extern char *GetConfigFileContent (char *Filename, int error_type);
  17. #define MAX_ITEMS_TO_PARSE  1000
  19. const int quant_coef[6][4][4] = {
  20.   {{13107, 8066,13107, 8066},{ 8066, 5243, 8066, 5243},{13107, 8066,13107, 8066},{ 8066, 5243, 8066, 5243}},
  21.   {{11916, 7490,11916, 7490},{ 7490, 4660, 7490, 4660},{11916, 7490,11916, 7490},{ 7490, 4660, 7490, 4660}},
  22.   {{10082, 6554,10082, 6554},{ 6554, 4194, 6554, 4194},{10082, 6554,10082, 6554},{ 6554, 4194, 6554, 4194}},
  23.   {{ 9362, 5825, 9362, 5825},{ 5825, 3647, 5825, 3647},{ 9362, 5825, 9362, 5825},{ 5825, 3647, 5825, 3647}},
  24.   {{ 8192, 5243, 8192, 5243},{ 5243, 3355, 5243, 3355},{ 8192, 5243, 8192, 5243},{ 5243, 3355, 5243, 3355}},
  25.   {{ 7282, 4559, 7282, 4559},{ 4559, 2893, 4559, 2893},{ 7282, 4559, 7282, 4559},{ 4559, 2893, 4559, 2893}}
  26. };
  28. const int dequant_coef[6][4][4] = {
  29.   {{10, 13, 10, 13},{ 13, 16, 13, 16},{10, 13, 10, 13},{ 13, 16, 13, 16}},
  30.   {{11, 14, 11, 14},{ 14, 18, 14, 18},{11, 14, 11, 14},{ 14, 18, 14, 18}},
  31.   {{13, 16, 13, 16},{ 16, 20, 16, 20},{13, 16, 13, 16},{ 16, 20, 16, 20}},
  32.   {{14, 18, 14, 18},{ 18, 23, 18, 23},{14, 18, 14, 18},{ 18, 23, 18, 23}},
  33.   {{16, 20, 16, 20},{ 20, 25, 20, 25},{16, 20, 16, 20},{ 20, 25, 20, 25}},
  34.   {{18, 23, 18, 23},{ 23, 29, 23, 29},{18, 23, 18, 23},{ 23, 29, 23, 29}}
  35. };
  37. const int quant_coef8[6][8][8] =
  38. {
  39.   {
  40.     {13107, 12222,  16777,  12222,  13107,  12222,  16777,  12222},
  41.     {12222, 11428,  15481,  11428,  12222,  11428,  15481,  11428},
  42.     {16777, 15481,  20972,  15481,  16777,  15481,  20972,  15481},
  43.     {12222, 11428,  15481,  11428,  12222,  11428,  15481,  11428},
  44.     {13107, 12222,  16777,  12222,  13107,  12222,  16777,  12222},
  45.     {12222, 11428,  15481,  11428,  12222,  11428,  15481,  11428},
  46.     {16777, 15481,  20972,  15481,  16777,  15481,  20972,  15481},
  47.     {12222, 11428,  15481,  11428,  12222,  11428,  15481,  11428}
  48.   },
  49.   {
  50.     {11916, 11058,  14980,  11058,  11916,  11058,  14980,  11058},
  51.     {11058, 10826,  14290,  10826,  11058,  10826,  14290,  10826},
  52.     {14980, 14290,  19174,  14290,  14980,  14290,  19174,  14290},
  53.     {11058, 10826,  14290,  10826,  11058,  10826,  14290,  10826},
  54.     {11916, 11058,  14980,  11058,  11916,  11058,  14980,  11058},
  55.     {11058, 10826,  14290,  10826,  11058,  10826,  14290,  10826},
  56.     {14980, 14290,  19174,  14290,  14980,  14290,  19174,  14290},
  57.     {11058, 10826,  14290,  10826,  11058,  10826,  14290,  10826}
  58.   },
  59.   {
  60.     {10082, 9675, 12710,  9675, 10082,  9675, 12710,  9675},
  61.     {9675,  8943, 11985,  8943, 9675, 8943, 11985,  8943},
  62.     {12710, 11985,  15978,  11985,  12710,  11985,  15978,  11985},
  63.     {9675,  8943, 11985,  8943, 9675, 8943, 11985,  8943},
  64.     {10082, 9675, 12710,  9675, 10082,  9675, 12710,  9675},
  65.     {9675,  8943, 11985,  8943, 9675, 8943, 11985,  8943},
  66.     {12710, 11985,  15978,  11985,  12710,  11985,  15978,  11985},
  67.     {9675,  8943, 11985,  8943, 9675, 8943, 11985,  8943}
  68.   },
  69.   {
  70.     {9362,  8931, 11984,  8931, 9362, 8931, 11984,  8931},
  71.     {8931,  8228, 11259,  8228, 8931, 8228, 11259,  8228},
  72.     {11984, 11259,  14913,  11259,  11984,  11259,  14913,  11259},
  73.     {8931,  8228, 11259,  8228, 8931, 8228, 11259,  8228},
  74.     {9362,  8931, 11984,  8931, 9362, 8931, 11984,  8931},
  75.     {8931,  8228, 11259,  8228, 8931, 8228, 11259,  8228},
  76.     {11984, 11259,  14913,  11259,  11984,  11259,  14913,  11259},
  77.     {8931,  8228, 11259,  8228, 8931, 8228, 11259,  8228}
  78.   },
  79.   {
  80.     {8192,  7740, 10486,  7740, 8192, 7740, 10486,  7740},
  81.     {7740,  7346, 9777, 7346, 7740, 7346, 9777, 7346},
  82.     {10486, 9777, 13159,  9777, 10486,  9777, 13159,  9777},
  83.     {7740,  7346, 9777, 7346, 7740, 7346, 9777, 7346},
  84.     {8192,  7740, 10486,  7740, 8192, 7740, 10486,  7740},
  85.     {7740,  7346, 9777, 7346, 7740, 7346, 9777, 7346},
  86.     {10486, 9777, 13159,  9777, 10486,  9777, 13159,  9777},
  87.     {7740,  7346, 9777, 7346, 7740, 7346, 9777, 7346}
  88.   },
  89.   {
  90.     {7282,  6830, 9118, 6830, 7282, 6830, 9118, 6830},
  91.     {6830,  6428, 8640, 6428, 6830, 6428, 8640, 6428},
  92.     {9118,  8640, 11570,  8640, 9118, 8640, 11570,  8640},
  93.     {6830,  6428, 8640, 6428, 6830, 6428, 8640, 6428},
  94.     {7282,  6830, 9118, 6830, 7282, 6830, 9118, 6830},
  95.     {6830,  6428, 8640, 6428, 6830, 6428, 8640, 6428},
  96.     {9118,  8640, 11570,  8640, 9118, 8640, 11570,  8640},
  97.     {6830,  6428, 8640, 6428, 6830, 6428, 8640, 6428}
  98.   }
  99. };
  103. const int dequant_coef8[6][8][8] =
  104. {
  105.   {
  106.     {20,  19, 25, 19, 20, 19, 25, 19},
  107.     {19,  18, 24, 18, 19, 18, 24, 18},
  108.     {25,  24, 32, 24, 25, 24, 32, 24},
  109.     {19,  18, 24, 18, 19, 18, 24, 18},
  110.     {20,  19, 25, 19, 20, 19, 25, 19},
  111.     {19,  18, 24, 18, 19, 18, 24, 18},
  112.     {25,  24, 32, 24, 25, 24, 32, 24},
  113.     {19,  18, 24, 18, 19, 18, 24, 18}
  114.   },
  115.   {
  116.     {22,  21, 28, 21, 22, 21, 28, 21},
  117.     {21,  19, 26, 19, 21, 19, 26, 19},
  118.     {28,  26, 35, 26, 28, 26, 35, 26},
  119.     {21,  19, 26, 19, 21, 19, 26, 19},
  120.     {22,  21, 28, 21, 22, 21, 28, 21},
  121.     {21,  19, 26, 19, 21, 19, 26, 19},
  122.     {28,  26, 35, 26, 28, 26, 35, 26},
  123.     {21,  19, 26, 19, 21, 19, 26, 19}
  124.   },
  125.   {
  126.     {26,  24, 33, 24, 26, 24, 33, 24},
  127.     {24,  23, 31, 23, 24, 23, 31, 23},
  128.     {33,  31, 42, 31, 33, 31, 42, 31},
  129.     {24,  23, 31, 23, 24, 23, 31, 23},
  130.     {26,  24, 33, 24, 26, 24, 33, 24},
  131.     {24,  23, 31, 23, 24, 23, 31, 23},
  132.     {33,  31, 42, 31, 33, 31, 42, 31},
  133.     {24,  23, 31, 23, 24, 23, 31, 23}
  134.   },
  135.   {
  136.     {28,  26, 35, 26, 28, 26, 35, 26},
  137.     {26,  25, 33, 25, 26, 25, 33, 25},
  138.     {35,  33, 45, 33, 35, 33, 45, 33},
  139.     {26,  25, 33, 25, 26, 25, 33, 25},
  140.     {28,  26, 35, 26, 28, 26, 35, 26},
  141.     {26,  25, 33, 25, 26, 25, 33, 25},
  142.     {35,  33, 45, 33, 35, 33, 45, 33},
  143.     {26,  25, 33, 25, 26, 25, 33, 25}
  144.   },
  145.   {
  146.     {32,  30, 40, 30, 32, 30, 40, 30},
  147.     {30,  28, 38, 28, 30, 28, 38, 28},
  148.     {40,  38, 51, 38, 40, 38, 51, 38},
  149.     {30,  28, 38, 28, 30, 28, 38, 28},
  150.     {32,  30, 40, 30, 32, 30, 40, 30},
  151.     {30,  28, 38, 28, 30, 28, 38, 28},
  152.     {40,  38, 51, 38, 40, 38, 51, 38},
  153.     {30,  28, 38, 28, 30, 28, 38, 28}
  154.   },
  155.   {
  156.     {36,  34, 46, 34, 36, 34, 46, 34},
  157.     {34,  32, 43, 32, 34, 32, 43, 32},
  158.     {46,  43, 58, 43, 46, 43, 58, 43},
  159.     {34,  32, 43, 32, 34, 32, 43, 32},
  160.     {36,  34, 46, 34, 36, 34, 46, 34},
  161.     {34,  32, 43, 32, 34, 32, 43, 32},
  162.     {46,  43, 58, 43, 46, 43, 58, 43},
  163.     {34,  32, 43, 32, 34, 32, 43, 32}
  164.   }
  165. };
  168. int matrix4x4_check[6] = {0, 0, 0, 0, 0, 0};
  169. int matrix8x8_check[6] = {0, 0, 0, 0, 0, 0};
  171. static const char MatrixType4x4[6][20] =
  172. {
  173.   "INTRA4X4_LUMA",
  174.   "INTRA4X4_CHROMAU",
  175.   "INTRA4X4_CHROMAV",
  176.   "INTER4X4_LUMA",
  177.   "INTER4X4_CHROMAU",
  178.   "INTER4X4_CHROMAV"
  179. };
  181. static const char MatrixType8x8[6][20] =
  182. {
  183.   "INTRA8X8_LUMA",
  184.   "INTER8X8_LUMA",
  185.   "INTRA8X8_CHROMAU",  // only for 4:4:4
  186.   "INTER8X8_CHROMAU",  // only for 4:4:4
  187.   "INTRA8X8_CHROMAV",  // only for 4:4:4
  188.   "INTER8X8_CHROMAV"   // only for 4:4:4
  189. };
  191. int *****LevelScale4x4Comp;
  192. int *****LevelScale8x8Comp;
  194. int *****InvLevelScale4x4Comp;
  195. int *****InvLevelScale8x8Comp;
  197. short ScalingList4x4input[6][16];
  198. short ScalingList8x8input[6][64];
  199. short ScalingList4x4[6][16];
  200. short ScalingList8x8[6][64];
  202. short UseDefaultScalingMatrix4x4Flag[6];
  203. short UseDefaultScalingMatrix8x8Flag[6];
  205. int *qp_per_matrix;
  206. int *qp_rem_matrix;
  208. static const short Quant_intra_default[16] =
  209. {
  210.  6,13,20,28,
  211. 13,20,28,32,
  212. 20,28,32,37,
  213. 28,32,37,42
  214. };
  216. static const short Quant_inter_default[16] =
  217. {
  218. 10,14,20,24,
  219. 14,20,24,27,
  220. 20,24,27,30,
  221. 24,27,30,34
  222. };
  224. static const short Quant8_intra_default[64] =
  225. {
  226.  6,10,13,16,18,23,25,27,
  227. 10,11,16,18,23,25,27,29,
  228. 13,16,18,23,25,27,29,31,
  229. 16,18,23,25,27,29,31,33,
  230. 18,23,25,27,29,31,33,36,
  231. 23,25,27,29,31,33,36,38,
  232. 25,27,29,31,33,36,38,40,
  233. 27,29,31,33,36,38,40,42
  234. };
  236. static const short Quant8_inter_default[64] =
  237. {
  238.  9,13,15,17,19,21,22,24,
  239. 13,13,17,19,21,22,24,25,
  240. 15,17,19,21,22,24,25,27,
  241. 17,19,21,22,24,25,27,28,
  242. 19,21,22,24,25,27,28,30,
  243. 21,22,24,25,27,28,30,32,
  244. 22,24,25,27,28,30,32,33,
  245. 24,25,27,28,30,32,33,35
  246. };
  249. /*!
  250.  ***********************************************************************
  251.  * brief
  252.  *    Check the parameter name.
  253.  * param s
  254.  *    parameter name string
  255.  * param type
  256.  *    4x4 or 8x8 matrix type
  257.  * return
  258.  *    the index number if the string is a valid parameter name,         n
  259.  *    -1 for error
  260.  ***********************************************************************
  261.  */
  262. int CheckParameterName (char *s, int *type)
  263. {
  264.   int i = 0;
  266.   *type = 0;
  267.   while ((MatrixType4x4[i] != NULL) && (i<6))
  268.   {
  269.     if (0==strcmp (MatrixType4x4[i], s))
  270.       return i;
  271.     else
  272.       i++;
  273.   }
  275.   i = 0;
  276.   *type = 1;
  277.   while ((MatrixType8x8[i] != NULL) && (i<6))
  278.   {
  279.     if (0==strcmp (MatrixType8x8[i], s))
  280.       return i;
  281.     else
  282.       i++;
  283.   }
  285.   return -1;
  286. }
  288. /*!
  289.  ***********************************************************************
  290.  * brief
  291.  *    Parse the Q matrix values read from cfg file.
  292.  * param buf
  293.  *    buffer to be parsed
  294.  * param bufsize
  295.  *    buffer size of buffer
  296.  ***********************************************************************
  297.  */
  298. void ParseMatrix (char *buf, int bufsize)
  299. {
  300.   char *items[MAX_ITEMS_TO_PARSE];
  301.   int MapIdx;
  302.   int item = 0;
  303.   int InString = 0, InItem = 0;
  304.   char *p = buf;
  305.   char *bufend = &buf[bufsize];
  306.   int IntContent;
  307.   int i, j, range, type, cnt;
  308.   short *ScalingList;
  310.   while (p < bufend)
  311.   {
  312.     switch (*p)
  313.     {
  314.       case 13:
  315.         p++;
  316.         break;
  317.       case '#':                 // Found comment
  318.         *p = '';              // Replace '#' with '' in case of comment immediately following integer or string
  319.         while (*p != 'n' && p < bufend)  // Skip till EOL or EOF, whichever comes first
  320.           p++;
  321.         InString = 0;
  322.         InItem = 0;
  323.         break;
  324.       case 'n':
  325.         InItem = 0;
  326.         InString = 0;
  327.         *p++='';
  328.         break;
  329.       case ' ':
  330.       case 't':              // Skip whitespace, leave state unchanged
  331.         if (InString)
  332.           p++;
  333.         else
  334.         {                     // Terminate non-strings once whitespace is found
  335.           *p++ = '';
  336.           InItem = 0;
  337.         }
  338.         break;
  340.       case '"':               // Begin/End of String
  341.         *p++ = '';
  342.         if (!InString)
  343.         {
  344.           items[item++] = p;
  345.           InItem = ~InItem;
  346.         }
  347.         else
  348.           InItem = 0;
  349.         InString = ~InString; // Toggle
  350.         break;
  352.       case ',':
  353.         p++;
  354.         InItem = 0;
  355.         break;
  357.       default:
  358.         if (!InItem)
  359.         {
  360.           items[item++] = p;
  361.           InItem = ~InItem;
  362.         }
  363.         p++;
  364.     }
  365.   }
  367.   item--;
  369.   for (i=0; i<item; i+=cnt)
  370.   {
  371.     cnt=0;
  372.     if (0 > (MapIdx = CheckParameterName (items[i+cnt], &type)))
  373.     {
  374.       snprintf (errortext, ET_SIZE, " Parsing error in config file: Parameter Name '%s' not recognized.", items[i+cnt]);
  375.       error (errortext, 300);
  376.     }
  377.     cnt++;
  378.     if (strcmp ("=", items[i+cnt]))
  379.     {
  380.       snprintf (errortext, ET_SIZE, " Parsing error in config file: '=' expected as the second token in each item.");
  381.       error (errortext, 300);
  382.     }
  383.     cnt++;
  385.     if (!type) //4x4 Matrix
  386.     {
  387.       range = 16;
  388.       ScalingList = ScalingList4x4input[MapIdx];
  389.       matrix4x4_check[MapIdx] = 1; //to indicate matrix found in cfg file
  390.     }
  391.     else //8x8 matrix
  392.     {
  393.       range = 64;
  394.       ScalingList = ScalingList8x8input[MapIdx];
  395.       matrix8x8_check[MapIdx] = 1; //to indicate matrix found in cfg file
  396.     }
  398.     for(j=0; j<range; j++)
  399.     {
  400.       if (1 != sscanf (items[i+cnt+j], "%d", &IntContent))
  401.       {
  402.         snprintf (errortext, ET_SIZE, " Parsing error: Expected numerical value for Parameter of %s, found '%s'.", items[i], items[i+cnt+j]);
  403.         error (errortext, 300);
  404.       }
  406.       ScalingList[j] = (short)IntContent; //save value in matrix
  407.     }
  408.     cnt+=j;
  409.     printf (".");
  410.   }
  411. }
  413. /*!
  414.  ***********************************************************************
  415.  * brief
  416.  *    Check Q Matrix values. If invalid values found in matrix,
  417.  *    whole matrix will be patch with default value 16.
  418.  ***********************************************************************
  419.  */
  420. void PatchMatrix(void)
  421. {
  422.   short *ScalingList;
  423.   int i, cnt, fail;
  425.   for(i=0; i<6; i++)
  426.   {
  427.     if(params->ScalingListPresentFlag[i])
  428.     {
  429.       ScalingList=ScalingList4x4input[i];
  430.       if(matrix4x4_check[i])
  431.       {
  432.         fail=0;
  433.         for(cnt=0; cnt<16; cnt++)
  434.         {
  435.           if(ScalingList[cnt]<0 || ScalingList[cnt]>255) // ScalingList[0]=0 to indicate use default matrix
  436.           {
  437.             fail=1;
  438.             break;
  439.           }
  440.         }
  442.         if(fail) //value of matrix exceed range
  443.         {
  444.           printf("n%s value exceed range. (Value must be 1 to 255)n", MatrixType4x4[i]);
  445.           printf("Setting default values for this matrix.");
  446.           if(i>2)
  447.             memcpy(ScalingList, Quant_inter_default, sizeof(short)*16);
  448.           else
  449.             memcpy(ScalingList, Quant_intra_default, sizeof(short)*16);
  450.         }
  451.       }
  452.       else //matrix not found, pad with default value
  453.       {
  454.         printf("n%s matrix definition not found. Setting default values.", MatrixType4x4[i]);
  455.         if(i>2)
  456.           memcpy(ScalingList, Quant_inter_default, sizeof(short)*16);
  457.         else
  458.           memcpy(ScalingList, Quant_intra_default, sizeof(short)*16);
  459.       }
  460.     }
  462.     if(params->ScalingListPresentFlag[i+6])
  463.     {
  464.       ScalingList=ScalingList8x8input[i];
  465.       if(matrix8x8_check[i])
  466.       {
  467.         fail=0;
  468.         for(cnt=0; cnt<64; cnt++)
  469.         {
  470.           if(ScalingList[cnt]<0 || ScalingList[cnt]>255) // ScalingList[0]=0 to indicate use default matrix
  471.           {
  472.             fail=1;
  473.             break;
  474.           }
  475.         }
  477.         if(fail) //value of matrix exceed range
  478.         {
  479.           printf("n%s value exceed range. (Value must be 1 to 255)n", MatrixType8x8[i]);
  480.           printf("Setting default values for this matrix.");
  481.           if(i==1 || i==3 || i==5)
  482.             memcpy(ScalingList, Quant8_inter_default, sizeof(short)*64);
  483.           else
  484.             memcpy(ScalingList, Quant8_intra_default, sizeof(short)*64);
  485.         }
  486.       }
  487.       else //matrix not found, pad with default value
  488.       {
  489.         printf("n%s matrix definition not found. Setting default values.", MatrixType8x8[i]);
  490.         if(i==1 || i==3 || i==5)
  491.           memcpy(ScalingList, Quant8_inter_default, sizeof(short)*64);
  492.         else
  493.           memcpy(ScalingList, Quant8_intra_default, sizeof(short)*64);
  494.       }
  495.     }
  496.   }
  497. }
  499. /*!
  500.  ***********************************************************************
  501.  * brief
  502.  *    Allocate Q matrix arrays
  503.  ***********************************************************************
  504.  */
  505. void allocate_QMatrix (void)
  506. {
  507.   int bitdepth_qp_scale = 6*(params->output.bit_depth[0] - 8);
  508.   int i;
  510.   if ((qp_per_matrix = (int*)malloc((MAX_QP + 1 +  bitdepth_qp_scale)*sizeof(int))) == NULL)
  511.     no_mem_exit("init_global_buffers: qp_per_matrix");
  512.   if ((qp_rem_matrix = (int*)malloc((MAX_QP + 1 +  bitdepth_qp_scale)*sizeof(int))) == NULL)
  513.     no_mem_exit("init_global_buffers: qp_per_matrix");
  515.   for (i = 0; i < MAX_QP + bitdepth_qp_scale + 1; i++)
  516.   {
  517.     qp_per_matrix[i] = i / 6;
  518.     qp_rem_matrix[i] = i % 6;
  519.   }
  521.   get_mem5Dint(&LevelScale4x4Comp,    3, 2, 6, 4, 4);
  522.   get_mem5Dint(&LevelScale8x8Comp,    3, 2, 6, 8, 8);
  524.   get_mem5Dint(&InvLevelScale4x4Comp, 3, 2, 6, 4, 4);
  525.   get_mem5Dint(&InvLevelScale8x8Comp, 3, 2, 6, 8, 8);
  526. }
  528. /*!
  529.  ***********************************************************************
  530.  * brief
  531.  *    Free Q matrix arrays
  532.  ***********************************************************************
  533.  */
  534. void free_QMatrix ()
  535. {
  536.   free(qp_rem_matrix);
  537.   free(qp_per_matrix);
  539.   free_mem5Dint(LevelScale4x4Comp);
  540.   free_mem5Dint(LevelScale8x8Comp);
  542.   free_mem5Dint(InvLevelScale4x4Comp);
  543.   free_mem5Dint(InvLevelScale8x8Comp);
  544. }
  547. /*!
  548.  ***********************************************************************
  549.  * brief
  550.  *    Initialise Q matrix values.
  551.  ***********************************************************************
  552.  */
  553. void Init_QMatrix (void)
  554. {
  555.   char *content;
  558.   allocate_QMatrix ();
  560.   if(params->ScalingMatrixPresentFlag)
  561.   {
  562.     printf ("Parsing QMatrix file %s ", params->QmatrixFile);
  563.     content = GetConfigFileContent(params->QmatrixFile, 0);
  564.     if(content!='')
  565.       ParseMatrix(content, strlen (content));
  566.     else
  567.       printf("nError: %snProceeding with default values for all matrices.", errortext);
  569.     PatchMatrix();
  570.     printf("n");
  572.     memset(UseDefaultScalingMatrix4x4Flag, 0, 6 * sizeof(short));
  573.     memset(UseDefaultScalingMatrix8x8Flag, 0, 6 * sizeof(short));
  575.     free(content);
  576.   }
  577. }
  579. /*!
  580.  ************************************************************************
  581.  * brief
  582.  *    For calculating the quantisation values at frame level
  583.  *
  584.  * par Input:
  585.  *    none
  586.  *
  587.  * par Output:
  588.  *    none
  589.  ************************************************************************
  590.  */
  591. void CalculateQuantParam(void)
  592. {
  593.   int i, j, k, temp;
  594.   int present[6];
  595.   int no_q_matrix=FALSE;
  597.   if(!active_sps->seq_scaling_matrix_present_flag && !active_pps->pic_scaling_matrix_present_flag) //set to no q-matrix
  598.     no_q_matrix=TRUE;
  599.   else
  600.   {
  601.     memset(present, 0, 6 * sizeof(int));
  603.     if(active_sps->seq_scaling_matrix_present_flag)
  604.       for(i=0; i<6; i++)
  605.         present[i] = active_sps->seq_scaling_list_present_flag[i];
  607.     if(active_pps->pic_scaling_matrix_present_flag)
  608.       for(i=0; i<6; i++)
  609.       {
  610.         if((i==0) || (i==3))
  611.           present[i] |= active_pps->pic_scaling_list_present_flag[i];
  612.         else
  613.           present[i] = active_pps->pic_scaling_list_present_flag[i];
  614.       }
  615.   }
  617.   if(no_q_matrix==TRUE)
  618.   {
  619.     for(k=0; k<6; k++)
  620.       for(j=0; j<4; j++)
  621.         for(i=0; i<4; i++)
  622.         {
  623.           LevelScale4x4Comp[0][1][k][j][i]    = quant_coef[k][j][i];
  624.           InvLevelScale4x4Comp[0][1][k][j][i] = dequant_coef[k][j][i]<<4;
  626.           LevelScale4x4Comp[1][1][k][j][i]    = quant_coef[k][j][i];
  627.           InvLevelScale4x4Comp[1][1][k][j][i] = dequant_coef[k][j][i]<<4;
  629.           LevelScale4x4Comp[2][1][k][j][i]    = quant_coef[k][j][i];
  630.           InvLevelScale4x4Comp[2][1][k][j][i] = dequant_coef[k][j][i]<<4;
  632.           // Inter
  633.           LevelScale4x4Comp[0][0][k][j][i]    = quant_coef[k][j][i];
  634.           InvLevelScale4x4Comp[0][0][k][j][i] = dequant_coef[k][j][i]<<4;
  636.           LevelScale4x4Comp[1][0][k][j][i]    = quant_coef[k][j][i];
  637.           InvLevelScale4x4Comp[1][0][k][j][i] = dequant_coef[k][j][i]<<4;
  639.           LevelScale4x4Comp[2][0][k][j][i]    = quant_coef[k][j][i];
  640.           InvLevelScale4x4Comp[2][0][k][j][i] = dequant_coef[k][j][i]<<4;
  641.         }
  642.   }
  643.   else
  644.   {
  645.     for(k=0; k<6; k++)
  646.     {
  647.       for(j=0; j<4; j++)
  648.       {
  649.         for(i=0; i<4; i++)
  650.         {
  651.           temp = (j<<2)+i;
  652.           if((!present[0]) || UseDefaultScalingMatrix4x4Flag[0])
  653.           {
  654.             LevelScale4x4Comp[0][1][k][j][i]         = (quant_coef[k][j][i]<<4)/Quant_intra_default[temp];
  655.             InvLevelScale4x4Comp[0][1][k][j][i]      = dequant_coef[k][j][i]*Quant_intra_default[temp];
  656.           }
  657.           else
  658.           {
  659.             LevelScale4x4Comp[0][1][k][j][i]         = (quant_coef[k][j][i]<<4)/ScalingList4x4[0][temp];
  660.             InvLevelScale4x4Comp[0][1][k][j][i]      = dequant_coef[k][j][i]*ScalingList4x4[0][temp];
  661.           }
  663.           if(!present[1])
  664.           {
  665.             LevelScale4x4Comp[1][1][k][j][i]    = LevelScale4x4Comp[0][1][k][j][i];
  666.             InvLevelScale4x4Comp[1][1][k][j][i] = InvLevelScale4x4Comp[0][1][k][j][i];
  667.           }
  668.           else
  669.           {
  670.             LevelScale4x4Comp[1][1][k][j][i]    = (quant_coef[k][j][i]<<4)/(UseDefaultScalingMatrix4x4Flag[1] ? Quant_intra_default[temp]:ScalingList4x4[1][temp]);
  671.             InvLevelScale4x4Comp[1][1][k][j][i] = dequant_coef[k][j][i]*(UseDefaultScalingMatrix4x4Flag[1] ? Quant_intra_default[temp]:ScalingList4x4[1][temp]);
  672.           }
  674.           if(!present[2])
  675.           {
  676.             LevelScale4x4Comp[2][1][k][j][i]    = LevelScale4x4Comp[1][1][k][j][i];
  677.             InvLevelScale4x4Comp[2][1][k][j][i] = InvLevelScale4x4Comp[1][1][k][j][i];
  678.           }
  679.           else
  680.           {
  681.             LevelScale4x4Comp[2][1][k][j][i]    = (quant_coef[k][j][i]<<4)/(UseDefaultScalingMatrix4x4Flag[2] ? Quant_intra_default[temp]:ScalingList4x4[2][temp]);
  682.             InvLevelScale4x4Comp[2][1][k][j][i] = dequant_coef[k][j][i]*(UseDefaultScalingMatrix4x4Flag[2] ? Quant_intra_default[temp]:ScalingList4x4[2][temp]);
  683.           }
  685.           if((!present[3]) || UseDefaultScalingMatrix4x4Flag[3])
  686.           {
  687.             LevelScale4x4Comp[0][0][k][j][i]         = (quant_coef[k][j][i]<<4)/Quant_inter_default[temp];
  688.             InvLevelScale4x4Comp[0][0][k][j][i]      = dequant_coef[k][j][i]*Quant_inter_default[temp];
  689.           }
  690.           else
  691.           {
  692.             LevelScale4x4Comp[0][0][k][j][i]         = (quant_coef[k][j][i]<<4)/ScalingList4x4[3][temp];
  693.             InvLevelScale4x4Comp[0][0][k][j][i]      = dequant_coef[k][j][i]*ScalingList4x4[3][temp];
  694.           }
  696.           if(!present[4])
  697.           {
  698.             LevelScale4x4Comp[1][0][k][j][i]    = LevelScale4x4Comp[0][0][k][j][i];
  699.             InvLevelScale4x4Comp[1][0][k][j][i] = InvLevelScale4x4Comp[0][0][k][j][i];
  700.           }
  701.           else
  702.           {
  703.             LevelScale4x4Comp[1][0][k][j][i]    = (quant_coef[k][j][i]<<4)/(UseDefaultScalingMatrix4x4Flag[4] ? Quant_inter_default[temp]:ScalingList4x4[4][temp]);
  704.             InvLevelScale4x4Comp[1][0][k][j][i] = dequant_coef[k][j][i]*(UseDefaultScalingMatrix4x4Flag[4] ? Quant_inter_default[temp]:ScalingList4x4[4][temp]);
  705.           }
  707.           if(!present[5])
  708.           {
  709.             LevelScale4x4Comp[2][0][k][j][i]    = LevelScale4x4Comp[1][0][k][j][i];
  710.             InvLevelScale4x4Comp[2][0][k][j][i] = InvLevelScale4x4Comp[1][0][k][j][i];
  711.           }
  712.           else
  713.           {
  714.             LevelScale4x4Comp[2][0][k][j][i]    = (quant_coef[k][j][i]<<4)/(UseDefaultScalingMatrix4x4Flag[5] ? Quant_inter_default[temp]:ScalingList4x4[5][temp]);
  715.             InvLevelScale4x4Comp[2][0][k][j][i] = dequant_coef[k][j][i]*(UseDefaultScalingMatrix4x4Flag[5] ? Quant_inter_default[temp]:ScalingList4x4[5][temp]);
  716.           }
  717.         }
  718.       }
  719.     }
  720.   }
  721. }
  723. /*!
  724.  ************************************************************************
  725.  * brief
  726.  *    Calculate the quantisation and inverse quantisation parameters
  727.  *
  728.  ************************************************************************
  729.  */
  730. void CalculateQuant8Param()
  731. {
  732.   int i, j, k, temp;
  733.   int n_ScalingList8x8;
  734.   int present[6];
  735.   int no_q_matrix=FALSE;
  737.   // maximum number of valid 8x8 scaling lists
  738.   n_ScalingList8x8 = ( active_sps->chroma_format_idc != 3 ) ? 2 : 6;
  740.   if(!active_sps->seq_scaling_matrix_present_flag && !active_pps->pic_scaling_matrix_present_flag) //set to default matrix
  741.     no_q_matrix=TRUE;
  742.   else
  743.   {
  744.     memset(present, 0, sizeof(int)*n_ScalingList8x8);
  746.     if(active_sps->seq_scaling_matrix_present_flag)
  747.       for(i=0; i<n_ScalingList8x8; i++)
  748.         present[i] = active_sps->seq_scaling_list_present_flag[i+6];
  750.       if(active_pps->pic_scaling_matrix_present_flag)
  751.         for(i=0; i<n_ScalingList8x8; i++)
  752.         {
  753.           if( i==0 || i==1 )
  754.             present[i] |= active_pps->pic_scaling_list_present_flag[i+6];
  755.           else
  756.             present[i] = active_pps->pic_scaling_list_present_flag[i+6];
  757.         }
  758.   }
  760.   if(no_q_matrix==TRUE)
  761.   {
  762.     for(k=0; k<6; k++)
  763.       for(j=0; j<8; j++)
  764.         for(i=0; i<8; i++)
  765.         {
  766.           // intra Y
  767.           LevelScale8x8Comp[0][1][k][j][i]      = quant_coef8[k][j][i];
  768.           InvLevelScale8x8Comp[0][1][k][j][i]   = dequant_coef8[k][j][i]<<4;
  770.           // inter Y
  771.           LevelScale8x8Comp[0][0][k][j][i]      = quant_coef8[k][j][i];
  772.           InvLevelScale8x8Comp[0][0][k][j][i]   = dequant_coef8[k][j][i]<<4;
  774.           if( n_ScalingList8x8 > 2 )  // 4:4:4 case only
  775.           {
  776.             // intra U
  777.             LevelScale8x8Comp[1][1][k][j][i]    = quant_coef8[k][j][i];
  778.             InvLevelScale8x8Comp[1][1][k][j][i] = dequant_coef8[k][j][i]<<4;
  780.             // intra V
  781.             LevelScale8x8Comp[2][1][k][j][i]    = quant_coef8[k][j][i];
  782.             InvLevelScale8x8Comp[2][1][k][j][i] = dequant_coef8[k][j][i]<<4;
  784.             // inter U
  785.             LevelScale8x8Comp[1][0][k][j][i]    = quant_coef8[k][j][i];
  786.             InvLevelScale8x8Comp[1][0][k][j][i] = dequant_coef8[k][j][i]<<4;
  788.             // inter V
  789.             LevelScale8x8Comp[2][0][k][j][i]    = quant_coef8[k][j][i];
  790.             InvLevelScale8x8Comp[2][0][k][j][i] = dequant_coef8[k][j][i]<<4;
  792.           }
  793.         }
  794.   }
  795.   else
  796.   {
  797.     for(k=0; k<6; k++)
  798.       for(j=0; j<8; j++)
  799.         for(i=0; i<8; i++)
  800.         {
  801.           temp = (j<<3)+i;
  802.           if((!present[0]) || UseDefaultScalingMatrix8x8Flag[0])
  803.           {
  804.             LevelScale8x8Comp[0][1][k][j][i]    = (quant_coef8[k][j][i]<<4)/Quant8_intra_default[temp];
  805.             InvLevelScale8x8Comp[0][1][k][j][i] = dequant_coef8[k][j][i]*Quant8_intra_default[temp];
  806.           }
  807.           else
  808.           {
  809.             LevelScale8x8Comp[0][1][k][j][i]    = (quant_coef8[k][j][i]<<4)/ScalingList8x8[0][temp];
  810.             InvLevelScale8x8Comp[0][1][k][j][i] = dequant_coef8[k][j][i]*ScalingList8x8[0][temp];
  811.           }
  813.           if((!present[1]) || UseDefaultScalingMatrix8x8Flag[1])
  814.           {
  815.             LevelScale8x8Comp[0][0][k][j][i]    = (quant_coef8[k][j][i]<<4)/Quant8_inter_default[temp];
  816.             InvLevelScale8x8Comp[0][0][k][j][i] = dequant_coef8[k][j][i]*Quant8_inter_default[temp];
  817.           }
  818.           else
  819.           {
  820.             LevelScale8x8Comp[0][0][k][j][i]    = (quant_coef8[k][j][i]<<4)/ScalingList8x8[1][temp];
  821.             InvLevelScale8x8Comp[0][0][k][j][i] = dequant_coef8[k][j][i]*ScalingList8x8[1][temp];
  822.           }
  824.           if( n_ScalingList8x8 > 2 )
  825.           {
  827.             // Intra U
  828.             if(!present[2])
  829.             {
  830.               LevelScale8x8Comp[1][1][k][j][i]    = LevelScale8x8Comp[0][1][k][j][i];
  831.               InvLevelScale8x8Comp[1][1][k][j][i] = InvLevelScale8x8Comp[0][1][k][j][i];
  832.             }
  833.             else
  834.             {
  835.               LevelScale8x8Comp[1][1][k][j][i]    = (quant_coef8[k][j][i]<<4)/(UseDefaultScalingMatrix8x8Flag[2] ? Quant8_intra_default[temp]:ScalingList8x8[2][temp]);
  836.               InvLevelScale8x8Comp[1][1][k][j][i] = dequant_coef8[k][j][i]*(UseDefaultScalingMatrix8x8Flag[2] ? Quant8_intra_default[temp]:ScalingList8x8[2][temp]);
  837.             }
  839.             // Inter U
  840.             if(!present[3])
  841.             {
  842.               LevelScale8x8Comp[1][0][k][j][i]    = LevelScale8x8Comp[0][0][k][j][i];
  843.               InvLevelScale8x8Comp[1][0][k][j][i] = InvLevelScale8x8Comp[0][0][k][j][i];
  844.             }
  845.             else
  846.             {
  847.               LevelScale8x8Comp[1][0][k][j][i]    = (quant_coef8[k][j][i]<<4)/(UseDefaultScalingMatrix8x8Flag[3] ? Quant8_inter_default[temp]:ScalingList8x8[3][temp]);
  848.               InvLevelScale8x8Comp[1][0][k][j][i] = dequant_coef8[k][j][i]*(UseDefaultScalingMatrix8x8Flag[3] ? Quant8_inter_default[temp]:ScalingList8x8[3][temp]);
  849.             }
  851.             // Intra V
  852.             if(!present[4])
  853.             {
  854.               LevelScale8x8Comp[2][1][k][j][i]    = LevelScale8x8Comp[1][1][k][j][i];
  855.               InvLevelScale8x8Comp[2][1][k][j][i] = InvLevelScale8x8Comp[1][1][k][j][i];
  856.             }
  857.             else
  858.             {
  859.               LevelScale8x8Comp[2][1][k][j][i]    = (quant_coef8[k][j][i]<<4)/(UseDefaultScalingMatrix8x8Flag[4] ? Quant8_intra_default[temp]:ScalingList8x8[4][temp]);
  860.               InvLevelScale8x8Comp[2][1][k][j][i] = dequant_coef8[k][j][i]*(UseDefaultScalingMatrix8x8Flag[4] ? Quant8_intra_default[temp]:ScalingList8x8[4][temp]);
  861.             }
  863.             // Inter V
  864.             if(!present[5])
  865.             {
  866.               LevelScale8x8Comp[2][0][k][j][i]    = LevelScale8x8Comp[1][0][k][j][i];
  867.               InvLevelScale8x8Comp[2][0][k][j][i] = InvLevelScale8x8Comp[1][0][k][j][i];
  868.             }
  869.             else
  870.             {
  871.               LevelScale8x8Comp[2][0][k][j][i]    = (quant_coef8[k][j][i]<<4)/(UseDefaultScalingMatrix8x8Flag[5] ? Quant8_inter_default[temp]:ScalingList8x8[5][temp]);
  872.               InvLevelScale8x8Comp[2][0][k][j][i] = dequant_coef8[k][j][i]*(UseDefaultScalingMatrix8x8Flag[5] ? Quant8_inter_default[temp]:ScalingList8x8[5][temp]);
  873.             }
  875.           }
  876.         }
  877.   }
  878. }