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

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

Audio

开发平台：

Visual C++

quant8x8_normal.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file quant8x8_normal.c
  5.  *
  6.  * brief
  7.  *    Quantization process for a 8x8 block without any adaptation
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Alexis Michael Tourapis                  <alexismt@ieee.org>
  12.  *
  13.  *************************************************************************************
  14.  */
  16. #include "contributors.h"
  18. #include <math.h>
  20. #include "global.h"
  22. #include "image.h"
  23. #include "mb_access.h"
  24. #include "vlc.h"
  25. #include "transform.h"
  26. #include "mc_prediction.h"
  27. #include "q_offsets.h"
  28. #include "q_matrix.h"
  29. #include "quant8x8.h"
  32. /*!
  33.  ************************************************************************
  34.  * brief
  35.  *    Quantization process for All coefficients for a 8x8 block
  36.  *
  37.  * par Input:
  38.  *
  39.  * par Output:
  40.  *
  41.  ************************************************************************
  42.  */
  43. int quant_8x8_normal(int (*tblock)[16], int block_y, int block_x, int  qp,
  44.                      int*  ACLevel, int*  ACRun, 
  45.                      int **fadjust8x8, int **levelscale, int **invlevelscale, int **leveloffset,
  46.                      int *coeff_cost, const byte (*pos_scan)[2], const byte *c_cost)
  47. {
  48.   static int i,j, coeff_ctr;
  50.   static int *m7;
  51.   static int scaled_coeff;
  53.   int   level, run = 0;
  54.   int   nonzero = FALSE;
  55.   int   qp_per = qp_per_matrix[qp];
  56.   int   q_bits = Q_BITS_8 + qp_per;
  57.   const byte *p_scan = &pos_scan[0][0];
  58.   int*  ACL = &ACLevel[0];
  59.   int*  ACR = &ACRun[0];
  61.   // Quantization
  62.   for (coeff_ctr = 0; coeff_ctr < 64; coeff_ctr++)
  63.   {
  64.     i = *p_scan++;  // horizontal position
  65.     j = *p_scan++;  // vertical position
  67.     m7 = &tblock[j][block_x + i];
  68.     if (*m7 != 0)
  69.     {
  70.       scaled_coeff = iabs (*m7) * levelscale[j][i];
  71.       level = (scaled_coeff + leveloffset[j][i]) >> q_bits;
  73.       if (level != 0)
  74.       {
  75.         nonzero = TRUE;
  77.         *coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];
  79.         level  = isignab(level, *m7);
  80.         *m7    = rshift_rnd_sf(((level * invlevelscale[j][i]) << qp_per), 6);
  81.         *ACL++ = level;
  82.         *ACR++ = run; 
  83.         // reset zero level counter
  84.         run    = 0;
  85.       }
  86.       else
  87.       {
  88.         run++;
  89.         *m7 = 0;
  90.       }
  91.     }
  92.     else
  93.     {
  94.       run++;
  95.     }
  96.   }
  98.   *ACL = 0;
  100.   return nonzero;
  101. }
  103. /*!
  104.  ************************************************************************
  105.  * brief
  106.  *    Quantization process for All coefficients for a 8x8 block 
  107.  *    CAVLC version
  108.  *
  109.  * par Input:
  110.  *
  111.  * par Output:
  112.  *
  113.  ************************************************************************
  114.  */
  115. int quant_8x8cavlc_normal(int (*tblock)[16], int block_y, int block_x, int  qp,                 
  116.                    int***  cofAC, 
  117.                    int **fadjust8x8, int **levelscale, int **invlevelscale, int **leveloffset,
  118.                    int *coeff_cost, const byte (*pos_scan)[2], const byte *c_cost)
  119. {
  120.   static int i,j, k, coeff_ctr;
  122.   static int *m7;
  123.   static int scaled_coeff;  
  125.   int level, runs[4] = { 0 };
  126.   int nonzero = FALSE; 
  127.   int qp_per = qp_per_matrix[qp];  
  128.   int q_bits = Q_BITS_8 + qp_per;
  129.   const byte *p_scan = &pos_scan[0][0];
  130.   int*  ACL[4];  
  131.   int*  ACR[4];
  133.   for (k = 0; k < 4; k++)
  134.   {
  135.     ACL[k] = &cofAC[k][0][0];
  136.     ACR[k] = &cofAC[k][1][0];
  137.   }
  139.   // Quantization
  140.   for (coeff_ctr = 0; coeff_ctr < 16; coeff_ctr++)
  141.   {
  142.     for (k = 0; k < 4; k++)
  143.     {
  144.       i = *p_scan++;  // horizontal position
  145.       j = *p_scan++;  // vertical position
  147.       m7 = &tblock[j][block_x + i];
  148.       if (*m7 != 0)
  149.       {
  150.       scaled_coeff = iabs (*m7) * levelscale[j][i];
  151.       level = (scaled_coeff + leveloffset[j][i]) >> q_bits;
  153.       if (level != 0)
  154.       {
  155.         level = imin(level, CAVLC_LEVEL_LIMIT);
  157.         nonzero=TRUE;
  159.         *coeff_cost += (level > 1) ? MAX_VALUE : c_cost[runs[k]];
  161.         level  = isignab(level, *m7);
  162.         *m7    = rshift_rnd_sf(((level * invlevelscale[j][i]) << qp_per), 6);
  164.         *(ACL[k])++ = level;
  165.         *(ACR[k])++ = runs[k];
  166.         // reset zero level counter
  167.         runs[k] = 0;
  168.       }
  169.       else
  170.       {        
  171.           runs[k]++;
  172.           *m7 = 0;      
  173.         }
  174.       }
  175.       else
  176.       {
  177.         runs[k]++;
  178.       }
  179.     }
  180.   }
  182.   for(k = 0; k < 4; k++)
  183.     *(ACL[k]) = 0;
  185.   return nonzero;
  186. }