quantize.c
上传用户:ma_junhua
上传日期:2008-04-11
资源大小:2752k
文件大小:5k
开发平台:

C/C++

  1. /* quantize.c, quantization / inverse quantization                          */
  2. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  27. #include <stdio.h>
  28. #include "config.h"
  29. #include "global.h"
  30. static void iquant1_intra _ANSI_ARGS_((short *src, short *dst,
  31.   int dc_prec, unsigned char *quant_mat, int mquant));
  32. static void iquant1_non_intra _ANSI_ARGS_((short *src, short *dst,
  33.   unsigned char *quant_mat, int mquant));
  34. /* Test Model 5 quantization
  35.  *
  36.  * this quantizer has a bias of 1/8 stepsize towards zero
  37.  * (except for the DC coefficient)
  38.  */
  39. int quant_intra(src,dst,dc_prec,quant_mat,mquant)
  40. short *src, *dst;
  41. int dc_prec;
  42. unsigned char *quant_mat;
  43. int mquant;
  44. {
  45.   int i;
  46.   int x, y, d;
  47.   x = src[0];
  48.   d = 8>>dc_prec; /* intra_dc_mult */
  49.   dst[0] = (x>=0) ? (x+(d>>1))/d : -((-x+(d>>1))/d); /* round(x/d) */
  50.   for (i=1; i<64; i++)
  51.   {
  52.     x = src[i];
  53.     d = quant_mat[i];
  54.     y = (32*(x>=0 ? x : -x) + (d>>1))/d; /* round(32*x/quant_mat) */
  55.     d = (3*mquant+2)>>2;
  56.     y = (y+d)/(2*mquant); /* (y+0.75*mquant) / (2*mquant) */
  57.     /* clip to syntax limits */
  58.     if (y > 255)
  59.     {
  60.       if (mpeg1)
  61.         y = 255;
  62.       else if (y > 2047)
  63.         y = 2047;
  64.     }
  65.     dst[i] = (x>=0) ? y : -y;
  66. #if 0
  67.     /* this quantizer is virtually identical to the above */
  68.     if (x<0)
  69.       x = -x;
  70.     d = mquant*quant_mat[i];
  71.     y = (16*x + ((3*d)>>3)) / d;
  72.     dst[i] = (src[i]<0) ? -y : y;
  73. #endif
  74.   }
  75.   return 1;
  76. }
  77. int quant_non_intra(src,dst,quant_mat,mquant)
  78. short *src, *dst;
  79. unsigned char *quant_mat;
  80. int mquant;
  81. {
  82.   int i;
  83.   int x, y, d;
  84.   int nzflag;
  85.   nzflag = 0;
  86.   for (i=0; i<64; i++)
  87.   {
  88.     x = src[i];
  89.     d = quant_mat[i];
  90.     y = (32*(x>=0 ? x : -x) + (d>>1))/d; /* round(32*x/quant_mat) */
  91.     y /= (2*mquant);
  92.     /* clip to syntax limits */
  93.     if (y > 255)
  94.     {
  95.       if (mpeg1)
  96.         y = 255;
  97.       else if (y > 2047)
  98.         y = 2047;
  99.     }
  100.     if ((dst[i] = (x>=0 ? y : -y)) != 0)
  101.       nzflag=1;
  102.   }
  103.   return nzflag;
  104. }
  105. /* MPEG-2 inverse quantization */
  106. void iquant_intra(src,dst,dc_prec,quant_mat,mquant)
  107. short *src, *dst;
  108. int dc_prec;
  109. unsigned char *quant_mat;
  110. int mquant;
  111. {
  112.   int i, val, sum;
  113.   if (mpeg1)
  114.     iquant1_intra(src,dst,dc_prec,quant_mat,mquant);
  115.   else
  116.   {
  117.     sum = dst[0] = src[0] << (3-dc_prec);
  118.     for (i=1; i<64; i++)
  119.     {
  120.       val = (int)(src[i]*quant_mat[i]*mquant)/16;
  121.       sum+= dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
  122.     }
  123.     /* mismatch control */
  124.     if ((sum&1)==0)
  125.       dst[63]^= 1;
  126.   }
  127. }
  128. void iquant_non_intra(src,dst,quant_mat,mquant)
  129. short *src, *dst;
  130. unsigned char *quant_mat;
  131. int mquant;
  132. {
  133.   int i, val, sum;
  134.   if (mpeg1)
  135.     iquant1_non_intra(src,dst,quant_mat,mquant);
  136.   else
  137.   {
  138.     sum = 0;
  139.     for (i=0; i<64; i++)
  140.     {
  141.       val = src[i];
  142.       if (val!=0)
  143.         val = (int)((2*val+(val>0 ? 1 : -1))*quant_mat[i]*mquant)/32;
  144.       sum+= dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
  145.     }
  146.     /* mismatch control */
  147.     if ((sum&1)==0)
  148.       dst[63]^= 1;
  149.   }
  150. }
  151. /* MPEG-1 inverse quantization */
  152. static void iquant1_intra(src,dst,dc_prec,quant_mat,mquant)
  153. short *src, *dst;
  154. int dc_prec;
  155. unsigned char *quant_mat;
  156. int mquant;
  157. {
  158.   int i, val;
  159.   dst[0] = src[0] << (3-dc_prec);
  160.   for (i=1; i<64; i++)
  161.   {
  162.     val = (int)(src[i]*quant_mat[i]*mquant)/16;
  163.     /* mismatch control */
  164.     if ((val&1)==0 && val!=0)
  165.       val+= (val>0) ? -1 : 1;
  166.     /* saturation */
  167.     dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
  168.   }
  169. }
  170. static void iquant1_non_intra(src,dst,quant_mat,mquant)
  171. short *src, *dst;
  172. unsigned char *quant_mat;
  173. int mquant;
  174. {
  175.   int i, val;
  176.   for (i=0; i<64; i++)
  177.   {
  178.     val = src[i];
  179.     if (val!=0)
  180.     {
  181.       val = (int)((2*val+(val>0 ? 1 : -1))*quant_mat[i]*mquant)/32;
  182.       /* mismatch control */
  183.       if ((val&1)==0 && val!=0)
  184.         val+= (val>0) ? -1 : 1;
  185.     }
  186.     /* saturation */
  187.     dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
  188.   }
  189. }