Remeber the range table for the quant matricies from the setup header.
[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-2005                *
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,
172          int N, int type) 
173 {
174   int index, range;
175   int qi = 0;
176   int count = 0;
177   qmat_range_table table[65];
178
179   theora_read(opb,_ilog(N-1),&index); /* qi=0 index */
180   table[count].startqi = 0;
181   table[count++].qmat = ci->qmats + index * Q_TABLE_SIZE;
182   //fprintf(stderr, " [%d]",index);
183   while(qi<63) {
184     theora_read(opb,_ilog(62-qi),&range); /* range to next code q matrix */
185     range++;
186     //fprintf(stderr," %d",range);
187     if(range<=0) return OC_BADHEADER;
188     qi+=range;
189     theora_read(opb,_ilog(N-1),&index); /* next index */
190     table[count].startqi = qi;
191     table[count++].qmat = ci->qmats + index * Q_TABLE_SIZE;
192     //fprintf(stderr, " [%d]",index);
193   }
194
195   ci->range_table[type] = _ogg_malloc(count * sizeof(qmat_range_table));
196   if (ci->range_table[type] != NULL) {
197     memcpy(&ci->range_table[type], table, count * sizeof(qmat_range_table)); 
198     return 0;
199   }
200   
201   return OC_FAULT; /* allocation failed */
202 }
203
204 int ReadQTables(codec_setup_info *ci, oggpack_buffer* opb) {
205   long bits,value;
206   int x,y, N;
207   //fprintf(stderr, "Reading Q tables...\n");
208   /* AC scale table */
209   theora_read(opb,4,&bits); bits++;
210   for(x=0; x<Q_TABLE_SIZE; x++) {
211     theora_read(opb,bits,&value);
212     if(bits<0)return OC_BADHEADER;
213     ci->QThreshTable[x]=value;
214   }
215   /* DC scale table */
216   theora_read(opb,4,&bits); bits++;
217   for(x=0; x<Q_TABLE_SIZE; x++) {
218     theora_read(opb,bits,&value);
219     if(bits<0)return OC_BADHEADER;
220     ci->DcScaleFactorTable[x]=(Q_LIST_ENTRY)value;
221   }
222   /* base matricies */
223   theora_read(opb,9,&N); N++;
224   //fprintf(stderr, "  max q matrix index %d\n", N);
225   if(N!=3)return OC_BADHEADER; /* we only support the VP3 config */
226   ci->qmats=_ogg_malloc(N*64*sizeof(Q_LIST_ENTRY));
227   ci->MaxQMatrixIndex = N;
228   for(y=0; y<N; y++) {
229     //fprintf(stderr," q matrix %d:\n  ", y);
230     for(x=0; x<64; x++) {
231       theora_read(opb,8,&value);
232       if(bits<0)return OC_BADHEADER;
233       ci->qmats[(y<<6)+x]=(Q_LIST_ENTRY)value;
234       //fprintf(stderr," %03d", (Q_LIST_ENTRY)value);
235       //if((x+1)%8==0)fprintf(stderr,"\n  ");
236     }
237     //fprintf(stderr,"\n");
238   }
239   /* table mapping */
240   for(x=0; x<6; x++) {
241     ci->range_table[x] = NULL;
242   }
243   {
244     int flag, ret;
245     /* intra Y */
246     //fprintf(stderr,"\n Intra Y:");
247     if((ret=_read_qtable_range(ci,opb,N,0))<0) return ret;
248     /* intra U */
249     //fprintf(stderr, "\n Intra U:");
250     theora_read(opb,1,&flag);
251     if(flag<0) return OC_BADHEADER;
252     if(flag) {
253       /* explicitly coded */
254       if((ret=_read_qtable_range(ci,opb,N,1))<0) return ret;
255     } else {
256       /* same as previous */
257       //fprintf(stderr," same as above");
258     }
259     /* intra V */
260     //fprintf(stderr,"\n Intra V:");
261     theora_read(opb,1,&flag);
262     if(flag<0) return OC_BADHEADER;
263     if(flag) {
264       /* explicitly coded */
265       if((ret=_read_qtable_range(ci,opb,N,2))<0) return ret;
266     } else {
267        /* same as previous */
268       //fprintf(stderr," same as above");
269     }
270     /* inter Y */
271     //fprintf(stderr,"\n Inter Y:");
272     theora_read(opb,1,&flag);
273     if(flag<0) return OC_BADHEADER;
274     if(flag) {
275       /* explicitly coded */
276       if((ret=_read_qtable_range(ci,opb,N,3))<0) return ret;
277     } else {
278       theora_read(opb,1,&flag);
279       if(flag<0) return OC_BADHEADER;
280       if(flag) {
281         /* same as corresponding intra */
282         //fprintf(stderr," same as intra");
283       } else {
284         /* same as previous */
285         //fprintf(stderr," same as above");
286       }
287     }
288     /* inter U */
289     //fprintf(stderr,"\n Inter U:");
290     theora_read(opb,1,&flag);
291     if(flag<0) return OC_BADHEADER;
292     if(flag) {
293       /* explicitly coded */
294       if((ret=_read_qtable_range(ci,opb,N,4))<0) return ret;
295     } else {
296       theora_read(opb,1,&flag);
297       if(flag<0) return OC_BADHEADER;
298       if(flag) {
299         /* same as corresponding intra */
300         //fprintf(stderr," same as intra");
301       } else {
302         /* same as previous */
303         //fprintf(stderr," same as above");
304       }
305     }
306     /* inter V */
307     //fprintf(stderr,"\n Inter V:");
308     theora_read(opb,1,&flag);
309     if(flag<0) return OC_BADHEADER;
310     if(flag) {
311       /* explicitly coded */
312       if((ret=_read_qtable_range(ci,opb,N,5))<0) return ret;
313     } else {
314       theora_read(opb,1,&flag);
315       if(flag<0) return OC_BADHEADER;
316       if(flag) {
317         /* same as corresponding intra */
318         //fprintf(stderr," same as intra");
319       } else {
320         /* same as previous */
321         //fprintf(stderr," same as above");
322       }
323     }
324     //fprintf(stderr,"\n");
325   }
326   
327   /* ignore the range table and reference the matricies we use */
328   memcpy(ci->Y_coeffs, &ci->qmats[0], sizeof(ci->Y_coeffs));
329   memcpy(ci->UV_coeffs, &ci->qmats[64], sizeof(ci->UV_coeffs));
330   memcpy(ci->Inter_coeffs, &ci->qmats[2*64], sizeof(ci->Inter_coeffs));
331
332   return 0;
333 }
334
335 void CopyQTables(PB_INSTANCE *pbi, codec_setup_info *ci) {
336   memcpy(pbi->QThreshTable, ci->QThreshTable, sizeof(pbi->QThreshTable));
337   memcpy(pbi->DcScaleFactorTable, ci->DcScaleFactorTable,
338          sizeof(pbi->DcScaleFactorTable));
339   memcpy(pbi->Y_coeffs, ci->Y_coeffs, sizeof(pbi->Y_coeffs));
340   memcpy(pbi->UV_coeffs, ci->UV_coeffs, sizeof(pbi->UV_coeffs));
341   memcpy(pbi->Inter_coeffs, ci->Inter_coeffs, sizeof(pbi->Inter_coeffs));
342 }
343
344 /* Initialize custom qtables using the VP31 values.
345    Someday we can change the quant tables to be adaptive, or just plain
346     better.*/
347 void InitQTables( PB_INSTANCE *pbi ){
348   memcpy(pbi->QThreshTable, QThreshTableV1, sizeof(pbi->QThreshTable));
349   memcpy(pbi->DcScaleFactorTable, DcScaleFactorTableV1,
350          sizeof(pbi->DcScaleFactorTable));
351   memcpy(pbi->Y_coeffs, Y_coeffsV1, sizeof(pbi->Y_coeffs));
352   memcpy(pbi->UV_coeffs, UV_coeffsV1, sizeof(pbi->UV_coeffs));
353   memcpy(pbi->Inter_coeffs, Inter_coeffsV1, sizeof(pbi->Inter_coeffs));
354 }
355
356 static void BuildQuantIndex_Generic(PB_INSTANCE *pbi){
357   ogg_int32_t i,j;
358
359   /* invert the dequant index into the quant index */
360   for ( i = 0; i < BLOCK_SIZE; i++ ){
361     j = dequant_index[i];
362     pbi->quant_index[j] = i;
363   }
364 }
365
366 static void init_quantizer ( CP_INSTANCE *cpi,
367                       ogg_uint32_t scale_factor,
368                       unsigned char QIndex ){
369     int i;
370     double ZBinFactor;
371     double RoundingFactor;
372
373     double temp_fp_quant_coeffs;
374     double temp_fp_quant_round;
375     double temp_fp_ZeroBinSize;
376     PB_INSTANCE *pbi = &cpi->pb;
377
378     const Q_LIST_ENTRY * Inter_coeffs;
379     const Q_LIST_ENTRY * Y_coeffs;
380     const Q_LIST_ENTRY * UV_coeffs;
381     const Q_LIST_ENTRY * DcScaleFactorTable;
382     const Q_LIST_ENTRY * UVDcScaleFactorTable;
383
384     /* Notes on setup of quantisers.  The initial multiplication by
385      the scale factor is done in the ogg_int32_t domain to insure that the
386      precision in the quantiser is the same as in the inverse
387      quantiser where all calculations are integer.  The "<< 2" is a
388      normalisation factor for the forward DCT transform. */
389
390     /* New version rounding and ZB characteristics. */
391     Inter_coeffs = Inter_coeffsV1;
392     Y_coeffs = Y_coeffsV1;
393     UV_coeffs = UV_coeffsV1;
394     DcScaleFactorTable = DcScaleFactorTableV1;
395     UVDcScaleFactorTable = DcScaleFactorTableV1;
396     ZBinFactor = 0.9;
397
398     switch(cpi->pb.info.sharpness){
399     case 0:
400       ZBinFactor = 0.65;
401       if ( scale_factor <= 50 )
402         RoundingFactor = 0.499;
403       else
404         RoundingFactor = 0.46;
405       break;
406     case 1:
407       ZBinFactor = 0.75;
408       if ( scale_factor <= 50 )
409         RoundingFactor = 0.476;
410       else
411         RoundingFactor = 0.400;
412       break;
413
414     default:
415       ZBinFactor = 0.9;
416       if ( scale_factor <= 50 )
417         RoundingFactor = 0.476;
418       else
419         RoundingFactor = 0.333;
420       break;
421     }
422
423     /* Use fixed multiplier for intra Y DC */
424     temp_fp_quant_coeffs =
425       (((ogg_uint32_t)(DcScaleFactorTable[QIndex] * Y_coeffs[0])/100) << 2);
426     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 2 )
427       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 2;
428
429     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
430     pbi->fp_quant_Y_round[0]    = (ogg_int32_t) (0.5 + temp_fp_quant_round);
431
432     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
433     pbi->fp_ZeroBinSize_Y[0]    = (ogg_int32_t) (0.5 + temp_fp_ZeroBinSize);
434
435     temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
436     pbi->fp_quant_Y_coeffs[0]   = (0.5 + SHIFT16 * temp_fp_quant_coeffs);
437
438     /* Intra UV */
439     temp_fp_quant_coeffs =
440       (((ogg_uint32_t)(UVDcScaleFactorTable[QIndex] * UV_coeffs[0])/100) << 2);
441     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 2)
442       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 2;
443
444     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
445     pbi->fp_quant_UV_round[0]   = (0.5 + temp_fp_quant_round);
446
447     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
448     pbi->fp_ZeroBinSize_UV[0]   = (0.5 + temp_fp_ZeroBinSize);
449
450     temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
451     pbi->fp_quant_UV_coeffs[0]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
452
453     /* Inter Y */
454     temp_fp_quant_coeffs =
455       (((ogg_uint32_t)(DcScaleFactorTable[QIndex] * Inter_coeffs[0])/100) << 2);
456     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 4)
457       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 4;
458
459     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
460     pbi->fp_quant_Inter_round[0]= (0.5 + temp_fp_quant_round);
461
462     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
463     pbi->fp_ZeroBinSize_Inter[0]= (0.5 + temp_fp_ZeroBinSize);
464
465     temp_fp_quant_coeffs= 1.0 / temp_fp_quant_coeffs;
466     pbi->fp_quant_Inter_coeffs[0]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
467
468     /* Inter UV */
469     temp_fp_quant_coeffs =
470       (((ogg_uint32_t)(UVDcScaleFactorTable[QIndex] * Inter_coeffs[0])/100) << 2);
471     if ( temp_fp_quant_coeffs < MIN_LEGAL_QUANT_ENTRY * 4)
472       temp_fp_quant_coeffs = MIN_LEGAL_QUANT_ENTRY * 4;
473
474     temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
475     pbi->fp_quant_InterUV_round[0]= (0.5 + temp_fp_quant_round);
476
477     temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
478     pbi->fp_ZeroBinSize_InterUV[0]= (0.5 + temp_fp_ZeroBinSize);
479
480     temp_fp_quant_coeffs= 1.0 / temp_fp_quant_coeffs;
481     pbi->fp_quant_InterUV_coeffs[0]=
482       (0.5 + SHIFT16 * temp_fp_quant_coeffs);
483
484     for ( i = 1; i < 64; i++ ){
485       /* now scale coefficients by required compression factor */
486       /* Intra Y */
487       temp_fp_quant_coeffs =
488         (((ogg_uint32_t)(scale_factor * Y_coeffs[i]) / 100 ) << 2 );
489       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY) )
490         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY);
491
492       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
493       pbi->fp_quant_Y_round[i]  = (0.5 + temp_fp_quant_round);
494
495       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
496       pbi->fp_ZeroBinSize_Y[i]  = (0.5 + temp_fp_ZeroBinSize);
497
498       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
499       pbi->fp_quant_Y_coeffs[i] = (0.5 + SHIFT16 * temp_fp_quant_coeffs);
500
501       /* Intra UV */
502       temp_fp_quant_coeffs =
503         (((ogg_uint32_t)(scale_factor * UV_coeffs[i]) / 100 ) << 2 );
504       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY))
505         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY);
506
507       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
508       pbi->fp_quant_UV_round[i] = (0.5 + temp_fp_quant_round);
509
510       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
511       pbi->fp_ZeroBinSize_UV[i] = (0.5 + temp_fp_ZeroBinSize);
512
513       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
514       pbi->fp_quant_UV_coeffs[i]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
515
516       /* Inter Y */
517       temp_fp_quant_coeffs =
518         (((ogg_uint32_t)(scale_factor * Inter_coeffs[i]) / 100 ) << 2 );
519       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY * 2) )
520         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY * 2);
521
522       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
523       pbi->fp_quant_Inter_round[i]= (0.5 + temp_fp_quant_round);
524
525       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
526       pbi->fp_ZeroBinSize_Inter[i]= (0.5 + temp_fp_ZeroBinSize);
527
528       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
529       pbi->fp_quant_Inter_coeffs[i]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
530
531       /* Inter UV */
532       temp_fp_quant_coeffs =
533         (((ogg_uint32_t)(scale_factor * Inter_coeffs[i]) / 100 ) << 2 );
534       if ( temp_fp_quant_coeffs < (MIN_LEGAL_QUANT_ENTRY * 2) )
535         temp_fp_quant_coeffs = (MIN_LEGAL_QUANT_ENTRY * 2);
536
537       temp_fp_quant_round = temp_fp_quant_coeffs * RoundingFactor;
538       pbi->fp_quant_InterUV_round[i]= (0.5 + temp_fp_quant_round);
539
540       temp_fp_ZeroBinSize = temp_fp_quant_coeffs * ZBinFactor;
541       pbi->fp_ZeroBinSize_InterUV[i]= (0.5 + temp_fp_ZeroBinSize);
542
543       temp_fp_quant_coeffs = 1.0 / temp_fp_quant_coeffs;
544       pbi->fp_quant_InterUV_coeffs[i]= (0.5 + SHIFT16 * temp_fp_quant_coeffs);
545
546     }
547
548     pbi->fquant_coeffs = pbi->fp_quant_Y_coeffs;
549
550 }
551
552 void select_Y_quantiser ( PB_INSTANCE *pbi ){
553   pbi->fquant_coeffs = pbi->fp_quant_Y_coeffs;
554   pbi->fquant_round = pbi->fp_quant_Y_round;
555   pbi->fquant_ZbSize = pbi->fp_ZeroBinSize_Y;
556 }
557
558 void select_Inter_quantiser ( PB_INSTANCE *pbi ){
559   pbi->fquant_coeffs = pbi->fp_quant_Inter_coeffs;
560   pbi->fquant_round = pbi->fp_quant_Inter_round;
561   pbi->fquant_ZbSize = pbi->fp_ZeroBinSize_Inter;
562 }
563
564 void select_UV_quantiser ( PB_INSTANCE *pbi ){
565   pbi->fquant_coeffs = pbi->fp_quant_UV_coeffs;
566   pbi->fquant_round = pbi->fp_quant_UV_round;
567   pbi->fquant_ZbSize = pbi->fp_quant_UV_round;
568 }
569
570 void select_InterUV_quantiser ( PB_INSTANCE *pbi ){
571   pbi->fquant_coeffs = pbi->fp_quant_InterUV_coeffs;
572   pbi->fquant_round = pbi->fp_quant_InterUV_round;
573   pbi->fquant_ZbSize = pbi->fp_ZeroBinSize_InterUV;
574 }
575
576 void quantize( PB_INSTANCE *pbi,
577                ogg_int16_t * DCT_block,
578                Q_LIST_ENTRY * quantized_list){
579   ogg_uint32_t          i;              /*      Row index */
580   Q_LIST_ENTRY  val;            /* Quantised value. */
581
582   ogg_int32_t * FquantRoundPtr = pbi->fquant_round;
583   ogg_int32_t * FquantCoeffsPtr = pbi->fquant_coeffs;
584   ogg_int32_t * FquantZBinSizePtr = pbi->fquant_ZbSize;
585   ogg_int16_t * DCT_blockPtr = DCT_block;
586   ogg_uint32_t * QIndexPtr = (ogg_uint32_t *)pbi->quant_index;
587   ogg_int32_t temp;
588
589   /* Set the quantized_list to default to 0 */
590   memset( quantized_list, 0, 64 * sizeof(Q_LIST_ENTRY) );
591
592   /* Note that we add half divisor to effect rounding on positive number */
593   for( i = 0; i < VFRAGPIXELS; i++) {
594     /* Column 0  */
595     if ( DCT_blockPtr[0] >= FquantZBinSizePtr[0] ) {
596       temp = FquantCoeffsPtr[0] * ( DCT_blockPtr[0] + FquantRoundPtr[0] ) ;
597       val = (Q_LIST_ENTRY) (temp>>16);
598       quantized_list[QIndexPtr[0]] = ( val > 511 ) ? 511 : val;
599     } else if ( DCT_blockPtr[0] <= -FquantZBinSizePtr[0] ) {
600       temp = FquantCoeffsPtr[0] *
601         ( DCT_blockPtr[0] - FquantRoundPtr[0] ) + MIN16;
602       val = (Q_LIST_ENTRY) (temp>>16);
603       quantized_list[QIndexPtr[0]] = ( val < -511 ) ? -511 : val;
604     }
605
606     /* Column 1 */
607     if ( DCT_blockPtr[1] >= FquantZBinSizePtr[1] ) {
608       temp = FquantCoeffsPtr[1] *
609         ( DCT_blockPtr[1] + FquantRoundPtr[1] ) ;
610       val = (Q_LIST_ENTRY) (temp>>16);
611       quantized_list[QIndexPtr[1]] = ( val > 511 ) ? 511 : val;
612     } else if ( DCT_blockPtr[1] <= -FquantZBinSizePtr[1] ) {
613       temp = FquantCoeffsPtr[1] *
614         ( DCT_blockPtr[1] - FquantRoundPtr[1] ) + MIN16;
615       val = (Q_LIST_ENTRY) (temp>>16);
616       quantized_list[QIndexPtr[1]] = ( val < -511 ) ? -511 : val;
617     }
618
619     /* Column 2 */
620     if ( DCT_blockPtr[2] >= FquantZBinSizePtr[2] ) {
621       temp = FquantCoeffsPtr[2] *
622         ( DCT_blockPtr[2] + FquantRoundPtr[2] ) ;
623       val = (Q_LIST_ENTRY) (temp>>16);
624       quantized_list[QIndexPtr[2]] = ( val > 511 ) ? 511 : val;
625     } else if ( DCT_blockPtr[2] <= -FquantZBinSizePtr[2] ) {
626       temp = FquantCoeffsPtr[2] *
627         ( DCT_blockPtr[2] - FquantRoundPtr[2] ) + MIN16;
628       val = (Q_LIST_ENTRY) (temp>>16);
629       quantized_list[QIndexPtr[2]] = ( val < -511 ) ? -511 : val;
630     }
631
632     /* Column 3 */
633     if ( DCT_blockPtr[3] >= FquantZBinSizePtr[3] ) {
634       temp = FquantCoeffsPtr[3] *
635         ( DCT_blockPtr[3] + FquantRoundPtr[3] ) ;
636       val = (Q_LIST_ENTRY) (temp>>16);
637       quantized_list[QIndexPtr[3]] = ( val > 511 ) ? 511 : val;
638     } else if ( DCT_blockPtr[3] <= -FquantZBinSizePtr[3] ) {
639       temp = FquantCoeffsPtr[3] *
640         ( DCT_blockPtr[3] - FquantRoundPtr[3] ) + MIN16;
641       val = (Q_LIST_ENTRY) (temp>>16);
642       quantized_list[QIndexPtr[3]] = ( val < -511 ) ? -511 : val;
643     }
644
645     /* Column 4 */
646     if ( DCT_blockPtr[4] >= FquantZBinSizePtr[4] ) {
647       temp = FquantCoeffsPtr[4] *
648         ( DCT_blockPtr[4] + FquantRoundPtr[4] ) ;
649       val = (Q_LIST_ENTRY) (temp>>16);
650       quantized_list[QIndexPtr[4]] = ( val > 511 ) ? 511 : val;
651     } else if ( DCT_blockPtr[4] <= -FquantZBinSizePtr[4] ) {
652       temp = FquantCoeffsPtr[4] *
653         ( DCT_blockPtr[4] - FquantRoundPtr[4] ) + MIN16;
654       val = (Q_LIST_ENTRY) (temp>>16);
655       quantized_list[QIndexPtr[4]] = ( val < -511 ) ? -511 : val;
656     }
657
658     /* Column 5 */
659     if ( DCT_blockPtr[5] >= FquantZBinSizePtr[5] ) {
660       temp = FquantCoeffsPtr[5] *
661         ( DCT_blockPtr[5] + FquantRoundPtr[5] ) ;
662       val = (Q_LIST_ENTRY) (temp>>16);
663       quantized_list[QIndexPtr[5]] = ( val > 511 ) ? 511 : val;
664     } else if ( DCT_blockPtr[5] <= -FquantZBinSizePtr[5] ) {
665       temp = FquantCoeffsPtr[5] *
666         ( DCT_blockPtr[5] - FquantRoundPtr[5] ) + MIN16;
667       val = (Q_LIST_ENTRY) (temp>>16);
668       quantized_list[QIndexPtr[5]] = ( val < -511 ) ? -511 : val;
669     }
670
671     /* Column 6 */
672     if ( DCT_blockPtr[6] >= FquantZBinSizePtr[6] ) {
673       temp = FquantCoeffsPtr[6] *
674         ( DCT_blockPtr[6] + FquantRoundPtr[6] ) ;
675       val = (Q_LIST_ENTRY) (temp>>16);
676       quantized_list[QIndexPtr[6]] = ( val > 511 ) ? 511 : val;
677     } else if ( DCT_blockPtr[6] <= -FquantZBinSizePtr[6] ) {
678       temp = FquantCoeffsPtr[6] *
679         ( DCT_blockPtr[6] - FquantRoundPtr[6] ) + MIN16;
680       val = (Q_LIST_ENTRY) (temp>>16);
681       quantized_list[QIndexPtr[6]] = ( val < -511 ) ? -511 : val;
682     }
683
684     /* Column 7 */
685     if ( DCT_blockPtr[7] >= FquantZBinSizePtr[7] ) {
686       temp = FquantCoeffsPtr[7] *
687         ( DCT_blockPtr[7] + FquantRoundPtr[7] ) ;
688       val = (Q_LIST_ENTRY) (temp>>16);
689       quantized_list[QIndexPtr[7]] = ( val > 511 ) ? 511 : val;
690     } else if ( DCT_blockPtr[7] <= -FquantZBinSizePtr[7] ) {
691       temp = FquantCoeffsPtr[7] *
692         ( DCT_blockPtr[7] - FquantRoundPtr[7] ) + MIN16;
693       val = (Q_LIST_ENTRY) (temp>>16);
694       quantized_list[QIndexPtr[7]] = ( val < -511 ) ? -511 : val;
695     }
696
697     FquantRoundPtr += 8;
698     FquantCoeffsPtr += 8;
699     FquantZBinSizePtr += 8;
700     DCT_blockPtr += 8;
701     QIndexPtr += 8;
702   }
703 }
704
705 static void init_dequantizer ( PB_INSTANCE *pbi,
706                         ogg_uint32_t scale_factor,
707                         unsigned char  QIndex ){
708   int i, j;
709
710   Q_LIST_ENTRY * Inter_coeffs;
711   Q_LIST_ENTRY * Y_coeffs;
712   Q_LIST_ENTRY * UV_coeffs;
713   Q_LIST_ENTRY * DcScaleFactorTable;
714   Q_LIST_ENTRY * UVDcScaleFactorTable;
715
716   Inter_coeffs = pbi->Inter_coeffs;
717   Y_coeffs = pbi->Y_coeffs;
718   UV_coeffs = pbi->UV_coeffs;
719   DcScaleFactorTable = pbi->DcScaleFactorTable;
720   UVDcScaleFactorTable = pbi->DcScaleFactorTable;
721
722   /* invert the dequant index into the quant index
723      the dxer has a different order than the cxer. */
724   BuildQuantIndex_Generic(pbi);
725
726   /* Reorder dequantisation coefficients into dct zigzag order. */
727   for ( i = 0; i < BLOCK_SIZE; i++ ) {
728     j = pbi->quant_index[i];
729     pbi->dequant_Y_coeffs[j] = Y_coeffs[i];
730   }
731   for ( i = 0; i < BLOCK_SIZE; i++ ){
732     j = pbi->quant_index[i];
733     pbi->dequant_Inter_coeffs[j] = Inter_coeffs[i];
734   }
735   for ( i = 0; i < BLOCK_SIZE; i++ ){
736     j = pbi->quant_index[i];
737     pbi->dequant_UV_coeffs[j] = UV_coeffs[i];
738   }
739   for ( i = 0; i < BLOCK_SIZE; i++ ){
740     j = pbi->quant_index[i];
741     pbi->dequant_InterUV_coeffs[j] = Inter_coeffs[i];
742   }
743
744   /* Intra Y */
745   pbi->dequant_Y_coeffs[0] =
746     ((DcScaleFactorTable[QIndex] * pbi->dequant_Y_coeffs[0])/100);
747   if ( pbi->dequant_Y_coeffs[0] < MIN_DEQUANT_VAL * 2 )
748     pbi->dequant_Y_coeffs[0] = MIN_DEQUANT_VAL * 2;
749   pbi->dequant_Y_coeffs[0] =
750     pbi->dequant_Y_coeffs[0] << IDCT_SCALE_FACTOR;
751
752   /* Intra UV */
753   pbi->dequant_UV_coeffs[0] =
754     ((UVDcScaleFactorTable[QIndex] * pbi->dequant_UV_coeffs[0])/100);
755   if ( pbi->dequant_UV_coeffs[0] < MIN_DEQUANT_VAL * 2 )
756     pbi->dequant_UV_coeffs[0] = MIN_DEQUANT_VAL * 2;
757   pbi->dequant_UV_coeffs[0] =
758     pbi->dequant_UV_coeffs[0] << IDCT_SCALE_FACTOR;
759
760   /* Inter Y */
761   pbi->dequant_Inter_coeffs[0] =
762     ((DcScaleFactorTable[QIndex] * pbi->dequant_Inter_coeffs[0])/100);
763   if ( pbi->dequant_Inter_coeffs[0] < MIN_DEQUANT_VAL * 4 )
764     pbi->dequant_Inter_coeffs[0] = MIN_DEQUANT_VAL * 4;
765   pbi->dequant_Inter_coeffs[0] =
766     pbi->dequant_Inter_coeffs[0] << IDCT_SCALE_FACTOR;
767
768   /* Inter UV */
769   pbi->dequant_InterUV_coeffs[0] =
770     ((UVDcScaleFactorTable[QIndex] * pbi->dequant_InterUV_coeffs[0])/100);
771   if ( pbi->dequant_InterUV_coeffs[0] < MIN_DEQUANT_VAL * 4 )
772     pbi->dequant_InterUV_coeffs[0] = MIN_DEQUANT_VAL * 4;
773   pbi->dequant_InterUV_coeffs[0] =
774     pbi->dequant_InterUV_coeffs[0] << IDCT_SCALE_FACTOR;
775
776   for ( i = 1; i < 64; i++ ){
777     /* now scale coefficients by required compression factor */
778     pbi->dequant_Y_coeffs[i] =
779       (( scale_factor * pbi->dequant_Y_coeffs[i] ) / 100);
780     if ( pbi->dequant_Y_coeffs[i] < MIN_DEQUANT_VAL )
781       pbi->dequant_Y_coeffs[i] = MIN_DEQUANT_VAL;
782     pbi->dequant_Y_coeffs[i] =
783       pbi->dequant_Y_coeffs[i] << IDCT_SCALE_FACTOR;
784
785     pbi->dequant_UV_coeffs[i] =
786       (( scale_factor * pbi->dequant_UV_coeffs[i] ) / 100);
787     if ( pbi->dequant_UV_coeffs[i] < MIN_DEQUANT_VAL )
788       pbi->dequant_UV_coeffs[i] = MIN_DEQUANT_VAL;
789     pbi->dequant_UV_coeffs[i] =
790       pbi->dequant_UV_coeffs[i] << IDCT_SCALE_FACTOR;
791
792     pbi->dequant_Inter_coeffs[i] =
793       (( scale_factor * pbi->dequant_Inter_coeffs[i] ) / 100);
794     if ( pbi->dequant_Inter_coeffs[i] < (MIN_DEQUANT_VAL * 2) )
795       pbi->dequant_Inter_coeffs[i] = MIN_DEQUANT_VAL * 2;
796     pbi->dequant_Inter_coeffs[i] =
797       pbi->dequant_Inter_coeffs[i] << IDCT_SCALE_FACTOR;
798
799     pbi->dequant_InterUV_coeffs[i] =
800       (( scale_factor * pbi->dequant_InterUV_coeffs[i] ) / 100);
801     if ( pbi->dequant_InterUV_coeffs[i] < (MIN_DEQUANT_VAL * 2) )
802       pbi->dequant_InterUV_coeffs[i] = MIN_DEQUANT_VAL * 2;
803     pbi->dequant_InterUV_coeffs[i] =
804       pbi->dequant_InterUV_coeffs[i] << IDCT_SCALE_FACTOR;
805   }
806
807   pbi->dequant_coeffs = pbi->dequant_Y_coeffs;
808 }
809
810 void UpdateQ( PB_INSTANCE *pbi, ogg_uint32_t NewQ ){
811   ogg_uint32_t qscale;
812
813   /* Do bounds checking and convert to a float. */
814   qscale = NewQ;
815   if ( qscale < pbi->QThreshTable[Q_TABLE_SIZE-1] )
816     qscale = pbi->QThreshTable[Q_TABLE_SIZE-1];
817   else if ( qscale > pbi->QThreshTable[0] )
818     qscale = pbi->QThreshTable[0];
819
820   /* Set the inter/intra descision control variables. */
821   pbi->FrameQIndex = Q_TABLE_SIZE - 1;
822   while ( (ogg_int32_t) pbi->FrameQIndex >= 0 ) {
823     if ( (pbi->FrameQIndex == 0) ||
824          ( pbi->QThreshTable[pbi->FrameQIndex] >= NewQ) )
825       break;
826     pbi->FrameQIndex --;
827   }
828
829   /* Re-initialise the q tables for forward and reverse transforms. */
830   init_dequantizer ( pbi, qscale, (unsigned char) pbi->FrameQIndex );
831 }
832
833 void UpdateQC( CP_INSTANCE *cpi, ogg_uint32_t NewQ ){
834   ogg_uint32_t qscale;
835   PB_INSTANCE *pbi = &cpi->pb;
836
837   /* Do bounds checking and convert to a float.  */
838   qscale = NewQ;
839   if ( qscale < pbi->QThreshTable[Q_TABLE_SIZE-1] )
840     qscale = pbi->QThreshTable[Q_TABLE_SIZE-1];
841   else if ( qscale > pbi->QThreshTable[0] )
842     qscale = pbi->QThreshTable[0];
843
844   /* Set the inter/intra descision control variables. */
845   pbi->FrameQIndex = Q_TABLE_SIZE - 1;
846   while ((ogg_int32_t) pbi->FrameQIndex >= 0 ) {
847     if ( (pbi->FrameQIndex == 0) ||
848          ( pbi->QThreshTable[pbi->FrameQIndex] >= NewQ) )
849       break;
850     pbi->FrameQIndex --;
851   }
852
853   /* Re-initialise the q tables for forward and reverse transforms. */
854   init_quantizer ( cpi, qscale, (unsigned char) pbi->FrameQIndex );
855   init_dequantizer ( pbi, qscale, (unsigned char) pbi->FrameQIndex );
856 }