1 /********************************************************************
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. *
8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
9 * by the XIPHOPHORUS Company http://www.xiph.org/ *
11 ********************************************************************
13 function: channel mapping 0 implementation
14 last mod: $Id: mapping0.c,v 1.52 2002/07/01 11:20:11 xiphmont Exp $
16 ********************************************************************/
23 #include "vorbis/codec.h"
24 #include "codec_internal.h"
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
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 */
40 static void mapping0_free_info(vorbis_info_mapping *i){
41 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i;
43 memset(info,0,sizeof(*info));
48 static int ilog(unsigned int v){
58 static void mapping0_pack(vorbis_info *vi,vorbis_info_mapping *vm,
61 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm;
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
71 oggpack_write(opb,1,1);
72 oggpack_write(opb,info->submaps-1,4);
74 oggpack_write(opb,0,1);
76 if(info->coupling_steps>0){
77 oggpack_write(opb,1,1);
78 oggpack_write(opb,info->coupling_steps-1,8);
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));
85 oggpack_write(opb,0,1);
87 oggpack_write(opb,0,2); /* 2,3:reserved */
89 /* we don't write the channel submappings if we only have one... */
91 for(i=0;i<vi->channels;i++)
92 oggpack_write(opb,info->chmuxlist[i],4);
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);
101 /* also responsible for range checking */
102 static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){
104 vorbis_info_mapping0 *info=_ogg_calloc(1,sizeof(*info));
105 codec_setup_info *ci=vi->codec_setup;
106 memset(info,0,sizeof(*info));
108 if(oggpack_read(opb,1))
109 info->submaps=oggpack_read(opb,4)+1;
113 if(oggpack_read(opb,1)){
114 info->coupling_steps=oggpack_read(opb,8)+1;
116 for(i=0;i<info->coupling_steps;i++){
117 int testM=info->coupling_mag[i]=oggpack_read(opb,ilog(vi->channels));
118 int testA=info->coupling_ang[i]=oggpack_read(opb,ilog(vi->channels));
123 testM>=vi->channels ||
124 testA>=vi->channels) goto err_out;
129 if(oggpack_read(opb,2)>0)goto err_out; /* 2,3:reserved */
132 for(i=0;i<vi->channels;i++){
133 info->chmuxlist[i]=oggpack_read(opb,4);
134 if(info->chmuxlist[i]>=info->submaps)goto err_out;
137 for(i=0;i<info->submaps;i++){
138 oggpack_read(opb,8); /* time submap unused */
139 info->floorsubmap[i]=oggpack_read(opb,8);
140 if(info->floorsubmap[i]>=ci->floors)goto err_out;
141 info->residuesubmap[i]=oggpack_read(opb,8);
142 if(info->residuesubmap[i]>=ci->residues)goto err_out;
148 mapping0_free_info(info);
155 #include "envelope.h"
162 static ogg_int64_t total=0;
163 static float FLOOR1_fromdB_LOOKUP[256]={
164 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
165 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
166 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
167 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
168 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
169 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
170 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
171 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
172 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
173 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
174 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
175 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
176 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
177 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
178 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
179 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
180 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
181 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
182 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
183 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
184 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
185 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
186 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
187 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
188 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
189 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
190 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
191 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
192 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
193 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
194 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
195 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
196 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
197 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
198 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
199 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
200 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
201 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
202 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
203 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
204 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
205 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
206 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
207 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
208 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
209 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
210 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
211 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
212 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
213 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
214 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
215 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
216 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
217 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
218 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
219 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
220 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
221 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
222 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
223 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
224 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
225 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
226 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
227 0.82788260F, 0.88168307F, 0.9389798F, 1.F,
232 extern int *floor1_fit(vorbis_block *vb,vorbis_look_floor *look,
233 const float *logmdct, /* in */
234 const float *logmask);
235 extern int *floor1_interpolate_fit(vorbis_block *vb,vorbis_look_floor *look,
238 extern int floor1_encode(vorbis_block *vb,vorbis_look_floor *look,
239 int *post,int *ilogmask);
242 static int mapping0_forward(vorbis_block *vb){
243 vorbis_dsp_state *vd=vb->vd;
244 vorbis_info *vi=vd->vi;
245 codec_setup_info *ci=vi->codec_setup;
246 backend_lookup_state *b=vb->vd->backend_state;
247 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
251 int *nonzero = alloca(sizeof(*nonzero)*vi->channels);
252 float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
253 int **ilogmaskch= _vorbis_block_alloc(vb,vi->channels*sizeof(*ilogmaskch));
254 int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
256 float global_ampmax=vbi->ampmax;
257 float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
258 int blocktype=vbi->blocktype;
260 int modenumber=vb->W;
261 vorbis_info_mapping0 *info=ci->map_param[modenumber];
262 vorbis_look_psy *psy_look=
263 b->psy+blocktype+(vb->W?2:0);
267 for(i=0;i<vi->channels;i++){
271 float *pcm =vb->pcm[i];
274 gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
276 scale_dB=todB(&scale);
281 _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2);
283 _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2);
286 /* window the PCM data */
287 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
292 _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2);
294 _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2);
297 /* transform the PCM data */
298 /* only MDCT right now.... */
299 mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
301 /* FFT yields more accurate tonal estimation (not phase sensitive) */
302 drft_forward(&b->fft_look[vb->W],pcm);
303 logfft[0]=scale_dB+todB(pcm);
304 local_ampmax[i]=logfft[0];
306 float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1];
307 temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp);
308 if(temp>local_ampmax[i])local_ampmax[i]=temp;
311 if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
312 if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
317 _analysis_output("fftL",seq,logfft,n/2,1,0,0);
319 _analysis_output("fftR",seq,logfft,n/2,1,0,0);
325 float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
326 float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
328 for(i=0;i<vi->channels;i++){
329 /* the encoder setup assumes that all the modes used by any
330 specific bitrate tweaking use the same floor */
332 int submap=info->chmuxlist[i];
334 /* the following makes things clearer to *me* anyway */
335 float *mdct =gmdct[i];
336 float *logfft =vb->pcm[i];
338 float *logmdct =logfft+n/2;
339 float *logmask =logfft;
343 floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
344 memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
347 logmdct[j]=todB(mdct+j);
352 _analysis_output("mdctL",seq,logmdct,n/2,1,0,0);
354 _analysis_output("mdctR",seq,logmdct,n/2,1,0,0);
356 _analysis_output("mdct",seq,logmdct,n/2,1,0,0);
360 /* first step; noise masking. Not only does 'noise masking'
361 give us curves from which we can decide how much resolution
362 to give noise parts of the spectrum, it also implicitly hands
363 us a tonality estimate (the larger the value in the
364 'noise_depth' vector, the more tonal that area is) */
366 _vp_noisemask(psy_look,
368 noise); /* noise does not have by-frequency offset
373 _analysis_output("noiseL",seq,noise,n/2,1,0,0);
375 _analysis_output("noiseR",seq,noise,n/2,1,0,0);
379 /* second step: 'all the other crap'; all the stuff that isn't
380 computed/fit for bitrate management goes in the second psy
381 vector. This includes tone masking, peak limiting and ATH */
383 _vp_tonemask(psy_look,
392 _analysis_output("toneL",seq,tone,n/2,1,0,0);
394 _analysis_output("toneR",seq,tone,n/2,1,0,0);
398 /* third step; we offset the noise vectors, overlay tone
399 masking. We then do a floor1-specific line fit. If we're
400 performing bitrate management, the line fit is performed
401 multiple times for up/down tweakage on demand. */
403 _vp_offset_and_mix(psy_look,
412 _analysis_output("mask1L",seq,logmask,n/2,1,0,0);
414 _analysis_output("mask1R",seq,logmask,n/2,1,0,0);
418 /* this algorithm is hardwired to floor 1 for now; abort out if
419 we're *not* floor1. This won't happen unless someone has
420 broken the encode setup lib. Guard it anyway. */
421 if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1);
423 floor_posts[i][PACKETBLOBS/2]=
424 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
428 /* are we managing bitrate? If so, perform two more fits for
429 later rate tweaking (fits represent hi/lo) */
430 if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){
431 /* higher rate by way of lower noise curve */
433 _vp_offset_and_mix(psy_look,
442 _analysis_output("mask2L",seq,logmask,n/2,1,0,0);
444 _analysis_output("mask2R",seq,logmask,n/2,1,0,0);
448 floor_posts[i][PACKETBLOBS-1]=
449 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
453 /* lower rate by way of higher noise curve */
454 _vp_offset_and_mix(psy_look,
463 _analysis_output("mask0L",seq,logmask,n/2,1,0,0);
465 _analysis_output("mask0R",seq,logmask,n/2,1,0,0);
469 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
473 /* we also interpolate a range of intermediate curves for
474 intermediate rates */
475 for(k=1;k<PACKETBLOBS/2;k++)
477 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
479 floor_posts[i][PACKETBLOBS/2],
480 k*65536/(PACKETBLOBS/2));
481 for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++)
483 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
484 floor_posts[i][PACKETBLOBS/2],
485 floor_posts[i][PACKETBLOBS-1],
486 (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2));
490 vbi->ampmax=global_ampmax;
493 the next phases are performed once for vbr-only and PACKETBLOB
494 times for bitrate managed modes.
496 1) encode actual mode being used
497 2) encode the floor for each channel, compute coded mask curve/res
498 3) normalize and couple.
500 5) save packet bytes to the packetblob vector
504 /* iterate over the many masking curve fits we've created */
507 float **res_bundle=alloca(sizeof(*res_bundle)*vi->channels);
508 float **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
509 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
510 int **sortindex=alloca(sizeof(*sortindex)*vi->channels);
514 if(info->coupling_steps){
515 mag_memo=_vp_quantize_couple_memo(vb,
520 mag_sort=_vp_quantize_couple_sort(vb,
526 memset(sortindex,0,sizeof(*sortindex)*vi->channels);
527 if(psy_look->vi->normal_channel_p){
528 for(i=0;i<vi->channels;i++){
529 float *mdct =gmdct[i];
530 sortindex[i]=alloca(sizeof(**sortindex)*n/2);
531 _vp_noise_normalize_sort(psy_look,mdct,sortindex[i]);
535 for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
536 k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
539 /* start out our new packet blob with packet type and mode */
540 /* Encode the packet type */
541 oggpack_write(&vb->opb,0,1);
542 /* Encode the modenumber */
543 /* Encode frame mode, pre,post windowsize, then dispatch */
544 oggpack_write(&vb->opb,modenumber,b->modebits);
546 oggpack_write(&vb->opb,vb->lW,1);
547 oggpack_write(&vb->opb,vb->nW,1);
550 /* encode floor, compute masking curve, sep out residue */
551 for(i=0;i<vi->channels;i++){
552 int submap=info->chmuxlist[i];
553 float *mdct =gmdct[i];
554 float *res =vb->pcm[i];
555 int *ilogmask=ilogmaskch[i]=
556 _vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
558 nonzero[i]=floor1_encode(vb,b->flr[info->floorsubmap[submap]],
564 sprintf(buf,"maskI%c%d",i?'R':'L',k);
567 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]];
568 _analysis_output(buf,seq,work,n/2,1,1,0);
571 _vp_remove_floor(psy_look,
575 ci->psy_g_param.sliding_lowpass[vb->W][k]);
577 _vp_noise_normalize(psy_look,res,res+n/2,sortindex[i]);
585 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]]*(res+n/2)[j];
586 sprintf(buf,"resI%c%d",i?'R':'L',k);
587 _analysis_output(buf,seq,work,n/2,1,1,0);
593 /* our iteration is now based on masking curve, not prequant and
594 coupling. Only one prequant/coupling step */
596 /* quantize/couple */
597 /* incomplete implementation that assumes the tree is all depth
598 one, or no tree at all */
599 if(info->coupling_steps){
609 ci->psy_g_param.sliding_lowpass[vb->W][k]);
612 /* classify and encode by submap */
613 for(i=0;i<info->submaps;i++){
615 long **classifications;
616 int resnum=info->residuesubmap[i];
618 for(j=0;j<vi->channels;j++){
619 if(info->chmuxlist[j]==i){
620 zerobundle[ch_in_bundle]=0;
621 if(nonzero[j])zerobundle[ch_in_bundle]=1;
622 res_bundle[ch_in_bundle]=vb->pcm[j];
623 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
627 classifications=_residue_P[ci->residue_type[resnum]]->
628 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
630 _residue_P[ci->residue_type[resnum]]->
631 forward(vb,b->residue[resnum],
632 couple_bundle,NULL,zerobundle,ch_in_bundle,classifications);
635 /* ok, done encoding. Mark this protopacket and prepare next. */
636 oggpack_writealign(&vb->opb);
637 vbi->packetblob_markers[k]=oggpack_bytes(&vb->opb);
645 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
650 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
651 vorbis_dsp_state *vd=vb->vd;
652 vorbis_info *vi=vd->vi;
653 codec_setup_info *ci=vi->codec_setup;
654 backend_lookup_state *b=vd->backend_state;
655 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
658 long n=vb->pcmend=ci->blocksizes[vb->W];
660 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
661 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
663 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
664 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
666 /* recover the spectral envelope; store it in the PCM vector for now */
667 for(i=0;i<vi->channels;i++){
668 int submap=info->chmuxlist[i];
669 floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
670 inverse1(vb,b->flr[info->floorsubmap[submap]]);
675 memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
678 /* channel coupling can 'dirty' the nonzero listing */
679 for(i=0;i<info->coupling_steps;i++){
680 if(nonzero[info->coupling_mag[i]] ||
681 nonzero[info->coupling_ang[i]]){
682 nonzero[info->coupling_mag[i]]=1;
683 nonzero[info->coupling_ang[i]]=1;
687 /* recover the residue into our working vectors */
688 for(i=0;i<info->submaps;i++){
690 for(j=0;j<vi->channels;j++){
691 if(info->chmuxlist[j]==i){
693 zerobundle[ch_in_bundle]=1;
695 zerobundle[ch_in_bundle]=0;
696 pcmbundle[ch_in_bundle++]=vb->pcm[j];
700 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
701 inverse(vb,b->residue[info->residuesubmap[i]],
702 pcmbundle,zerobundle,ch_in_bundle);
705 /* channel coupling */
706 for(i=info->coupling_steps-1;i>=0;i--){
707 float *pcmM=vb->pcm[info->coupling_mag[i]];
708 float *pcmA=vb->pcm[info->coupling_ang[i]];
733 /* compute and apply spectral envelope */
734 for(i=0;i<vi->channels;i++){
735 float *pcm=vb->pcm[i];
736 int submap=info->chmuxlist[i];
737 _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
738 inverse2(vb,b->flr[info->floorsubmap[submap]],
742 /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
743 /* only MDCT right now.... */
744 for(i=0;i<vi->channels;i++){
745 float *pcm=vb->pcm[i];
746 mdct_backward(b->transform[vb->W][0],pcm,pcm);
749 /* window the data */
750 for(i=0;i<vi->channels;i++){
751 float *pcm=vb->pcm[i];
753 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
765 vorbis_func_mapping mapping0_exportbundle={