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.54 2002/10/11 11:14:41 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 private_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,
521 mag_sort=_vp_quantize_couple_sort(vb,
527 memset(sortindex,0,sizeof(*sortindex)*vi->channels);
528 if(psy_look->vi->normal_channel_p){
529 for(i=0;i<vi->channels;i++){
530 float *mdct =gmdct[i];
531 sortindex[i]=alloca(sizeof(**sortindex)*n/2);
532 _vp_noise_normalize_sort(psy_look,mdct,sortindex[i]);
536 for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
537 k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
540 /* start out our new packet blob with packet type and mode */
541 /* Encode the packet type */
542 oggpack_write(&vb->opb,0,1);
543 /* Encode the modenumber */
544 /* Encode frame mode, pre,post windowsize, then dispatch */
545 oggpack_write(&vb->opb,modenumber,b->modebits);
547 oggpack_write(&vb->opb,vb->lW,1);
548 oggpack_write(&vb->opb,vb->nW,1);
551 /* encode floor, compute masking curve, sep out residue */
552 for(i=0;i<vi->channels;i++){
553 int submap=info->chmuxlist[i];
554 float *mdct =gmdct[i];
555 float *res =vb->pcm[i];
556 int *ilogmask=ilogmaskch[i]=
557 _vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
559 nonzero[i]=floor1_encode(vb,b->flr[info->floorsubmap[submap]],
565 sprintf(buf,"maskI%c%d",i?'R':'L',k);
568 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]];
569 _analysis_output(buf,seq,work,n/2,1,1,0);
572 _vp_remove_floor(psy_look,
576 ci->psy_g_param.sliding_lowpass[vb->W][k]);
578 _vp_noise_normalize(psy_look,res,res+n/2,sortindex[i]);
586 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]]*(res+n/2)[j];
587 sprintf(buf,"resI%c%d",i?'R':'L',k);
588 _analysis_output(buf,seq,work,n/2,1,1,0);
594 /* our iteration is now based on masking curve, not prequant and
595 coupling. Only one prequant/coupling step */
597 /* quantize/couple */
598 /* incomplete implementation that assumes the tree is all depth
599 one, or no tree at all */
600 if(info->coupling_steps){
610 ci->psy_g_param.sliding_lowpass[vb->W][k]);
613 /* classify and encode by submap */
614 for(i=0;i<info->submaps;i++){
616 long **classifications;
617 int resnum=info->residuesubmap[i];
619 for(j=0;j<vi->channels;j++){
620 if(info->chmuxlist[j]==i){
621 zerobundle[ch_in_bundle]=0;
622 if(nonzero[j])zerobundle[ch_in_bundle]=1;
623 res_bundle[ch_in_bundle]=vb->pcm[j];
624 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
628 classifications=_residue_P[ci->residue_type[resnum]]->
629 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
631 _residue_P[ci->residue_type[resnum]]->
632 forward(vb,b->residue[resnum],
633 couple_bundle,NULL,zerobundle,ch_in_bundle,classifications);
636 /* ok, done encoding. Mark this protopacket and prepare next. */
637 oggpack_writealign(&vb->opb);
638 vbi->packetblob_markers[k]=oggpack_bytes(&vb->opb);
646 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
651 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
652 vorbis_dsp_state *vd=vb->vd;
653 vorbis_info *vi=vd->vi;
654 codec_setup_info *ci=vi->codec_setup;
655 private_state *b=vd->backend_state;
656 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
659 long n=vb->pcmend=ci->blocksizes[vb->W];
661 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
662 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
664 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
665 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
667 /* recover the spectral envelope; store it in the PCM vector for now */
668 for(i=0;i<vi->channels;i++){
669 int submap=info->chmuxlist[i];
670 floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
671 inverse1(vb,b->flr[info->floorsubmap[submap]]);
676 memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
679 /* channel coupling can 'dirty' the nonzero listing */
680 for(i=0;i<info->coupling_steps;i++){
681 if(nonzero[info->coupling_mag[i]] ||
682 nonzero[info->coupling_ang[i]]){
683 nonzero[info->coupling_mag[i]]=1;
684 nonzero[info->coupling_ang[i]]=1;
688 /* recover the residue into our working vectors */
689 for(i=0;i<info->submaps;i++){
691 for(j=0;j<vi->channels;j++){
692 if(info->chmuxlist[j]==i){
694 zerobundle[ch_in_bundle]=1;
696 zerobundle[ch_in_bundle]=0;
697 pcmbundle[ch_in_bundle++]=vb->pcm[j];
701 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
702 inverse(vb,b->residue[info->residuesubmap[i]],
703 pcmbundle,zerobundle,ch_in_bundle);
706 /* channel coupling */
707 for(i=info->coupling_steps-1;i>=0;i--){
708 float *pcmM=vb->pcm[info->coupling_mag[i]];
709 float *pcmA=vb->pcm[info->coupling_ang[i]];
734 /* compute and apply spectral envelope */
735 for(i=0;i<vi->channels;i++){
736 float *pcm=vb->pcm[i];
737 int submap=info->chmuxlist[i];
738 _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
739 inverse2(vb,b->flr[info->floorsubmap[submap]],
743 /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
744 /* only MDCT right now.... */
745 for(i=0;i<vi->channels;i++){
746 float *pcm=vb->pcm[i];
747 mdct_backward(b->transform[vb->W][0],pcm,pcm);
750 /* window the data */
751 for(i=0;i<vi->channels;i++){
752 float *pcm=vb->pcm[i];
754 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
766 vorbis_func_mapping mapping0_exportbundle={