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

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

Audio

开发平台：

Visual C++

quant.c：源码内容
  2. /*!
  3.  ***********************************************************************
  4.  *  file
  5.  *      quant.c
  6.  *
  7.  *  brief
  8.  *      Quantization functions
  9.  *
  10.  *  author
  11.  *      Main contributors (see contributors.h for copyright, address and affiliation details)
  12.  *
  13.  ***********************************************************************
  14.  */
  16. #include "contributors.h"
  18. #include "global.h"
  19. #include "memalloc.h"
  20. #include "block.h"
  21. #include "image.h"
  22. #include "mb_access.h"
  23. #include "transform.h"
  24. #include "quant.h"
  26. const int dequant_coef8[6][8][8] =
  27. {
  28.   {
  29.     {20,  19, 25, 19, 20, 19, 25, 19},
  30.     {19,  18, 24, 18, 19, 18, 24, 18},
  31.     {25,  24, 32, 24, 25, 24, 32, 24},
  32.     {19,  18, 24, 18, 19, 18, 24, 18},
  33.     {20,  19, 25, 19, 20, 19, 25, 19},
  34.     {19,  18, 24, 18, 19, 18, 24, 18},
  35.     {25,  24, 32, 24, 25, 24, 32, 24},
  36.     {19,  18, 24, 18, 19, 18, 24, 18}
  37.   },
  38.   {
  39.     {22,  21, 28, 21, 22, 21, 28, 21},
  40.     {21,  19, 26, 19, 21, 19, 26, 19},
  41.     {28,  26, 35, 26, 28, 26, 35, 26},
  42.     {21,  19, 26, 19, 21, 19, 26, 19},
  43.     {22,  21, 28, 21, 22, 21, 28, 21},
  44.     {21,  19, 26, 19, 21, 19, 26, 19},
  45.     {28,  26, 35, 26, 28, 26, 35, 26},
  46.     {21,  19, 26, 19, 21, 19, 26, 19}
  47.   },
  48.   {
  49.     {26,  24, 33, 24, 26, 24, 33, 24},
  50.     {24,  23, 31, 23, 24, 23, 31, 23},
  51.     {33,  31, 42, 31, 33, 31, 42, 31},
  52.     {24,  23, 31, 23, 24, 23, 31, 23},
  53.     {26,  24, 33, 24, 26, 24, 33, 24},
  54.     {24,  23, 31, 23, 24, 23, 31, 23},
  55.     {33,  31, 42, 31, 33, 31, 42, 31},
  56.     {24,  23, 31, 23, 24, 23, 31, 23}
  57.   },
  58.   {
  59.     {28,  26, 35, 26, 28, 26, 35, 26},
  60.     {26,  25, 33, 25, 26, 25, 33, 25},
  61.     {35,  33, 45, 33, 35, 33, 45, 33},
  62.     {26,  25, 33, 25, 26, 25, 33, 25},
  63.     {28,  26, 35, 26, 28, 26, 35, 26},
  64.     {26,  25, 33, 25, 26, 25, 33, 25},
  65.     {35,  33, 45, 33, 35, 33, 45, 33},
  66.     {26,  25, 33, 25, 26, 25, 33, 25}
  67.   },
  68.   {
  69.     {32,  30, 40, 30, 32, 30, 40, 30},
  70.     {30,  28, 38, 28, 30, 28, 38, 28},
  71.     {40,  38, 51, 38, 40, 38, 51, 38},
  72.     {30,  28, 38, 28, 30, 28, 38, 28},
  73.     {32,  30, 40, 30, 32, 30, 40, 30},
  74.     {30,  28, 38, 28, 30, 28, 38, 28},
  75.     {40,  38, 51, 38, 40, 38, 51, 38},
  76.     {30,  28, 38, 28, 30, 28, 38, 28}
  77.   },
  78.   {
  79.     {36,  34, 46, 34, 36, 34, 46, 34},
  80.     {34,  32, 43, 32, 34, 32, 43, 32},
  81.     {46,  43, 58, 43, 46, 43, 58, 43},
  82.     {34,  32, 43, 32, 34, 32, 43, 32},
  83.     {36,  34, 46, 34, 36, 34, 46, 34},
  84.     {34,  32, 43, 32, 34, 32, 43, 32},
  85.     {46,  43, 58, 43, 46, 43, 58, 43},
  86.     {34,  32, 43, 32, 34, 32, 43, 32}
  87.   }
  88. };
  90. //! Dequantization coefficients
  91. const int dequant_coef[6][4][4] = {
  92.   {
  93.     { 10, 13, 10, 13},
  94.     { 13, 16, 13, 16},
  95.     { 10, 13, 10, 13},
  96.     { 13, 16, 13, 16}},
  97.   {
  98.     { 11, 14, 11, 14},
  99.     { 14, 18, 14, 18},
  100.     { 11, 14, 11, 14},
  101.     { 14, 18, 14, 18}},
  102.   {
  103.     { 13, 16, 13, 16},
  104.     { 16, 20, 16, 20},
  105.     { 13, 16, 13, 16},
  106.     { 16, 20, 16, 20}},
  107.   {
  108.     { 14, 18, 14, 18},
  109.     { 18, 23, 18, 23},
  110.     { 14, 18, 14, 18},
  111.     { 18, 23, 18, 23}},
  112.   {
  113.     { 16, 20, 16, 20},
  114.     { 20, 25, 20, 25},
  115.     { 16, 20, 16, 20},
  116.     { 20, 25, 20, 25}},
  117.   {
  118.     { 18, 23, 18, 23},
  119.     { 23, 29, 23, 29},
  120.     { 18, 23, 18, 23},
  121.     { 23, 29, 23, 29}}
  122. };
  124. const int quant_coef[6][4][4] = {
  125.   {
  126.     { 13107,  8066, 13107,  8066},
  127.     {  8066,  5243,  8066,  5243},
  128.     { 13107,  8066, 13107,  8066},
  129.     {  8066,  5243,  8066,  5243}},
  130.   {
  131.     { 11916,  7490, 11916,  7490},
  132.     {  7490,  4660,  7490,  4660},
  133.     { 11916,  7490, 11916,  7490},
  134.     {  7490,  4660,  7490,  4660}},
  135.   {
  136.     { 10082,  6554, 10082,  6554},
  137.     {  6554,  4194,  6554,  4194},
  138.     { 10082,  6554, 10082,  6554},
  139.     {  6554,  4194,  6554,  4194}},
  140.   {
  141.     {  9362,  5825,  9362,  5825},
  142.     {  5825,  3647,  5825,  3647},
  143.     {  9362,  5825,  9362,  5825},
  144.     {  5825,  3647,  5825,  3647}},
  145.   {
  146.     {  8192,  5243,  8192,  5243},
  147.     {  5243,  3355,  5243,  3355},
  148.     {  8192,  5243,  8192,  5243},
  149.     {  5243,  3355,  5243,  3355}},
  150.   {
  151.     {  7282,  4559,  7282,  4559},
  152.     {  4559,  2893,  4559,  2893},
  153.     {  7282,  4559,  7282,  4559},
  154.     {  4559,  2893,  4559,  2893}}
  155. };
  157. const int A[4][4] = {
  158.   { 16, 20, 16, 20},
  159.   { 20, 25, 20, 25},
  160.   { 16, 20, 16, 20},
  161.   { 20, 25, 20, 25}
  162. };
  164. int quant_intra_default[16] = {
  165.    6,13,20,28,
  166.   13,20,28,32,
  167.   20,28,32,37,
  168.   28,32,37,42
  169. };
  171. int quant_inter_default[16] = {
  172.   10,14,20,24,
  173.   14,20,24,27,
  174.   20,24,27,30,
  175.   24,27,30,34
  176. };
  178. int quant8_intra_default[64] = {
  179.  6,10,13,16,18,23,25,27,
  180. 10,11,16,18,23,25,27,29,
  181. 13,16,18,23,25,27,29,31,
  182. 16,18,23,25,27,29,31,33,
  183. 18,23,25,27,29,31,33,36,
  184. 23,25,27,29,31,33,36,38,
  185. 25,27,29,31,33,36,38,40,
  186. 27,29,31,33,36,38,40,42
  187. };
  189. int quant8_inter_default[64] = {
  190.  9,13,15,17,19,21,22,24,
  191. 13,13,17,19,21,22,24,25,
  192. 15,17,19,21,22,24,25,27,
  193. 17,19,21,22,24,25,27,28,
  194. 19,21,22,24,25,27,28,30,
  195. 21,22,24,25,27,28,30,32,
  196. 22,24,25,27,28,30,32,33,
  197. 24,25,27,28,30,32,33,35
  198. };
  200. int quant_org[16] = { //to be use if no q matrix is chosen
  201. 16,16,16,16,
  202. 16,16,16,16,
  203. 16,16,16,16,
  204. 16,16,16,16
  205. };
  207. int quant8_org[64] = { //to be use if no q matrix is chosen
  208. 16,16,16,16,16,16,16,16,
  209. 16,16,16,16,16,16,16,16,
  210. 16,16,16,16,16,16,16,16,
  211. 16,16,16,16,16,16,16,16,
  212. 16,16,16,16,16,16,16,16,
  213. 16,16,16,16,16,16,16,16,
  214. 16,16,16,16,16,16,16,16,
  215. 16,16,16,16,16,16,16,16
  216. };
  218. int *qp_per_matrix;
  219. int *qp_rem_matrix;
  221. int  InvLevelScale4x4_Intra[3][6][4][4];
  222. int  InvLevelScale4x4_Inter[3][6][4][4];
  223. int  InvLevelScale8x8_Intra[3][6][8][8];
  224. int  InvLevelScale8x8_Inter[3][6][8][8];
  226. int  *qmatrix[12];
  228. /*!
  229.  ***********************************************************************
  230.  * brief
  231.  *    Initiate quantization process arrays
  232.  ***********************************************************************
  233.  */
  234. void init_qp_process(ImageParameters *img)
  235. {
  236.   int bitdepth_qp_scale = imax(img->bitdepth_luma_qp_scale,img->bitdepth_chroma_qp_scale);
  237.   int i;
  239.   // We should allocate memory outside of this process since maybe we will have a change of SPS 
  240.   // and we may need to recreate these. Currently should only support same bitdepth
  241.   if (qp_per_matrix == NULL)
  242.     if ((qp_per_matrix = (int*)malloc((MAX_QP + 1 +  bitdepth_qp_scale)*sizeof(int))) == NULL)
  243.       no_mem_exit("init_global_buffers: qp_per_matrix");
  244.   if (qp_rem_matrix == NULL)
  245.     if ((qp_rem_matrix = (int*)malloc((MAX_QP + 1 +  bitdepth_qp_scale)*sizeof(int))) == NULL)
  246.       no_mem_exit("init_global_buffers: qp_per_matrix");
  248.   for (i = 0; i < MAX_QP + bitdepth_qp_scale + 1; i++)
  249.   {
  250.     qp_per_matrix[i] = i / 6;
  251.     qp_rem_matrix[i] = i % 6;
  252.   }
  253. }
  255. /*!
  256.  ************************************************************************
  257.  * brief
  258.  *    For mapping the q-matrix to the active id and calculate quantisation values
  259.  *
  260.  * param pps
  261.  *    Picture parameter set
  262.  * param sps
  263.  *    Sequence parameter set
  264.  *
  265.  ************************************************************************
  266.  */
  267. void AssignQuantParam(pic_parameter_set_rbsp_t* pps, seq_parameter_set_rbsp_t* sps)
  268. {
  269.   int i;
  270.   int n_ScalingList;
  272.   if(!pps->pic_scaling_matrix_present_flag && !sps->seq_scaling_matrix_present_flag)
  273.   {
  274.     for(i=0; i<12; i++)
  275.       qmatrix[i] = (i < 6) ? quant_org : quant8_org;
  276.   }
  277.   else
  278.   {
  279.     n_ScalingList = (sps->chroma_format_idc != YUV444) ? 8 : 12;
  280.     if(sps->seq_scaling_matrix_present_flag) // check sps first
  281.     {
  282.       for(i=0; i<n_ScalingList; i++)
  283.       {
  284.         if(i<6)
  285.         {
  286.           if(!sps->seq_scaling_list_present_flag[i]) // fall-back rule A
  287.           {
  288.             if(i==0)
  289.               qmatrix[i] = quant_intra_default;
  290.             else if(i==3)
  291.               qmatrix[i] = quant_inter_default;
  292.             else
  293.               qmatrix[i] = qmatrix[i-1];
  294.           }
  295.           else
  296.           {
  297.             if(sps->UseDefaultScalingMatrix4x4Flag[i])
  298.               qmatrix[i] = (i<3) ? quant_intra_default : quant_inter_default;
  299.             else
  300.               qmatrix[i] = sps->ScalingList4x4[i];
  301.           }
  302.         }
  303.         else
  304.         {
  305.           if(!sps->seq_scaling_list_present_flag[i]) // fall-back rule A
  306.           {
  307.             if(i==6)
  308.               qmatrix[i] = quant8_intra_default;
  309.             else if(i==7)
  310.               qmatrix[i] = quant8_inter_default;
  311.             else
  312.               qmatrix[i] = qmatrix[i-2];
  313.           }
  314.           else
  315.           {
  316.             if(sps->UseDefaultScalingMatrix8x8Flag[i-6])
  317.               qmatrix[i] = (i==6 || i==8 || i==10) ? quant8_intra_default:quant8_inter_default;
  318.             else
  319.               qmatrix[i] = sps->ScalingList8x8[i-6];
  320.           }
  321.         }
  322.       }
  323.     }
  325.     if(pps->pic_scaling_matrix_present_flag) // then check pps
  326.     {
  327.       for(i=0; i<n_ScalingList; i++)
  328.       {
  329.         if(i<6)
  330.         {
  331.           if(!pps->pic_scaling_list_present_flag[i]) // fall-back rule B
  332.           {
  333.             if (i==0)
  334.             {
  335.               if(!sps->seq_scaling_matrix_present_flag)
  336.                 qmatrix[i] = quant_intra_default;
  337.             }
  338.             else if (i==3)
  339.             {
  340.               if(!sps->seq_scaling_matrix_present_flag)
  341.                 qmatrix[i] = quant_inter_default;
  342.             }
  343.             else
  344.               qmatrix[i] = qmatrix[i-1];
  345.           }
  346.           else
  347.           {
  348.             if(pps->UseDefaultScalingMatrix4x4Flag[i])
  349.               qmatrix[i] = (i<3) ? quant_intra_default:quant_inter_default;
  350.             else
  351.               qmatrix[i] = pps->ScalingList4x4[i];
  352.           }
  353.         }
  354.         else
  355.         {
  356.           if(!pps->pic_scaling_list_present_flag[i]) // fall-back rule B
  357.           {
  358.             if (i==6)
  359.             {
  360.               if(!sps->seq_scaling_matrix_present_flag)
  361.                 qmatrix[i] = quant8_intra_default;
  362.             }
  363.             else if(i==7)
  364.             {
  365.               if(!sps->seq_scaling_matrix_present_flag)
  366.                 qmatrix[i] = quant8_inter_default;
  367.             }
  368.             else  
  369.               qmatrix[i] = qmatrix[i-2];
  370.           }
  371.           else
  372.           {
  373.             if(pps->UseDefaultScalingMatrix8x8Flag[i-6])
  374.               qmatrix[i] = (i==6 || i==8 || i==10) ? quant8_intra_default:quant8_inter_default;
  375.             else
  376.               qmatrix[i] = pps->ScalingList8x8[i-6];
  377.           }
  378.         }
  379.       }
  380.     }
  381.   }
  383.   CalculateQuantParam();
  384.   if(pps->transform_8x8_mode_flag)
  385.     CalculateQuant8Param();
  386. }
  388. /*!
  389.  ************************************************************************
  390.  * brief
  391.  *    For calculating the quantisation values at frame level
  392.  *
  393.  ************************************************************************
  394.  */
  395. void CalculateQuantParam()
  396. {
  397.   int i, j, k, temp;
  399.   for(k=0; k<6; k++)
  400.   {
  401.     for(i=0; i<4; i++)
  402.     {
  403.       for(j=0; j<4; j++)
  404.       {
  405.         temp = (i<<2)+j;
  406.         InvLevelScale4x4_Intra[0][k][i][j] = dequant_coef[k][i][j] * qmatrix[0][temp];
  407.         InvLevelScale4x4_Intra[1][k][i][j] = dequant_coef[k][i][j] * qmatrix[1][temp];
  408.         InvLevelScale4x4_Intra[2][k][i][j] = dequant_coef[k][i][j] * qmatrix[2][temp];
  410.         InvLevelScale4x4_Inter[0][k][i][j] = dequant_coef[k][i][j] * qmatrix[3][temp];
  411.         InvLevelScale4x4_Inter[1][k][i][j] = dequant_coef[k][i][j] * qmatrix[4][temp];
  412.         InvLevelScale4x4_Inter[2][k][i][j] = dequant_coef[k][i][j] * qmatrix[5][temp];
  413.       }
  414.     }
  415.   }
  416. }
  418. /*!
  419.  ************************************************************************
  420.  * brief
  421.  *    Calculate the quantisation and inverse quantisation parameters
  422.  *
  423.  ************************************************************************
  424.  */
  425. void CalculateQuant8Param()
  426. {
  427.   int i, j, k, temp;
  429.   for(k=0; k<6; k++)
  430.   {
  431.     for(i=0; i<8; i++)
  432.     {
  433.       for(j=0; j<8; j++)
  434.       {
  435.         temp = (i<<3)+j;
  436.         InvLevelScale8x8_Intra[0][k][i][j] = dequant_coef8[k][i][j] * qmatrix[6][temp];
  437.         InvLevelScale8x8_Inter[0][k][i][j] = dequant_coef8[k][i][j] * qmatrix[7][temp];
  438.       }
  439.     }
  440.   }
  442.   if( active_sps->chroma_format_idc == 3 )  // 4:4:4
  443.   {
  444.     for(k=0; k<6; k++)
  445.     {
  446.       for(i=0; i<8; i++)
  447.       {
  448.         for(j=0; j<8; j++)
  449.         {
  450.           temp = (i<<3)+j;
  451.           InvLevelScale8x8_Intra[1][k][i][j] = dequant_coef8[k][i][j] * qmatrix[8][temp];
  452.           InvLevelScale8x8_Inter[1][k][i][j] = dequant_coef8[k][i][j] * qmatrix[9][temp];
  453.           InvLevelScale8x8_Intra[2][k][i][j] = dequant_coef8[k][i][j] * qmatrix[10][temp];
  454.           InvLevelScale8x8_Inter[2][k][i][j] = dequant_coef8[k][i][j] * qmatrix[11][temp];
  455.         }
  456.       }
  457.     }
  458.   }
  459. }