1 /* quantize.c, quantization / inverse quantization */
3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
6 * Disclaimer of Warranty
8 * These software programs are available to the user without any license fee or
9 * royalty on an "as is" basis. The MPEG Software Simulation Group disclaims
10 * any and all warranties, whether express, implied, or statuary, including any
11 * implied warranties or merchantability or of fitness for a particular
12 * purpose. In no event shall the copyright-holder be liable for any
13 * incidental, punitive, or consequential damages of any kind whatsoever
14 * arising from the use of these programs.
16 * This disclaimer of warranty extends to the user of these programs and user's
17 * customers, employees, agents, transferees, successors, and assigns.
19 * The MPEG Software Simulation Group does not represent or warrant that the
20 * programs furnished hereunder are free of infringement of any third-party
23 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
24 * are subject to royalty fees to patent holders. Many of these patents are
25 * general enough such that they are unavoidable regardless of implementation
35 #include "cpu_accel.h"
37 #include "fastintfns.h"
40 /* Global function pointers for SIMD-dependent functions */
41 int (*pquant_non_intra)(pict_data_s *picture, int16_t *src, int16_t *dst,
42 int mquant, int *nonsat_mquant);
43 int (*pquant_weight_coeff_sum)(int16_t *blk, uint16_t*i_quant_mat );
45 /* Local functions pointers for SIMD-dependent functions */
47 static void (*piquant_non_intra_m1)(int16_t *src, int16_t *dst, uint16_t *quant_mat);
50 static int quant_weight_coeff_sum( int16_t *blk, uint16_t * i_quant_mat );
51 static void iquant_non_intra_m1(int16_t *src, int16_t *dst, uint16_t *quant_mat);
55 Initialise quantization routines.
56 Currently just setting up MMX routines if available...
59 void init_quantizer_hv()
64 if( (flags & ACCEL_X86_MMX) != 0 ) /* MMX CPU */
66 if(verbose) fprintf( stderr, "SETTING " );
67 if( (flags & ACCEL_X86_3DNOW) != 0 )
69 if(verbose) fprintf( stderr, "3DNOW and ");
70 pquant_non_intra = quant_non_intra_hv_3dnow;
73 * else if ( (flags & ACCEL_X86_MMXEXT) != 0 )
75 * if(verbose) fprintf( stderr, "SSE and ");
76 * pquant_non_intra = quant_non_intra_hv_sse;
81 pquant_non_intra = quant_non_intra_hv;
84 if ( (flags & ACCEL_X86_MMXEXT) != 0 )
86 if(verbose) fprintf( stderr, "EXTENDED MMX");
87 pquant_weight_coeff_sum = quant_weight_coeff_sum_mmx;
88 piquant_non_intra_m1 = iquant_non_intra_m1_sse;
92 if(verbose) fprintf( stderr, "MMX");
93 pquant_weight_coeff_sum = quant_weight_coeff_sum_mmx;
94 piquant_non_intra_m1 = iquant_non_intra_m1_mmx;
96 if(verbose) fprintf( stderr, " for QUANTIZER!\n");
101 pquant_non_intra = quant_non_intra_hv;
102 pquant_weight_coeff_sum = quant_weight_coeff_sum;
103 piquant_non_intra_m1 = iquant_non_intra_m1;
109 * Computes the next quantisation up. Used to avoid saturation
110 * in macroblock coefficients - common in MPEG-1 - which causes
113 * NOTE: Does no range checking...
118 int next_larger_quant_hv( pict_data_s *picture, int quant )
120 if( picture->q_scale_type )
122 if( map_non_linear_mquant_hv[quant]+1 > 31 )
125 return non_linear_mquant_table_hv[map_non_linear_mquant_hv[quant]+1];
138 * Quantisation for intra blocks using Test Model 5 quantization
140 * this quantizer has a bias of 1/8 stepsize towards zero
141 * (except for the DC coefficient)
143 PRECONDITION: src dst point to *disinct* memory buffers...
144 of block_count *adjact* int16_t[64] arrays...
146 * RETURN: 1 If non-zero coefficients left after quantisaiont 0 otherwise
150 pict_data_s *picture,
161 int clipvalue = dctsatlim;
162 uint16_t *quant_mat = intra_q_tbl[mquant] /* intra_q */;
165 /* Inspired by suggestion by Juan. Quantize a little harder if we clip...
173 for( comp = 0; comp<block_count && !clipping; ++comp )
176 d = 8>>picture->dc_prec; /* intra_dc_mult */
177 pbuf[0] = (x>=0) ? (x+(d>>1))/d : -((-x+(d>>1))/d); /* round(x/d) */
180 for (i=1; i<64 ; i++)
184 /* RJ: save one divide operation */
185 y = ((abs(x) << 5)+ ((3 * quant_mat[i]) >> 2)) / (quant_mat[i] << 1);
189 mquant = next_larger_quant_hv( picture, mquant );
190 quant_mat = intra_q_tbl[mquant];
194 pbuf[i] = intsamesign(x,y);
201 *nonsat_mquant = mquant;
206 * Quantisation matrix weighted Coefficient sum fixed-point
207 * integer with low 16 bits fractional...
208 * To be used for rate control as a measure of dct block
213 int quant_weight_coeff_sum( int16_t *blk, uint16_t * i_quant_mat )
217 for( i = 0; i < 64; i+=2 )
219 sum += abs((int)blk[i]) * (i_quant_mat[i]) + abs((int)blk[i+1]) * (i_quant_mat[i+1]);
222 /* In case you're wondering typical average coeff_sum's for a rather
223 noisy video are around 20.0. */
229 * Quantisation for non-intra blocks using Test Model 5 quantization
231 * this quantizer has a bias of 1/8 stepsize towards zero
232 * (except for the DC coefficient)
234 * A.Stevens 2000: The above comment is nonsense. Only the intra quantiser does
235 * this. This one just truncates with a modest bias of 1/(4*quant_matrix_scale)
238 * PRECONDITION: src dst point to *disinct* memory buffers...
239 * of block_count *adjacent* int16_t[64] arrays...
241 * RETURN: A bit-mask of block_count bits indicating non-zero blocks (a 1).
243 * TODO: A candidate for use of efficient abs and "intsamesign". If only gcc understood
244 * PPro conditional moves...
247 int quant_non_intra_hv(
248 pict_data_s *picture,
249 int16_t *src, int16_t *dst,
257 int clipvalue = dctsatlim;
260 uint16_t *quant_mat = inter_q_tbl[mquant]/* inter_q */;
262 coeff_count = 64*block_count;
265 for (i=0; i<coeff_count; ++i)
270 nzflag = (nzflag<<1) | !!flags;
274 /* RJ: save one divide operation */
276 x = abs( ((int)src[i]) ) /*(src[i] >= 0 ? src[i] : -src[i])*/ ;
277 d = (int)quant_mat[(i&63)];
278 /* A.Stevens 2000: Given the math of non-intra frame
279 quantisation / inverse quantisation I always though the
280 funny little foudning factor was bogus. It seems to be
281 the encoder needs less bits if you simply divide!
284 y = (x<<4) / (d) /* (32*x + (d>>1))/(d*2*mquant)*/ ;
293 int new_mquant = next_larger_quant_hv( picture, mquant );
294 if( new_mquant != mquant )
297 quant_mat = inter_q_tbl[mquant];
308 dst[i] = intsamesign(src[i], y) /* (src[i] >= 0 ? y : -y) */;
311 nzflag = (nzflag<<1) | !!flags;
313 *nonsat_mquant = mquant;
317 /* MPEG-1 inverse quantization */
318 static void iquant1_intra(int16_t *src, int16_t *dst, int dc_prec, int mquant)
321 uint16_t *quant_mat = intra_q;
323 dst[0] = src[0] << (3-dc_prec);
326 val = (int)(src[i]*quant_mat[i]*mquant)/16;
328 /* mismatch control */
329 if ((val&1)==0 && val!=0)
330 val+= (val>0) ? -1 : 1;
333 dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
338 /* MPEG-2 inverse quantization */
339 void iquant_intra(int16_t *src, int16_t *dst, int dc_prec, int mquant)
344 iquant1_intra(src,dst,dc_prec, mquant);
347 sum = dst[0] = src[0] << (3-dc_prec);
350 val = (int)(src[i]*intra_q[i]*mquant)/16;
351 sum+= dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
354 /* mismatch control */
361 static void iquant_non_intra_m1(int16_t *src, int16_t *dst, uint16_t *quant_mat)
365 #ifndef ORIGINAL_CODE
372 val = (int)((2*val+(val>0 ? 1 : -1))*quant_mat[i])/32;
374 /* mismatch control */
375 if ((val&1)==0 && val!=0)
376 val+= (val>0) ? -1 : 1;
380 dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
389 val = ((val+val+1)*quant_mat[i]) >> 5;
390 /* mismatch control */
391 val -= (~(val&1))&(val!=0);
392 val = fastmin(val, 2047); /* Saturation */
394 dst[i] = intsamesign(src[i],val);
404 void iquant_non_intra(int16_t *src, int16_t *dst, int mquant )
410 (*piquant_non_intra_m1)(src,dst,inter_q_tbl[mquant]);
421 val = (int)((2*val+(val>0 ? 1 : -1))*inter_q[i]*mquant)/32;
422 sum+= dst[i] = (val>2047) ? 2047 : ((val<-2048) ? -2048 : val);
425 quant_mat = inter_q_tbl[mquant];
432 val = (int)((val+val+1)*quant_mat[i])>>5;
433 val = intmin( val, 2047);
436 dst[i] = intsamesign(src[i],val);
440 /* mismatch control */
446 void iquantize( pict_data_s *picture )
449 int16_t (*qblocks)[64] = picture->qblocks;
450 for (k=0; k<mb_per_pict; k++)
452 if (picture->mbinfo[k].mb_type & MB_INTRA)
453 for (j=0; j<block_count; j++)
454 iquant_intra(qblocks[k*block_count+j],
455 qblocks[k*block_count+j],
457 cur_picture.mbinfo[k].mquant);
459 for (j=0;j<block_count;j++)
460 iquant_non_intra(qblocks[k*block_count+j],
461 qblocks[k*block_count+j],
462 cur_picture.mbinfo[k].mquant);