e33df23347072ea9bd0154b54e5438944c9249b9
[theora.git] / lib / quant.c
1 /********************************************************************
2  *                                                                  *
3  * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
7  *                                                                  *
8  * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2003                *
9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
10  *                                                                  *
11  ********************************************************************
12
13   function:
14   last mod: $Id: quant.c,v 1.20 2004/03/19 05:13:56 giles Exp $
15
16  ********************************************************************/
17
18 //#include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include "encoder_internal.h"
22 #include "quant_lookup.h"
23
24 static const ogg_uint32_t QThreshTableV1[Q_TABLE_SIZE] = {
25   500,  450,  400,  370,  340,  310, 285, 265,
26   245,  225,  210,  195,  185,  180, 170, 160,
27   150,  145,  135,  130,  125,  115, 110, 107,
28   100,   96,   93,   89,   85,   82,  75,  74,
29   70,   68,   64,   60,   57,   56,  52,  50,
30   49,   45,   44,   43,   40,   38,  37,  35,
31   33,   32,   30,   29,   28,   25,  24,  22,
32   21,   19,   18,   17,   15,   13,  12,  10
33 };
34
35 static const Q_LIST_ENTRY DcScaleFactorTableV1[ Q_TABLE_SIZE ] = {
36   220, 200, 190, 180, 170, 170, 160, 160,
37   150, 150, 140, 140, 130, 130, 120, 120,
38   110, 110, 100, 100, 90,  90,  90,  80,
39   80,  80,  70,  70,  70,  60,  60,  60,
40   60,  50,  50,  50,  50,  40,  40,  40,
41   40,  40,  30,  30,  30,  30,  30,  30,
42   30,  20,  20,  20,  20,  20,  20,  20,
43   20,  10,  10,  10,  10,  10,  10,  10
44 };
45
46 /* dbm -- defined some alternative tables to test header packing */
47 #define NEW_QTABLES 0
48 #if NEW_QTABLES
49
50 static const Q_LIST_ENTRY Y_coeffsV1[64] =
51 {
52         8,  16,  16,  16,  20,  20,  20,  20,
53         16,  16,  16,  16,  20,  20,  20,  20,
54         16,  16,  16,  16,  22,  22,  22,  22,
55         16,  16,  16,  16,  22,  22,  22,  22,
56         20,  20,  22,  22,  24,  24,  24,  24,
57         20,  20,  22,  22,  24,  24,  24,  24,
58         20,  20,  22,  22,  24,  24,  24,  24,
59         20,  20,  22,  22,  24,  24,  24,  24
60 };
61
62 static const Q_LIST_ENTRY UV_coeffsV1[64] =
63 {       17,     18,     24,     47,     99,     99,     99,     99,
64         18,     21,     26,     66,     99,     99,     99,     99,
65         24,     26,     56,     99,     99,     99,     99,     99,
66         47,     66,     99,     99,     99,     99,     99,     99,
67         99,     99,     99,     99,     99,     99,     99,     99,
68         99,     99,     99,     99,     99,     99,     99,     99,
69         99,     99,     99,     99,     99,     99,     99,     99,
70         99,     99,     99,     99,     99,     99,     99,     99
71 };
72
73 /* Different matrices for different encoder versions */
74 static const Q_LIST_ENTRY Inter_coeffsV1[64] =
75 {
76         12, 16,  16,  16,  20,  20,  20,  20,
77         16,  16,  16,  16,  20,  20,  20,  20,
78         16,  16,  16,  16,  22,  22,  22,  22,
79         16,  16,  16,  16,  22,  22,  22,  22,
80         20,  20,  22,  22,  24,  24,  24,  24,
81         20,  20,  22,  22,  24,  24,  24,  24,
82         20,  20,  22,  22,  24,  24,  24,  24,
83         20,  20,  22,  22,  24,  24,  24,  24
84 };
85
86 #else /* these are the old VP3 values: */
87
88 static const Q_LIST_ENTRY Y_coeffsV1[64] ={
89   16,  11,  10,  16,  24,  40,  51,  61,
90   12,  12,  14,  19,  26,  58,  60,  55,
91   14,  13,  16,  24,  40,  57,  69,  56,
92   14,  17,  22,  29,  51,  87,  80,  62,
93   18,  22,  37,  58,  68, 109, 103,  77,
94   24,  35,  55,  64,  81, 104, 113,  92,
95   49,  64,  78,  87, 103, 121, 120, 101,
96   72,  92,  95,  98, 112, 100, 103,  99
97 };
98
99 static const Q_LIST_ENTRY UV_coeffsV1[64] ={
100   17,   18,     24,     47,     99,     99,     99,     99,
101   18,   21,     26,     66,     99,     99,     99,     99,
102   24,   26,     56,     99,     99,     99,     99,     99,
103   47,   66,     99,     99,     99,     99,     99,     99,
104   99,   99,     99,     99,     99,     99,     99,     99,
105   99,   99,     99,     99,     99,     99,     99,     99,
106   99,   99,     99,     99,     99,     99,     99,     99,
107   99,   99,     99,     99,     99,     99,     99,     99
108 };
109
110 /* Different matrices for different encoder versions */
111 static const Q_LIST_ENTRY Inter_coeffsV1[64] ={
112   16,  16,  16,  20,  24,  28,  32,  40,
113   16,  16,  20,  24,  28,  32,  40,  48,
114   16,  20,  24,  28,  32,  40,  48,  64,
115   20,  24,  28,  32,  40,  48,  64,  64,
116   24,  28,  32,  40,  48,  64,  64,  64,
117   28,  32,  40,  48,  64,  64,  64,  96,
118   32,  40,  48,  64,  64,  64,  96,  128,
119   40,  48,  64,  64,  64,  96,  128, 128
120 };
121
122 #endif
123
124 static int _ilog(unsigned int v){
125   int ret=0;
126   while(v){
127     ret++;
128     v>>=1;
129   }
130   return(ret);
131 }
132
133 void WriteQTables(PB_INSTANCE *pbi,oggpack_buffer* opb) {
134   int x, bits;
135   bits=10;
136   oggpackB_write(opb, bits-1, 4);
137   for(x=0; x<64; x++) {
138     oggpackB_write(opb, pbi->QThreshTable[x],bits);
139   }
140   oggpackB_write(opb, bits-1, 4);
141   for(x=0; x<64; x++) {
142     oggpackB_write(opb, pbi->DcScaleFactorTable[x],bits);
143   }
144   oggpackB_write(opb, 3 - 1, 9); /* number of base matricies */
145   for(x=0; x<64; x++) {
146     oggpackB_write(opb, pbi->Y_coeffs[x],8);
147   }
148   for(x=0; x<64; x++) {
149     oggpackB_write(opb, pbi->UV_coeffs[x],8);
150   }
151   for(x=0; x<64; x++) {
152     oggpackB_write(opb, pbi->Inter_coeffs[x],8);
153   }
154   /* table mapping */
155   oggpackB_write(opb, 0, 2);  /* matrix 0 for intra Y */
156   oggpackB_write(opb, 62, 6); /* used for every q */
157   oggpackB_write(opb, 0, 2);
158   oggpackB_write(opb, 1, 1);  /* next range is explicit */
159   oggpackB_write(opb, 1, 2);  /* matrix 1 for intra U */
160   oggpackB_write(opb, 62, 6);
161   oggpackB_write(opb, 1, 2);
162   oggpackB_write(opb, 0, 1);  /* intra V is the same */
163   oggpackB_write(opb, 1, 1);  /* next range is explicit */
164   oggpackB_write(opb, 2, 2);  /* matrix 2 for inter Y */
165   oggpackB_write(opb, 62, 6);
166   oggpackB_write(opb, 2, 2);
167   oggpackB_write(opb, 0, 2);  /* inter U the same */
168   oggpackB_write(opb, 0, 2);  /* inter V the same */
169 }
170
171 static int _read_qtable_range(codec_setup_info *ci, oggpack_buffer* opb, int N) 
172 {
173   int index, range;
174   int qi = 0;
175
176   theora_read(opb,_ilog(N-1),&index); /* qi=0 index */
177   //fprintf(stderr, " [%d]",index);
178   while(qi<63) {
179     theora_read(opb,_ilog(62-qi),&range); /* range to next code q matrix */
180     range++;
181     //fprintf(stderr," %d",range);
182     if(range<=0) return OC_BADHEADER;
183     qi+=range;
184     theora_read(opb,_ilog(N-1),&index); /* next index */
185     //fprintf(stderr, " [%d]",index);
186   }
187
188   return 0;
189 }
190
191 int ReadQTables(codec_setup_info *ci, oggpack_buffer* opb) {
192   long bits,value;
193   int x,y, N;
194   //fprintf(stderr, "Reading Q tables...\n");
195   /* AC scale table */
196   theora_read(opb,4,&bits); bits++;
197   for(x=0; x<Q_TABLE_SIZE; x++) {
198     theora_read(opb,bits,&value);
199     if(bits<0)return OC_BADHEADER;
200     ci->QThreshTable[x]=value;
201   }
202   /* DC scale table */
203   theora_read(opb,4,&bits); bits++;
204   for(x=0; x<Q_TABLE_SIZE; x++) {
205     theora_read(opb,bits,&value);
206     if(bits<0)return OC_BADHEADER;
207     ci->DcScaleFactorTable[x]=(Q_LIST_ENTRY)value;
208   }
209   /* base matricies */
210   theora_read(opb,9,&N); N++;
211   //fprintf(stderr, "  max q matrix index %d\n", N);
212   if(N!=3)return OC_BADHEADER; /* we only support the VP3 config */
213   ci->qmats=_ogg_malloc(N*64*sizeof(Q_LIST_ENTRY));
214   ci->MaxQMatrixIndex = N;
215   for(y=0; y<N; y++) {
216     //fprintf(stderr," q matrix %d:\n  ", y);
217     for(x=0; x<64; x++) {
218       theora_read(opb,8,&value);
219       if(bits<0)return OC_BADHEADER;
220       ci->qmats[(y<<6)+x]=(Q_LIST_ENTRY)value;
221       //fprintf(stderr," %03d", (Q_LIST_ENTRY)value);
222       //if((x+1)%8==0)fprintf(stderr,"\n  ");
223     }
224     //fprintf(stderr,"\n");
225   }
226   /* table mapping */
227   {
228     int flag, ret;
229     /* intra Y */
230     //fprintf(stderr,"\n Intra Y:");
231     if((ret=_read_qtable_range(ci,opb,N))<0) return ret;
232     /* intra U */
233     //fprintf(stderr, "\n Intra U:");
234     theora_read(opb,1,&flag);
235     if(flag<0) return OC_BADHEADER;
236     if(flag) {
237       /* explicitly coded */
238       if((ret=_read_qtable_range(ci,opb,N))<0) return ret;
239     } else {
240       /* same as previous */
241       //fprintf(stderr," same as above");
242     }
243     /* intra V */
244     //fprintf(stderr,"\n Intra V:");
245     theora_read(opb,1,&flag);
246     if(flag<0) return OC_BADHEADER;
247     if(flag) {
248       /* explicitly coded */
249       if((ret=_read_qtable_range(ci,opb,N))<0) return ret;
250     } else {
251        /* same as previous */
252       //fprintf(stderr," same as above");
253     }
254     /* inter Y */
255     //fprintf(stderr,"\n Inter Y:");
256     theora_read(opb,1,&flag);
257     if(flag<0) return OC_BADHEADER;
258     if(flag) {
259       /* explicitly coded */
260       if((ret=_read_qtable_range(ci,opb,N))<0) return ret;
261     } else {
262       theora_read(opb,1,&flag);
263       if(flag<0) return OC_BADHEADER;
264       if(flag) {
265         /* same as corresponding intra */
266         //fprintf(stderr," same as intra");
267       } else {
268         /* same as previous */
269         //fprintf(stderr," same as above");
270       }
271     }
272     /* inter U */
273     //fprintf(stderr,"\n Inter U:");
274     theora_read(opb,1,&flag);
275     if(flag<0) return OC_BADHEADER;
276     if(flag) {
277       /* explicitly coded */
278       if((ret=_read_qtable_range(ci,opb,N))<0) return ret;
279     } else {
280       theora_read(opb,1,&flag);
281       if(flag<0) return OC_BADHEADER;
282       if(flag) {
283         /* same as corresponding intra */
284         //fprintf(stderr," same as intra");
285       } else {
286         /* same as previous */
287         //fprintf(stderr," same as above");
288       }
289     }
290     /* inter V */
291     //fprintf(stderr,"\n Inter V:");
292     theora_read(opb,1,&flag);
293     if(flag<0) return OC_BADHEADER;
294     if(flag) {
295       /* explicitly coded */
296       if((ret=_read_qtable_range(ci,opb,N))<0) return ret;
297     } else {
298       theora_read(opb,1,&flag);
299       if(flag<0) return OC_BADHEADER;
300       if(flag) {
301         /* same as corresponding intra */
302         //fprintf(stderr," same as intra");
303       } else {
304         /* same as previous */
305         //fprintf(stderr," same as above");
306       }
307     }
308     //fprintf(stderr,"\n");
309   }
310   
311   /* ignore the range table and reference the matricies we use */
312   memcpy(ci->Y_coeffs, &ci->qmats[0], sizeof(ci->Y_coeffs));
313   memcpy(ci->UV_coeffs, &ci->qmats[64], sizeof(ci->UV_coeffs));
314   memcpy(ci->Inter_coeffs, &ci->qmats[2*64], sizeof(ci->Inter_coeffs));
315
316   return 0;
317 }
318
319 void CopyQTables(PB_INSTANCE *pbi, codec_setup_info *ci) {
320   memcpy(pbi->QThreshTable, ci->QThreshTable, sizeof(pbi->QThreshTable));
321   memcpy(pbi->DcScaleFactorTable, ci->DcScaleFactorTable,
322          sizeof(pbi->DcScaleFactorTable));
323   memcpy(pbi->Y_coeffs, ci->Y_coeffs, sizeof(pbi->Y_coeffs));
324   memcpy(pbi->UV_coeffs, ci->UV_coeffs, sizeof(pbi->UV_coeffs));
325   memcpy(pbi->Inter_coeffs, ci->Inter_coeffs, sizeof(pbi->Inter_coeffs));
326 }
327
328 /* Initialize custom qtables using the VP31 values.
329    Someday we can change the quant tables to be adaptive, or just plain
330     better.*/
331 void InitQTables( PB_INSTANCE *pbi ){
332   memcpy(pbi->QThreshTable, QThreshTableV1, sizeof(pbi->QThreshTable));
333   memcpy(pbi->DcScaleFactorTable, DcScaleFactorTableV1,
334          sizeof(pbi->DcScaleFactorTable));
335   memcpy(pbi->Y_coeffs, Y_coeffsV1, sizeof(pbi->Y_coeffs));
336   memcpy(pbi->UV_coeffs, UV_coeffsV1, sizeof(pbi->UV_coeffs));
337   memcpy(pbi->Inter_coeffs, Inter_coeffsV1, sizeof(pbi->Inter_coeffs));
338 }
339
340 static void BuildQuantIndex_Generic(PB_INSTANCE *pbi){
341   ogg_int32_t i,j;
342
343   /* invert the dequant index into the quant index */
344   for ( i = 0; i < BLOCK_SIZE; i++ ){
345     j = dequant_index[i];
346     pbi->quant_index[j] = i;
347   }
348 }
349
350 static void init_quantizer ( CP_INSTANCE *cpi,
351                       ogg_uint32_t scale_factor,
352                       unsigned char QIndex ){
353     int i;
354     double ZBinFactor;
355     double RoundingFactor;
356
357     double temp_fp_quant_coeffs;
358     double temp_fp_quant_round;
359     double temp_fp_ZeroBinSize;
360     PB_INSTANCE *pbi = &cpi->pb;
361
362     const Q_LIST_ENTRY * Inter_coeffs;
363     const Q_LIST_ENTRY * Y_coeffs;
364     const Q_LIST_ENTRY * UV_coeffs;
365     const Q_LIST_ENTRY * DcScaleFactorTable;
366     const Q_LIST_ENTRY * UVDcScaleFactorTable;
367
368     /* Notes on setup of quantisers.  The initial multiplication by
369      the scale factor is done in the ogg_int32_t domain to insure that the
370      precision in the quantiser is the same as in the inverse
371      quantiser where all calculations are integer.  The "<< 2" is a
372      normalisation factor for the forward DCT transform. */
373
374     /* New version rounding and ZB characteristics. */
375     Inter_coeffs = Inter_coeffsV1;
376     Y_coeffs = Y_coeffsV1;
377     UV_coeffs = UV_coeffsV1;
378     DcScaleFactorTable = DcScaleFactorTableV1;
379     UVDcScaleFactorTable = DcScaleFactorTableV1;
380     ZBinFactor = 0.9;
381
382     switch(cpi->pb.info.sharpness){
383     case 0:
384       ZBinFactor = 0.65;
385       if ( scale_factor <= 50 )
386         RoundingFactor = 0.499;
387       else
388         RoundingFactor = 0.46;
389       break;
390     case 1:
391       ZBinFactor = 0.75;
392       if ( scale_factor <= 50 )
393         RoundingFactor = 0.476;
394       else
395         RoundingFactor = 0.400;
396       break;
397
398     default:
399       ZBinFactor = 0.9;
400       if ( scale_factor <= 50 )
401         RoundingFactor = 0.476;
402       else
403         RoundingFactor = 0.333;
404       break;
405     }
406
407     /* Use fixed multiplier for intra Y DC */
408     temp_fp_quant_coeffs =
409       (((ogg_uint32_t)(DcScaleFactorTable[QIndex] * Y_coeffs[0])/100) << 2);
410     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 2 )
411       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 2;
412
413     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
414     pbi->fp_quant_Y_round[0]    = (ogg_int32_t) (0.5 + temp_fp_quant_round);
415
416     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
417     pbi->fp_ZeroBinSize_Y[0]    = (ogg_int32_t) (0.5 + temp_fp_ZeroBinSize);
418
419     temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
420     pbi->fp_quant_Y_coeffs[0]   = (0.5 + SHIFT16 * temp_fp_quant_coeffs);
421
422     /* Intra UV */
423     temp_fp_quant_coeffs =
424       (((ogg_uint32_t)(UVDcScaleFactorTable[QIndex] * UV_coeffs[0])/100) << 2);
425     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 2)
426       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 2;
427
428     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
429     pbi->fp_quant_UV_round[0]   = (0.5 + temp_fp_quant_round);
430
431     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
432     pbi->fp_ZeroBinSize_UV[0]   = (0.5 + temp_fp_ZeroBinSize);
433
434     temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
435     pbi->fp_quant_UV_coeffs[0]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
436
437     /* Inter Y */
438     temp_fp_quant_coeffs =
439       (((ogg_uint32_t)(DcScaleFactorTable[QIndex] * Inter_coeffs[0])/100) << 2);
440     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 4)
441       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 4;
442
443     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
444     pbi->fp_quant_Inter_round[0]= (0.5 + temp_fp_quant_round);
445
446     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
447     pbi->fp_ZeroBinSize_Inter[0]= (0.5 + temp_fp_ZeroBinSize);
448
449     temp_fp_quant_coeffs= 1.0 / temp_fp_quant_coeffs;
450     pbi->fp_quant_Inter_coeffs[0]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
451
452     /* Inter UV */
453     temp_fp_quant_coeffs =
454       (((ogg_uint32_t)(UVDcScaleFactorTable[QIndex] * Inter_coeffs[0])/100) << 2);
455     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 4)
456       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 4;
457
458     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
459     pbi->fp_quant_InterUV_round[0]= (0.5 + temp_fp_quant_round);
460
461     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
462     pbi->fp_ZeroBinSize_InterUV[0]= (0.5 + temp_fp_ZeroBinSize);
463
464     temp_fp_quant_coeffs= 1.0 / temp_fp_quant_coeffs;
465     pbi->fp_quant_InterUV_coeffs[0]=
466       (0.5 + SHIFT16 * temp_fp_quant_coeffs);
467
468     for ( i = 1; i < 64; i++ ){
469       /* now scale coefficients by required compression factor */
470       /* Intra Y */
471       temp_fp_quant_coeffs =
472         (((ogg_uint32_t)(scale_factor * Y_coeffs[i]) / 100 ) << 2 );
473       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY) )
474         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY);
475
476       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
477       pbi->fp_quant_Y_round[i]  = (0.5 + temp_fp_quant_round);
478
479       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
480       pbi->fp_ZeroBinSize_Y[i]  = (0.5 + temp_fp_ZeroBinSize);
481
482       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
483       pbi->fp_quant_Y_coeffs[i] = (0.5 + SHIFT16 * temp_fp_quant_coeffs);
484
485       /* Intra UV */
486       temp_fp_quant_coeffs =
487         (((ogg_uint32_t)(scale_factor * UV_coeffs[i]) / 100 ) << 2 );
488       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY))
489         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY);
490
491       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
492       pbi->fp_quant_UV_round[i] = (0.5 + temp_fp_quant_round);
493
494       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
495       pbi->fp_ZeroBinSize_UV[i] = (0.5 + temp_fp_ZeroBinSize);
496
497       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
498       pbi->fp_quant_UV_coeffs[i]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
499
500       /* Inter Y */
501       temp_fp_quant_coeffs =
502         (((ogg_uint32_t)(scale_factor * Inter_coeffs[i]) / 100 ) << 2 );
503       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY * 2) )
504         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY * 2);
505
506       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
507       pbi->fp_quant_Inter_round[i]= (0.5 + temp_fp_quant_round);
508
509       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
510       pbi->fp_ZeroBinSize_Inter[i]= (0.5 + temp_fp_ZeroBinSize);
511
512       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
513       pbi->fp_quant_Inter_coeffs[i]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
514
515       /* Inter UV */
516       temp_fp_quant_coeffs =
517         (((ogg_uint32_t)(scale_factor * Inter_coeffs[i]) / 100 ) << 2 );
518       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY * 2) )
519         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY * 2);
520
521       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
522       pbi->fp_quant_InterUV_round[i]= (0.5 + temp_fp_quant_round);
523
524       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
525       pbi->fp_ZeroBinSize_InterUV[i]= (0.5 + temp_fp_ZeroBinSize);
526
527       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
528       pbi->fp_quant_InterUV_coeffs[i]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
529
530     }
531
532     pbi->fquant_coeffs = pbi->fp_quant_Y_coeffs;
533
534 }
535
536 void select_Y_quantiser ( PB_INSTANCE *pbi ){
537   pbi->fquant_coeffs = pbi->fp_quant_Y_coeffs;
538   pbi->fquant_round = pbi->fp_quant_Y_round;
539   pbi->fquant_ZbSize = pbi->fp_ZeroBinSize_Y;
540 }
541
542 void select_Inter_quantiser ( PB_INSTANCE *pbi ){
543   pbi->fquant_coeffs = pbi->fp_quant_Inter_coeffs;
544   pbi->fquant_round = pbi->fp_quant_Inter_round;
545   pbi->fquant_ZbSize = pbi->fp_ZeroBinSize_Inter;
546 }
547
548 void select_UV_quantiser ( PB_INSTANCE *pbi ){
549   pbi->fquant_coeffs = pbi->fp_quant_UV_coeffs;
550   pbi->fquant_round = pbi->fp_quant_UV_round;
551   pbi->fquant_ZbSize = pbi->fp_quant_UV_round;
552 }
553
554 void select_InterUV_quantiser ( PB_INSTANCE *pbi ){
555   pbi->fquant_coeffs = pbi->fp_quant_InterUV_coeffs;
556   pbi->fquant_round = pbi->fp_quant_InterUV_round;
557   pbi->fquant_ZbSize = pbi->fp_ZeroBinSize_InterUV;
558 }
559
560 void quantize( PB_INSTANCE *pbi,
561                ogg_int16_t * DCT_block,
562                Q_LIST_ENTRY * quantized_list){
563   ogg_uint32_t          i;              /*      Row index */
564   Q_LIST_ENTRY  val;            /* Quantised value. */
565
566   ogg_int32_t * FquantRoundPtr = pbi->fquant_round;
567   ogg_int32_t * FquantCoeffsPtr = pbi->fquant_coeffs;
568   ogg_int32_t * FquantZBinSizePtr = pbi->fquant_ZbSize;
569   ogg_int16_t * DCT_blockPtr = DCT_block;
570   ogg_uint32_t * QIndexPtr = (ogg_uint32_t *)pbi->quant_index;
571   ogg_int32_t temp;
572
573   /* Set the quantized_list to default to 0 */
574   memset( quantized_list, 0, 64 * sizeof(Q_LIST_ENTRY) );
575
576   /* Note that we add half divisor to effect rounding on positive number */
577   for( i = 0; i < VFRAGPIXELS; i++) {
578     /* Column 0  */
579     if ( DCT_blockPtr[0] >= FquantZBinSizePtr[0] ) {
580       temp = FquantCoeffsPtr[0] * ( DCT_blockPtr[0] + FquantRoundPtr[0] ) ;
581       val = (Q_LIST_ENTRY) (temp>>16);
582       quantized_list[QIndexPtr[0]] = ( val > 511 ) ? 511 : val;
583     } else if ( DCT_blockPtr[0] <= -FquantZBinSizePtr[0] ) {
584       temp = FquantCoeffsPtr[0] *
585         ( DCT_blockPtr[0] - FquantRoundPtr[0] ) + MIN16;
586       val = (Q_LIST_ENTRY) (temp>>16);
587       quantized_list[QIndexPtr[0]] = ( val < -511 ) ? -511 : val;
588     }
589
590     /* Column 1 */
591     if ( DCT_blockPtr[1] >= FquantZBinSizePtr[1] ) {
592       temp = FquantCoeffsPtr[1] *
593         ( DCT_blockPtr[1] + FquantRoundPtr[1] ) ;
594       val = (Q_LIST_ENTRY) (temp>>16);
595       quantized_list[QIndexPtr[1]] = ( val > 511 ) ? 511 : val;
596     } else if ( DCT_blockPtr[1] <= -FquantZBinSizePtr[1] ) {
597       temp = FquantCoeffsPtr[1] *
598         ( DCT_blockPtr[1] - FquantRoundPtr[1] ) + MIN16;
599       val = (Q_LIST_ENTRY) (temp>>16);
600       quantized_list[QIndexPtr[1]] = ( val < -511 ) ? -511 : val;
601     }
602
603     /* Column 2 */
604     if ( DCT_blockPtr[2] >= FquantZBinSizePtr[2] ) {
605       temp = FquantCoeffsPtr[2] *
606         ( DCT_blockPtr[2] + FquantRoundPtr[2] ) ;
607       val = (Q_LIST_ENTRY) (temp>>16);
608       quantized_list[QIndexPtr[2]] = ( val > 511 ) ? 511 : val;
609     } else if ( DCT_blockPtr[2] <= -FquantZBinSizePtr[2] ) {
610       temp = FquantCoeffsPtr[2] *
611         ( DCT_blockPtr[2] - FquantRoundPtr[2] ) + MIN16;
612       val = (Q_LIST_ENTRY) (temp>>16);
613       quantized_list[QIndexPtr[2]] = ( val < -511 ) ? -511 : val;
614     }
615
616     /* Column 3 */
617     if ( DCT_blockPtr[3] >= FquantZBinSizePtr[3] ) {
618       temp = FquantCoeffsPtr[3] *
619         ( DCT_blockPtr[3] + FquantRoundPtr[3] ) ;
620       val = (Q_LIST_ENTRY) (temp>>16);
621       quantized_list[QIndexPtr[3]] = ( val > 511 ) ? 511 : val;
622     } else if ( DCT_blockPtr[3] <= -FquantZBinSizePtr[3] ) {
623       temp = FquantCoeffsPtr[3] *
624         ( DCT_blockPtr[3] - FquantRoundPtr[3] ) + MIN16;
625       val = (Q_LIST_ENTRY) (temp>>16);
626       quantized_list[QIndexPtr[3]] = ( val < -511 ) ? -511 : val;
627     }
628
629     /* Column 4 */
630     if ( DCT_blockPtr[4] >= FquantZBinSizePtr[4] ) {
631       temp = FquantCoeffsPtr[4] *
632         ( DCT_blockPtr[4] + FquantRoundPtr[4] ) ;
633       val = (Q_LIST_ENTRY) (temp>>16);
634       quantized_list[QIndexPtr[4]] = ( val > 511 ) ? 511 : val;
635     } else if ( DCT_blockPtr[4] <= -FquantZBinSizePtr[4] ) {
636       temp = FquantCoeffsPtr[4] *
637         ( DCT_blockPtr[4] - FquantRoundPtr[4] ) + MIN16;
638       val = (Q_LIST_ENTRY) (temp>>16);
639       quantized_list[QIndexPtr[4]] = ( val < -511 ) ? -511 : val;
640     }
641
642     /* Column 5 */
643     if ( DCT_blockPtr[5] >= FquantZBinSizePtr[5] ) {
644       temp = FquantCoeffsPtr[5] *
645         ( DCT_blockPtr[5] + FquantRoundPtr[5] ) ;
646       val = (Q_LIST_ENTRY) (temp>>16);
647       quantized_list[QIndexPtr[5]] = ( val > 511 ) ? 511 : val;
648     } else if ( DCT_blockPtr[5] <= -FquantZBinSizePtr[5] ) {
649       temp = FquantCoeffsPtr[5] *
650         ( DCT_blockPtr[5] - FquantRoundPtr[5] ) + MIN16;
651       val = (Q_LIST_ENTRY) (temp>>16);
652       quantized_list[QIndexPtr[5]] = ( val < -511 ) ? -511 : val;
653     }
654
655     /* Column 6 */
656     if ( DCT_blockPtr[6] >= FquantZBinSizePtr[6] ) {
657       temp = FquantCoeffsPtr[6] *
658         ( DCT_blockPtr[6] + FquantRoundPtr[6] ) ;
659       val = (Q_LIST_ENTRY) (temp>>16);
660       quantized_list[QIndexPtr[6]] = ( val > 511 ) ? 511 : val;
661     } else if ( DCT_blockPtr[6] <= -FquantZBinSizePtr[6] ) {
662       temp = FquantCoeffsPtr[6] *
663         ( DCT_blockPtr[6] - FquantRoundPtr[6] ) + MIN16;
664       val = (Q_LIST_ENTRY) (temp>>16);
665       quantized_list[QIndexPtr[6]] = ( val < -511 ) ? -511 : val;
666     }
667
668     /* Column 7 */
669     if ( DCT_blockPtr[7] >= FquantZBinSizePtr[7] ) {
670       temp = FquantCoeffsPtr[7] *
671         ( DCT_blockPtr[7] + FquantRoundPtr[7] ) ;
672       val = (Q_LIST_ENTRY) (temp>>16);
673       quantized_list[QIndexPtr[7]] = ( val > 511 ) ? 511 : val;
674     } else if ( DCT_blockPtr[7] <= -FquantZBinSizePtr[7] ) {
675       temp = FquantCoeffsPtr[7] *
676         ( DCT_blockPtr[7] - FquantRoundPtr[7] ) + MIN16;
677       val = (Q_LIST_ENTRY) (temp>>16);
678       quantized_list[QIndexPtr[7]] = ( val < -511 ) ? -511 : val;
679     }
680
681     FquantRoundPtr += 8;
682     FquantCoeffsPtr += 8;
683     FquantZBinSizePtr += 8;
684     DCT_blockPtr += 8;
685     QIndexPtr += 8;
686   }
687 }
688
689 static void init_dequantizer ( PB_INSTANCE *pbi,
690                         ogg_uint32_t scale_factor,
691                         unsigned char  QIndex ){
692   int i, j;
693
694   Q_LIST_ENTRY * Inter_coeffs;
695   Q_LIST_ENTRY * Y_coeffs;
696   Q_LIST_ENTRY * UV_coeffs;
697   Q_LIST_ENTRY * DcScaleFactorTable;
698   Q_LIST_ENTRY * UVDcScaleFactorTable;
699
700   Inter_coeffs = pbi->Inter_coeffs;
701   Y_coeffs = pbi->Y_coeffs;
702   UV_coeffs = pbi->UV_coeffs;
703   DcScaleFactorTable = pbi->DcScaleFactorTable;
704   UVDcScaleFactorTable = pbi->DcScaleFactorTable;
705
706   /* invert the dequant index into the quant index
707      the dxer has a different order than the cxer. */
708   BuildQuantIndex_Generic(pbi);
709
710   /* Reorder dequantisation coefficients into dct zigzag order. */
711   for ( i = 0; i < BLOCK_SIZE; i++ ) {
712     j = pbi->quant_index[i];
713     pbi->dequant_Y_coeffs[j] = Y_coeffs[i];
714   }
715   for ( i = 0; i < BLOCK_SIZE; i++ ){
716     j = pbi->quant_index[i];
717     pbi->dequant_Inter_coeffs[j] = Inter_coeffs[i];
718   }
719   for ( i = 0; i < BLOCK_SIZE; i++ ){
720     j = pbi->quant_index[i];
721     pbi->dequant_UV_coeffs[j] = UV_coeffs[i];
722   }
723   for ( i = 0; i < BLOCK_SIZE; i++ ){
724     j = pbi->quant_index[i];
725     pbi->dequant_InterUV_coeffs[j] = Inter_coeffs[i];
726   }
727
728   /* Intra Y */
729   pbi->dequant_Y_coeffs[0] =
730     ((DcScaleFactorTable[QIndex] * pbi->dequant_Y_coeffs[0])/100);
731   if ( pbi->dequant_Y_coeffs[0] < MIN_DEQUANT_VAL * 2 )
732     pbi->dequant_Y_coeffs[0] = MIN_DEQUANT_VAL * 2;
733   pbi->dequant_Y_coeffs[0] =
734     pbi->dequant_Y_coeffs[0] << IDCT_SCALE_FACTOR;
735
736   /* Intra UV */
737   pbi->dequant_UV_coeffs[0] =
738     ((UVDcScaleFactorTable[QIndex] * pbi->dequant_UV_coeffs[0])/100);
739   if ( pbi->dequant_UV_coeffs[0] < MIN_DEQUANT_VAL * 2 )
740     pbi->dequant_UV_coeffs[0] = MIN_DEQUANT_VAL * 2;
741   pbi->dequant_UV_coeffs[0] =
742     pbi->dequant_UV_coeffs[0] << IDCT_SCALE_FACTOR;
743
744   /* Inter Y */
745   pbi->dequant_Inter_coeffs[0] =
746     ((DcScaleFactorTable[QIndex] * pbi->dequant_Inter_coeffs[0])/100);
747   if ( pbi->dequant_Inter_coeffs[0] < MIN_DEQUANT_VAL * 4 )
748     pbi->dequant_Inter_coeffs[0] = MIN_DEQUANT_VAL * 4;
749   pbi->dequant_Inter_coeffs[0] =
750     pbi->dequant_Inter_coeffs[0] << IDCT_SCALE_FACTOR;
751
752   /* Inter UV */
753   pbi->dequant_InterUV_coeffs[0] =
754     ((UVDcScaleFactorTable[QIndex] * pbi->dequant_InterUV_coeffs[0])/100);
755   if ( pbi->dequant_InterUV_coeffs[0] < MIN_DEQUANT_VAL * 4 )
756     pbi->dequant_InterUV_coeffs[0] = MIN_DEQUANT_VAL * 4;
757   pbi->dequant_InterUV_coeffs[0] =
758     pbi->dequant_InterUV_coeffs[0] << IDCT_SCALE_FACTOR;
759
760   for ( i = 1; i < 64; i++ ){
761     /* now scale coefficients by required compression factor */
762     pbi->dequant_Y_coeffs[i] =
763       (( scale_factor * pbi->dequant_Y_coeffs[i] ) / 100);
764     if ( pbi->dequant_Y_coeffs[i] < MIN_DEQUANT_VAL )
765       pbi->dequant_Y_coeffs[i] = MIN_DEQUANT_VAL;
766     pbi->dequant_Y_coeffs[i] =
767       pbi->dequant_Y_coeffs[i] << IDCT_SCALE_FACTOR;
768
769     pbi->dequant_UV_coeffs[i] =
770       (( scale_factor * pbi->dequant_UV_coeffs[i] ) / 100);
771     if ( pbi->dequant_UV_coeffs[i] < MIN_DEQUANT_VAL )
772       pbi->dequant_UV_coeffs[i] = MIN_DEQUANT_VAL;
773     pbi->dequant_UV_coeffs[i] =
774       pbi->dequant_UV_coeffs[i] << IDCT_SCALE_FACTOR;
775
776     pbi->dequant_Inter_coeffs[i] =
777       (( scale_factor * pbi->dequant_Inter_coeffs[i] ) / 100);
778     if ( pbi->dequant_Inter_coeffs[i] < (MIN_DEQUANT_VAL * 2) )
779       pbi->dequant_Inter_coeffs[i] = MIN_DEQUANT_VAL * 2;
780     pbi->dequant_Inter_coeffs[i] =
781       pbi->dequant_Inter_coeffs[i] << IDCT_SCALE_FACTOR;
782
783     pbi->dequant_InterUV_coeffs[i] =
784       (( scale_factor * pbi->dequant_InterUV_coeffs[i] ) / 100);
785     if ( pbi->dequant_InterUV_coeffs[i] < (MIN_DEQUANT_VAL * 2) )
786       pbi->dequant_InterUV_coeffs[i] = MIN_DEQUANT_VAL * 2;
787     pbi->dequant_InterUV_coeffs[i] =
788       pbi->dequant_InterUV_coeffs[i] << IDCT_SCALE_FACTOR;
789   }
790
791   pbi->dequant_coeffs = pbi->dequant_Y_coeffs;
792 }
793
794 void UpdateQ( PB_INSTANCE *pbi, ogg_uint32_t NewQ ){
795   ogg_uint32_t qscale;
796
797   /* Do bounds checking and convert to a float. */
798   qscale = NewQ;
799   if ( qscale < pbi->QThreshTable[Q_TABLE_SIZE-1] )
800     qscale = pbi->QThreshTable[Q_TABLE_SIZE-1];
801   else if ( qscale > pbi->QThreshTable[0] )
802     qscale = pbi->QThreshTable[0];
803
804   /* Set the inter/intra descision control variables. */
805   pbi->FrameQIndex = Q_TABLE_SIZE - 1;
806   while ( (ogg_int32_t) pbi->FrameQIndex >= 0 ) {
807     if ( (pbi->FrameQIndex == 0) ||
808          ( pbi->QThreshTable[pbi->FrameQIndex] >= NewQ) )
809       break;
810     pbi->FrameQIndex --;
811   }
812
813   /* Re-initialise the q tables for forward and reverse transforms. */
814   init_dequantizer ( pbi, qscale, (unsigned char) pbi->FrameQIndex );
815 }
816
817 void UpdateQC( CP_INSTANCE *cpi, ogg_uint32_t NewQ ){
818   ogg_uint32_t qscale;
819   PB_INSTANCE *pbi = &cpi->pb;
820
821   /* Do bounds checking and convert to a float.  */
822   qscale = NewQ;
823   if ( qscale < pbi->QThreshTable[Q_TABLE_SIZE-1] )
824     qscale = pbi->QThreshTable[Q_TABLE_SIZE-1];
825   else if ( qscale > pbi->QThreshTable[0] )
826     qscale = pbi->QThreshTable[0];
827
828   /* Set the inter/intra descision control variables. */
829   pbi->FrameQIndex = Q_TABLE_SIZE - 1;
830   while ((ogg_int32_t) pbi->FrameQIndex >= 0 ) {
831     if ( (pbi->FrameQIndex == 0) ||
832          ( pbi->QThreshTable[pbi->FrameQIndex] >= NewQ) )
833       break;
834     pbi->FrameQIndex --;
835   }
836
837   /* Re-initialise the q tables for forward and reverse transforms. */
838   init_quantizer ( cpi, qscale, (unsigned char) pbi->FrameQIndex );
839   init_dequantizer ( pbi, qscale, (unsigned char) pbi->FrameQIndex );
840 }