]> git.jsancho.org Git - lugaru.git/blob - Dependencies/libvorbis/lib/mapping0.c
Merge.
[lugaru.git] / Dependencies / libvorbis / lib / mapping0.c
1 /********************************************************************
2  *                                                                  *
3  * THIS FILE IS PART OF THE OggVorbis 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 OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010             *
9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
10  *                                                                  *
11  ********************************************************************
12
13  function: channel mapping 0 implementation
14  last mod: $Id: mapping0.c 17022 2010-03-25 03:45:42Z xiphmont $
15
16  ********************************************************************/
17
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21 #include <math.h>
22 #include <ogg/ogg.h>
23 #include "vorbis/codec.h"
24 #include "codec_internal.h"
25 #include "codebook.h"
26 #include "window.h"
27 #include "registry.h"
28 #include "psy.h"
29 #include "misc.h"
30
31 /* simplistic, wasteful way of doing this (unique lookup for each
32    mode/submapping); there should be a central repository for
33    identical lookups.  That will require minor work, so I'm putting it
34    off as low priority.
35
36    Why a lookup for each backend in a given mode?  Because the
37    blocksize is set by the mode, and low backend lookups may require
38    parameters from other areas of the mode/mapping */
39
40 static void mapping0_free_info(vorbis_info_mapping *i){
41   vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i;
42   if(info){
43     memset(info,0,sizeof(*info));
44     _ogg_free(info);
45   }
46 }
47
48 static int ilog(unsigned int v){
49   int ret=0;
50   if(v)--v;
51   while(v){
52     ret++;
53     v>>=1;
54   }
55   return(ret);
56 }
57
58 static void mapping0_pack(vorbis_info *vi,vorbis_info_mapping *vm,
59                           oggpack_buffer *opb){
60   int i;
61   vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm;
62
63   /* another 'we meant to do it this way' hack...  up to beta 4, we
64      packed 4 binary zeros here to signify one submapping in use.  We
65      now redefine that to mean four bitflags that indicate use of
66      deeper features; bit0:submappings, bit1:coupling,
67      bit2,3:reserved. This is backward compatable with all actual uses
68      of the beta code. */
69
70   if(info->submaps>1){
71     oggpack_write(opb,1,1);
72     oggpack_write(opb,info->submaps-1,4);
73   }else
74     oggpack_write(opb,0,1);
75
76   if(info->coupling_steps>0){
77     oggpack_write(opb,1,1);
78     oggpack_write(opb,info->coupling_steps-1,8);
79
80     for(i=0;i<info->coupling_steps;i++){
81       oggpack_write(opb,info->coupling_mag[i],ilog(vi->channels));
82       oggpack_write(opb,info->coupling_ang[i],ilog(vi->channels));
83     }
84   }else
85     oggpack_write(opb,0,1);
86
87   oggpack_write(opb,0,2); /* 2,3:reserved */
88
89   /* we don't write the channel submappings if we only have one... */
90   if(info->submaps>1){
91     for(i=0;i<vi->channels;i++)
92       oggpack_write(opb,info->chmuxlist[i],4);
93   }
94   for(i=0;i<info->submaps;i++){
95     oggpack_write(opb,0,8); /* time submap unused */
96     oggpack_write(opb,info->floorsubmap[i],8);
97     oggpack_write(opb,info->residuesubmap[i],8);
98   }
99 }
100
101 /* also responsible for range checking */
102 static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){
103   int i,b;
104   vorbis_info_mapping0 *info=_ogg_calloc(1,sizeof(*info));
105   codec_setup_info     *ci=vi->codec_setup;
106   memset(info,0,sizeof(*info));
107
108   b=oggpack_read(opb,1);
109   if(b<0)goto err_out;
110   if(b){
111     info->submaps=oggpack_read(opb,4)+1;
112     if(info->submaps<=0)goto err_out;
113   }else
114     info->submaps=1;
115
116   b=oggpack_read(opb,1);
117   if(b<0)goto err_out;
118   if(b){
119     info->coupling_steps=oggpack_read(opb,8)+1;
120     if(info->coupling_steps<=0)goto err_out;
121     for(i=0;i<info->coupling_steps;i++){
122       int testM=info->coupling_mag[i]=oggpack_read(opb,ilog(vi->channels));
123       int testA=info->coupling_ang[i]=oggpack_read(opb,ilog(vi->channels));
124
125       if(testM<0 ||
126          testA<0 ||
127          testM==testA ||
128          testM>=vi->channels ||
129          testA>=vi->channels) goto err_out;
130     }
131
132   }
133
134   if(oggpack_read(opb,2)!=0)goto err_out; /* 2,3:reserved */
135
136   if(info->submaps>1){
137     for(i=0;i<vi->channels;i++){
138       info->chmuxlist[i]=oggpack_read(opb,4);
139       if(info->chmuxlist[i]>=info->submaps || info->chmuxlist[i]<0)goto err_out;
140     }
141   }
142   for(i=0;i<info->submaps;i++){
143     oggpack_read(opb,8); /* time submap unused */
144     info->floorsubmap[i]=oggpack_read(opb,8);
145     if(info->floorsubmap[i]>=ci->floors || info->floorsubmap[i]<0)goto err_out;
146     info->residuesubmap[i]=oggpack_read(opb,8);
147     if(info->residuesubmap[i]>=ci->residues || info->residuesubmap[i]<0)goto err_out;
148   }
149
150   return info;
151
152  err_out:
153   mapping0_free_info(info);
154   return(NULL);
155 }
156
157 #include "os.h"
158 #include "lpc.h"
159 #include "lsp.h"
160 #include "envelope.h"
161 #include "mdct.h"
162 #include "psy.h"
163 #include "scales.h"
164
165 #if 0
166 static long seq=0;
167 static ogg_int64_t total=0;
168 static float FLOOR1_fromdB_LOOKUP[256]={
169   1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
170   1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
171   1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
172   2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
173   2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
174   3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
175   4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
176   6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
177   7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
178   1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
179   1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
180   1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
181   2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
182   2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
183   3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
184   4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
185   5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
186   7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
187   9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
188   1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
189   1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
190   2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
191   2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
192   3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
193   4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
194   5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
195   7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
196   9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
197   0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
198   0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
199   0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
200   0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
201   0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
202   0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
203   0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
204   0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
205   0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
206   0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
207   0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
208   0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
209   0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
210   0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
211   0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
212   0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
213   0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
214   0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
215   0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
216   0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
217   0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
218   0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
219   0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
220   0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
221   0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
222   0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
223   0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
224   0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
225   0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
226   0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
227   0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
228   0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
229   0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
230   0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
231   0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
232   0.82788260F, 0.88168307F, 0.9389798F, 1.F,
233 };
234
235 #endif
236
237
238 static int mapping0_forward(vorbis_block *vb){
239   vorbis_dsp_state      *vd=vb->vd;
240   vorbis_info           *vi=vd->vi;
241   codec_setup_info      *ci=vi->codec_setup;
242   private_state         *b=vb->vd->backend_state;
243   vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
244   int                    n=vb->pcmend;
245   int i,j,k;
246
247   int    *nonzero    = alloca(sizeof(*nonzero)*vi->channels);
248   float  **gmdct     = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
249   int    **iwork      = _vorbis_block_alloc(vb,vi->channels*sizeof(*iwork));
250   int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
251
252   float global_ampmax=vbi->ampmax;
253   float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
254   int blocktype=vbi->blocktype;
255
256   int modenumber=vb->W;
257   vorbis_info_mapping0 *info=ci->map_param[modenumber];
258   vorbis_look_psy *psy_look=b->psy+blocktype+(vb->W?2:0);
259
260   vb->mode=modenumber;
261
262   for(i=0;i<vi->channels;i++){
263     float scale=4.f/n;
264     float scale_dB;
265
266     float *pcm     =vb->pcm[i];
267     float *logfft  =pcm;
268
269     iwork[i]=_vorbis_block_alloc(vb,n/2*sizeof(**iwork));
270     gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
271
272     scale_dB=todB(&scale) + .345; /* + .345 is a hack; the original
273                                      todB estimation used on IEEE 754
274                                      compliant machines had a bug that
275                                      returned dB values about a third
276                                      of a decibel too high.  The bug
277                                      was harmless because tunings
278                                      implicitly took that into
279                                      account.  However, fixing the bug
280                                      in the estimator requires
281                                      changing all the tunings as well.
282                                      For now, it's easier to sync
283                                      things back up here, and
284                                      recalibrate the tunings in the
285                                      next major model upgrade. */
286
287 #if 0
288     if(vi->channels==2){
289       if(i==0)
290         _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2);
291       else
292         _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2);
293     }else{
294       _analysis_output("pcm",seq,pcm,n,0,0,total-n/2);
295     }
296 #endif
297
298     /* window the PCM data */
299     _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
300
301 #if 0
302     if(vi->channels==2){
303       if(i==0)
304         _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2);
305       else
306         _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2);
307     }else{
308       _analysis_output("windowed",seq,pcm,n,0,0,total-n/2);
309     }
310 #endif
311
312     /* transform the PCM data */
313     /* only MDCT right now.... */
314     mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
315
316     /* FFT yields more accurate tonal estimation (not phase sensitive) */
317     drft_forward(&b->fft_look[vb->W],pcm);
318     logfft[0]=scale_dB+todB(pcm)  + .345; /* + .345 is a hack; the
319                                      original todB estimation used on
320                                      IEEE 754 compliant machines had a
321                                      bug that returned dB values about
322                                      a third of a decibel too high.
323                                      The bug was harmless because
324                                      tunings implicitly took that into
325                                      account.  However, fixing the bug
326                                      in the estimator requires
327                                      changing all the tunings as well.
328                                      For now, it's easier to sync
329                                      things back up here, and
330                                      recalibrate the tunings in the
331                                      next major model upgrade. */
332     local_ampmax[i]=logfft[0];
333     for(j=1;j<n-1;j+=2){
334       float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1];
335       temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp)  + .345; /* +
336                                      .345 is a hack; the original todB
337                                      estimation used on IEEE 754
338                                      compliant machines had a bug that
339                                      returned dB values about a third
340                                      of a decibel too high.  The bug
341                                      was harmless because tunings
342                                      implicitly took that into
343                                      account.  However, fixing the bug
344                                      in the estimator requires
345                                      changing all the tunings as well.
346                                      For now, it's easier to sync
347                                      things back up here, and
348                                      recalibrate the tunings in the
349                                      next major model upgrade. */
350       if(temp>local_ampmax[i])local_ampmax[i]=temp;
351     }
352
353     if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
354     if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
355
356 #if 0
357     if(vi->channels==2){
358       if(i==0){
359         _analysis_output("fftL",seq,logfft,n/2,1,0,0);
360       }else{
361         _analysis_output("fftR",seq,logfft,n/2,1,0,0);
362       }
363     }else{
364       _analysis_output("fft",seq,logfft,n/2,1,0,0);
365     }
366 #endif
367
368   }
369
370   {
371     float   *noise        = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
372     float   *tone         = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
373
374     for(i=0;i<vi->channels;i++){
375       /* the encoder setup assumes that all the modes used by any
376          specific bitrate tweaking use the same floor */
377
378       int submap=info->chmuxlist[i];
379
380       /* the following makes things clearer to *me* anyway */
381       float *mdct    =gmdct[i];
382       float *logfft  =vb->pcm[i];
383
384       float *logmdct =logfft+n/2;
385       float *logmask =logfft;
386
387       vb->mode=modenumber;
388
389       floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
390       memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
391
392       for(j=0;j<n/2;j++)
393         logmdct[j]=todB(mdct+j)  + .345; /* + .345 is a hack; the original
394                                      todB estimation used on IEEE 754
395                                      compliant machines had a bug that
396                                      returned dB values about a third
397                                      of a decibel too high.  The bug
398                                      was harmless because tunings
399                                      implicitly took that into
400                                      account.  However, fixing the bug
401                                      in the estimator requires
402                                      changing all the tunings as well.
403                                      For now, it's easier to sync
404                                      things back up here, and
405                                      recalibrate the tunings in the
406                                      next major model upgrade. */
407
408 #if 0
409       if(vi->channels==2){
410         if(i==0)
411           _analysis_output("mdctL",seq,logmdct,n/2,1,0,0);
412         else
413           _analysis_output("mdctR",seq,logmdct,n/2,1,0,0);
414       }else{
415         _analysis_output("mdct",seq,logmdct,n/2,1,0,0);
416       }
417 #endif
418
419       /* first step; noise masking.  Not only does 'noise masking'
420          give us curves from which we can decide how much resolution
421          to give noise parts of the spectrum, it also implicitly hands
422          us a tonality estimate (the larger the value in the
423          'noise_depth' vector, the more tonal that area is) */
424
425       _vp_noisemask(psy_look,
426                     logmdct,
427                     noise); /* noise does not have by-frequency offset
428                                bias applied yet */
429 #if 0
430       if(vi->channels==2){
431         if(i==0)
432           _analysis_output("noiseL",seq,noise,n/2,1,0,0);
433         else
434           _analysis_output("noiseR",seq,noise,n/2,1,0,0);
435       }else{
436         _analysis_output("noise",seq,noise,n/2,1,0,0);
437       }
438 #endif
439
440       /* second step: 'all the other crap'; all the stuff that isn't
441          computed/fit for bitrate management goes in the second psy
442          vector.  This includes tone masking, peak limiting and ATH */
443
444       _vp_tonemask(psy_look,
445                    logfft,
446                    tone,
447                    global_ampmax,
448                    local_ampmax[i]);
449
450 #if 0
451       if(vi->channels==2){
452         if(i==0)
453           _analysis_output("toneL",seq,tone,n/2,1,0,0);
454         else
455           _analysis_output("toneR",seq,tone,n/2,1,0,0);
456       }else{
457         _analysis_output("tone",seq,tone,n/2,1,0,0);
458       }
459 #endif
460
461       /* third step; we offset the noise vectors, overlay tone
462          masking.  We then do a floor1-specific line fit.  If we're
463          performing bitrate management, the line fit is performed
464          multiple times for up/down tweakage on demand. */
465
466 #if 0
467       {
468       float aotuv[psy_look->n];
469 #endif
470
471         _vp_offset_and_mix(psy_look,
472                            noise,
473                            tone,
474                            1,
475                            logmask,
476                            mdct,
477                            logmdct);
478
479 #if 0
480         if(vi->channels==2){
481           if(i==0)
482             _analysis_output("aotuvM1_L",seq,aotuv,psy_look->n,1,1,0);
483           else
484             _analysis_output("aotuvM1_R",seq,aotuv,psy_look->n,1,1,0);
485         }else{
486           _analysis_output("aotuvM1",seq,aotuv,psy_look->n,1,1,0);
487         }
488       }
489 #endif
490
491
492 #if 0
493       if(vi->channels==2){
494         if(i==0)
495           _analysis_output("mask1L",seq,logmask,n/2,1,0,0);
496         else
497           _analysis_output("mask1R",seq,logmask,n/2,1,0,0);
498       }else{
499         _analysis_output("mask1",seq,logmask,n/2,1,0,0);
500       }
501 #endif
502
503       /* this algorithm is hardwired to floor 1 for now; abort out if
504          we're *not* floor1.  This won't happen unless someone has
505          broken the encode setup lib.  Guard it anyway. */
506       if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1);
507
508       floor_posts[i][PACKETBLOBS/2]=
509         floor1_fit(vb,b->flr[info->floorsubmap[submap]],
510                    logmdct,
511                    logmask);
512
513       /* are we managing bitrate?  If so, perform two more fits for
514          later rate tweaking (fits represent hi/lo) */
515       if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){
516         /* higher rate by way of lower noise curve */
517
518         _vp_offset_and_mix(psy_look,
519                            noise,
520                            tone,
521                            2,
522                            logmask,
523                            mdct,
524                            logmdct);
525
526 #if 0
527         if(vi->channels==2){
528           if(i==0)
529             _analysis_output("mask2L",seq,logmask,n/2,1,0,0);
530           else
531             _analysis_output("mask2R",seq,logmask,n/2,1,0,0);
532         }else{
533           _analysis_output("mask2",seq,logmask,n/2,1,0,0);
534         }
535 #endif
536
537         floor_posts[i][PACKETBLOBS-1]=
538           floor1_fit(vb,b->flr[info->floorsubmap[submap]],
539                      logmdct,
540                      logmask);
541
542         /* lower rate by way of higher noise curve */
543         _vp_offset_and_mix(psy_look,
544                            noise,
545                            tone,
546                            0,
547                            logmask,
548                            mdct,
549                            logmdct);
550
551 #if 0
552         if(vi->channels==2){
553           if(i==0)
554             _analysis_output("mask0L",seq,logmask,n/2,1,0,0);
555           else
556             _analysis_output("mask0R",seq,logmask,n/2,1,0,0);
557         }else{
558           _analysis_output("mask0",seq,logmask,n/2,1,0,0);
559         }
560 #endif
561
562         floor_posts[i][0]=
563           floor1_fit(vb,b->flr[info->floorsubmap[submap]],
564                      logmdct,
565                      logmask);
566
567         /* we also interpolate a range of intermediate curves for
568            intermediate rates */
569         for(k=1;k<PACKETBLOBS/2;k++)
570           floor_posts[i][k]=
571             floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
572                                    floor_posts[i][0],
573                                    floor_posts[i][PACKETBLOBS/2],
574                                    k*65536/(PACKETBLOBS/2));
575         for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++)
576           floor_posts[i][k]=
577             floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
578                                    floor_posts[i][PACKETBLOBS/2],
579                                    floor_posts[i][PACKETBLOBS-1],
580                                    (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2));
581       }
582     }
583   }
584   vbi->ampmax=global_ampmax;
585
586   /*
587     the next phases are performed once for vbr-only and PACKETBLOB
588     times for bitrate managed modes.
589
590     1) encode actual mode being used
591     2) encode the floor for each channel, compute coded mask curve/res
592     3) normalize and couple.
593     4) encode residue
594     5) save packet bytes to the packetblob vector
595
596   */
597
598   /* iterate over the many masking curve fits we've created */
599
600   {
601     int **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
602     int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
603
604     for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
605         k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
606         k++){
607       oggpack_buffer *opb=vbi->packetblob[k];
608
609       /* start out our new packet blob with packet type and mode */
610       /* Encode the packet type */
611       oggpack_write(opb,0,1);
612       /* Encode the modenumber */
613       /* Encode frame mode, pre,post windowsize, then dispatch */
614       oggpack_write(opb,modenumber,b->modebits);
615       if(vb->W){
616         oggpack_write(opb,vb->lW,1);
617         oggpack_write(opb,vb->nW,1);
618       }
619
620       /* encode floor, compute masking curve, sep out residue */
621       for(i=0;i<vi->channels;i++){
622         int submap=info->chmuxlist[i];
623         int *ilogmask=iwork[i];
624
625         nonzero[i]=floor1_encode(opb,vb,b->flr[info->floorsubmap[submap]],
626                                  floor_posts[i][k],
627                                  ilogmask);
628 #if 0
629         {
630           char buf[80];
631           sprintf(buf,"maskI%c%d",i?'R':'L',k);
632           float work[n/2];
633           for(j=0;j<n/2;j++)
634             work[j]=FLOOR1_fromdB_LOOKUP[iwork[i][j]];
635           _analysis_output(buf,seq,work,n/2,1,1,0);
636         }
637 #endif
638       }
639
640       /* our iteration is now based on masking curve, not prequant and
641          coupling.  Only one prequant/coupling step */
642
643       /* quantize/couple */
644       /* incomplete implementation that assumes the tree is all depth
645          one, or no tree at all */
646       _vp_couple_quantize_normalize(k,
647                                     &ci->psy_g_param,
648                                     psy_look,
649                                     info,
650                                     gmdct,
651                                     iwork,
652                                     nonzero,
653                                     ci->psy_g_param.sliding_lowpass[vb->W][k],
654                                     vi->channels);
655
656 #if 0
657       for(i=0;i<vi->channels;i++){
658         char buf[80];
659         sprintf(buf,"res%c%d",i?'R':'L',k);
660         float work[n/2];
661         for(j=0;j<n/2;j++)
662           work[j]=iwork[i][j];
663         _analysis_output(buf,seq,work,n/2,1,0,0);
664       }
665 #endif
666
667       /* classify and encode by submap */
668       for(i=0;i<info->submaps;i++){
669         int ch_in_bundle=0;
670         long **classifications;
671         int resnum=info->residuesubmap[i];
672
673         for(j=0;j<vi->channels;j++){
674           if(info->chmuxlist[j]==i){
675             zerobundle[ch_in_bundle]=0;
676             if(nonzero[j])zerobundle[ch_in_bundle]=1;
677             couple_bundle[ch_in_bundle++]=iwork[j];
678           }
679         }
680
681         classifications=_residue_P[ci->residue_type[resnum]]->
682           class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
683
684         ch_in_bundle=0;
685         for(j=0;j<vi->channels;j++)
686           if(info->chmuxlist[j]==i)
687             couple_bundle[ch_in_bundle++]=iwork[j];
688
689         _residue_P[ci->residue_type[resnum]]->
690           forward(opb,vb,b->residue[resnum],
691                   couple_bundle,zerobundle,ch_in_bundle,classifications,i);
692       }
693
694       /* ok, done encoding.  Next protopacket. */
695     }
696
697   }
698
699 #if 0
700   seq++;
701   total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
702 #endif
703   return(0);
704 }
705
706 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
707   vorbis_dsp_state     *vd=vb->vd;
708   vorbis_info          *vi=vd->vi;
709   codec_setup_info     *ci=vi->codec_setup;
710   private_state        *b=vd->backend_state;
711   vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
712
713   int                   i,j;
714   long                  n=vb->pcmend=ci->blocksizes[vb->W];
715
716   float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
717   int    *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
718
719   int   *nonzero  =alloca(sizeof(*nonzero)*vi->channels);
720   void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
721
722   /* recover the spectral envelope; store it in the PCM vector for now */
723   for(i=0;i<vi->channels;i++){
724     int submap=info->chmuxlist[i];
725     floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
726       inverse1(vb,b->flr[info->floorsubmap[submap]]);
727     if(floormemo[i])
728       nonzero[i]=1;
729     else
730       nonzero[i]=0;
731     memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
732   }
733
734   /* channel coupling can 'dirty' the nonzero listing */
735   for(i=0;i<info->coupling_steps;i++){
736     if(nonzero[info->coupling_mag[i]] ||
737        nonzero[info->coupling_ang[i]]){
738       nonzero[info->coupling_mag[i]]=1;
739       nonzero[info->coupling_ang[i]]=1;
740     }
741   }
742
743   /* recover the residue into our working vectors */
744   for(i=0;i<info->submaps;i++){
745     int ch_in_bundle=0;
746     for(j=0;j<vi->channels;j++){
747       if(info->chmuxlist[j]==i){
748         if(nonzero[j])
749           zerobundle[ch_in_bundle]=1;
750         else
751           zerobundle[ch_in_bundle]=0;
752         pcmbundle[ch_in_bundle++]=vb->pcm[j];
753       }
754     }
755
756     _residue_P[ci->residue_type[info->residuesubmap[i]]]->
757       inverse(vb,b->residue[info->residuesubmap[i]],
758               pcmbundle,zerobundle,ch_in_bundle);
759   }
760
761   /* channel coupling */
762   for(i=info->coupling_steps-1;i>=0;i--){
763     float *pcmM=vb->pcm[info->coupling_mag[i]];
764     float *pcmA=vb->pcm[info->coupling_ang[i]];
765
766     for(j=0;j<n/2;j++){
767       float mag=pcmM[j];
768       float ang=pcmA[j];
769
770       if(mag>0)
771         if(ang>0){
772           pcmM[j]=mag;
773           pcmA[j]=mag-ang;
774         }else{
775           pcmA[j]=mag;
776           pcmM[j]=mag+ang;
777         }
778       else
779         if(ang>0){
780           pcmM[j]=mag;
781           pcmA[j]=mag+ang;
782         }else{
783           pcmA[j]=mag;
784           pcmM[j]=mag-ang;
785         }
786     }
787   }
788
789   /* compute and apply spectral envelope */
790   for(i=0;i<vi->channels;i++){
791     float *pcm=vb->pcm[i];
792     int submap=info->chmuxlist[i];
793     _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
794       inverse2(vb,b->flr[info->floorsubmap[submap]],
795                floormemo[i],pcm);
796   }
797
798   /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
799   /* only MDCT right now.... */
800   for(i=0;i<vi->channels;i++){
801     float *pcm=vb->pcm[i];
802     mdct_backward(b->transform[vb->W][0],pcm,pcm);
803   }
804
805   /* all done! */
806   return(0);
807 }
808
809 /* export hooks */
810 const vorbis_func_mapping mapping0_exportbundle={
811   &mapping0_pack,
812   &mapping0_unpack,
813   &mapping0_free_info,
814   &mapping0_forward,
815   &mapping0_inverse
816 };