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.50 2002/06/28 22:19:35 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;
165 extern int *floor1_fit(vorbis_block *vb,vorbis_look_floor *look,
166 const float *logmdct, /* in */
167 const float *logmask);
168 extern int *floor1_interpolate_fit(vorbis_block *vb,vorbis_look_floor *look,
171 extern int floor1_encode(vorbis_block *vb,vorbis_look_floor *look,
172 int *post,int *ilogmask);
175 static int mapping0_forward(vorbis_block *vb){
176 vorbis_dsp_state *vd=vb->vd;
177 vorbis_info *vi=vd->vi;
178 codec_setup_info *ci=vi->codec_setup;
179 backend_lookup_state *b=vb->vd->backend_state;
180 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
184 int *nonzero = alloca(sizeof(*nonzero)*vi->channels);
185 float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
186 int **ilogmaskch= _vorbis_block_alloc(vb,vi->channels*sizeof(*ilogmaskch));
187 int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
189 float global_ampmax=vbi->ampmax;
190 float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
191 int blocktype=vbi->blocktype;
193 int modenumber=vb->W;
194 vorbis_info_mapping0 *info=ci->map_param[modenumber];
195 vorbis_look_psy *psy_look=
196 b->psy+blocktype+(vb->W?2:0);
200 for(i=0;i<vi->channels;i++){
204 float *pcm =vb->pcm[i];
207 gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
209 scale_dB=todB(&scale);
214 _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2);
216 _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2);
219 /* window the PCM data */
220 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
225 _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2);
227 _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2);
230 /* transform the PCM data */
231 /* only MDCT right now.... */
232 mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
234 /* FFT yields more accurate tonal estimation (not phase sensitive) */
235 drft_forward(&b->fft_look[vb->W],pcm);
236 logfft[0]=scale_dB+todB(pcm);
237 local_ampmax[i]=logfft[0];
239 float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1];
240 temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp);
241 if(temp>local_ampmax[i])local_ampmax[i]=temp;
244 if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
245 if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
250 _analysis_output("fftL",seq,logfft,n/2,1,0,0);
252 _analysis_output("fftR",seq,logfft,n/2,1,0,0);
258 float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
259 float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
261 for(i=0;i<vi->channels;i++){
262 /* the encoder setup assumes that all the modes used by any
263 specific bitrate tweaking use the same floor */
265 int submap=info->chmuxlist[i];
267 /* the following makes things clearer to *me* anyway */
268 float *mdct =gmdct[i];
269 float *logfft =vb->pcm[i];
271 float *logmdct =logfft+n/2;
272 float *logmask =logfft;
276 floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
277 memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
280 logmdct[j]=todB(mdct+j);
285 _analysis_output("mdctL",seq,logmdct,n/2,1,0,0);
287 _analysis_output("mdctR",seq,logmdct,n/2,1,0,0);
289 _analysis_output("mdct",seq,logmdct,n/2,1,0,0);
293 /* first step; noise masking. Not only does 'noise masking'
294 give us curves from which we can decide how much resolution
295 to give noise parts of the spectrum, it also implicitly hands
296 us a tonality estimate (the larger the value in the
297 'noise_depth' vector, the more tonal that area is) */
299 _vp_noisemask(psy_look,
301 noise); /* noise does not have by-frequency offset
306 _analysis_output("noiseL",seq,noise,n/2,1,0,0);
308 _analysis_output("noiseR",seq,noise,n/2,1,0,0);
312 /* second step: 'all the other crap'; all the stuff that isn't
313 computed/fit for bitrate management goes in the second psy
314 vector. This includes tone masking, peak limiting and ATH */
316 _vp_tonemask(psy_look,
325 _analysis_output("toneL",seq,tone,n/2,1,0,0);
327 _analysis_output("toneR",seq,tone,n/2,1,0,0);
331 /* third step; we offset the noise vectors, overlay tone
332 masking. We then do a floor1-specific line fit. If we're
333 performing bitrate management, the line fit is performed
334 multiple times for up/down tweakage on demand. */
336 _vp_offset_and_mix(psy_look,
345 _analysis_output("mask1L",seq,logmask,n/2,1,0,0);
347 _analysis_output("mask1R",seq,logmask,n/2,1,0,0);
351 /* this algorithm is hardwired to floor 1 for now; abort out if
352 we're *not* floor1. This won't happen unless someone has
353 broken the encode setup lib. Guard it anyway. */
354 if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1);
356 floor_posts[i][PACKETBLOBS/2]=
357 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
361 /* are we managing bitrate? If so, perform two more fits for
362 later rate tweaking (fits represent hi/lo) */
363 if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){
364 /* higher rate by way of lower noise curve */
366 _vp_offset_and_mix(psy_look,
375 _analysis_output("mask2L",seq,logmask,n/2,1,0,0);
377 _analysis_output("mask2R",seq,logmask,n/2,1,0,0);
381 floor_posts[i][PACKETBLOBS-1]=
382 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
386 /* lower rate by way of higher noise curve */
387 _vp_offset_and_mix(psy_look,
396 _analysis_output("mask0L",seq,logmask,n/2,1,0,0);
398 _analysis_output("mask0R",seq,logmask,n/2,1,0,0);
402 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
406 /* we also interpolate a range of intermediate curves for
407 intermediate rates */
408 for(k=1;k<PACKETBLOBS/2;k++)
410 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
412 floor_posts[i][PACKETBLOBS/2],
413 k*65536/(PACKETBLOBS/2));
414 for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++)
416 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
417 floor_posts[i][PACKETBLOBS/2],
418 floor_posts[i][PACKETBLOBS-1],
419 (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2));
423 vbi->ampmax=global_ampmax;
426 the next phases are performed once for vbr-only and PACKETBLOB
427 times for bitrate managed modes.
429 1) encode actual mode being used
430 2) encode the floor for each channel, compute coded mask curve/res
431 3) normalize and couple.
433 5) save packet bytes to the packetblob vector
437 /* iterate over the many masking curve fits we've created */
440 float **res_bundle=alloca(sizeof(*res_bundle)*vi->channels);
441 float **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
442 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
443 int **sortindex=alloca(sizeof(*sortindex)*vi->channels);
447 mag_memo=_vp_quantize_couple_memo(vb,
452 mag_sort=_vp_quantize_couple_sort(vb,
457 memset(sortindex,0,sizeof(*sortindex)*vi->channels);
458 if(psy_look->vi->normal_channel_p){
459 for(i=0;i<vi->channels;i++){
460 float *mdct =gmdct[i];
461 sortindex[i]=alloca(sizeof(**sortindex)*n/2);
462 _vp_noise_normalize_sort(psy_look,mdct,sortindex[i]);
466 for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
467 k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
470 /* start out our new packet blob with packet type and mode */
471 /* Encode the packet type */
472 oggpack_write(&vb->opb,0,1);
473 /* Encode the modenumber */
474 /* Encode frame mode, pre,post windowsize, then dispatch */
475 oggpack_write(&vb->opb,modenumber,b->modebits);
477 oggpack_write(&vb->opb,vb->lW,1);
478 oggpack_write(&vb->opb,vb->nW,1);
481 /* encode floor, compute masking curve, sep out residue */
482 for(i=0;i<vi->channels;i++){
483 int submap=info->chmuxlist[i];
484 float *mdct =gmdct[i];
485 float *res =vb->pcm[i];
486 int *ilogmask=ilogmaskch[i]=
487 _vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
489 nonzero[i]=floor1_encode(vb,b->flr[info->floorsubmap[submap]],
494 static float FLOOR1_fromdB_LOOKUP[256]={
495 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
496 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
497 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
498 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
499 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
500 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
501 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
502 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
503 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
504 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
505 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
506 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
507 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
508 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
509 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
510 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
511 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
512 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
513 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
514 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
515 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
516 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
517 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
518 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
519 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
520 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
521 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
522 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
523 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
524 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
525 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
526 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
527 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
528 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
529 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
530 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
531 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
532 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
533 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
534 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
535 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
536 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
537 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
538 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
539 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
540 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
541 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
542 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
543 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
544 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
545 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
546 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
547 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
548 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
549 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
550 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
551 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
552 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
553 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
554 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
555 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
556 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
557 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
558 0.82788260F, 0.88168307F, 0.9389798F, 1.F,
562 sprintf(buf,"maskI%c%d",i?'L':'R',k);
565 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]];
566 _analysis_output(buf,seq,work,n/2,1,1,0);
569 _vp_remove_floor(psy_look,
573 ci->psy_g_param.sliding_lowpass[vb->W][k]);
574 _vp_noise_normalize(psy_look,res,res+n/2,sortindex[i]);
579 sprintf(buf,"resI%d",k,i);
580 _analysis_output(buf,seq,res,n/2,1,1,0);
585 /* our iteration is now based on masking curve, not prequant and
586 coupling. Only one prequant/coupling step */
588 /* quantize/couple */
589 /* incomplete implementation that assumes the tree is all depth
590 one, or no tree at all */
591 if(info->coupling_steps){
602 for(i=0;i<vi->channels;i++)
603 memcpy(vb->pcm[i]+n/2,vb->pcm[i],n/2*sizeof(**vb->pcm));
606 /* classify and encode by submap */
607 for(i=0;i<info->submaps;i++){
609 long **classifications;
610 int resnum=info->residuesubmap[i];
612 for(j=0;j<vi->channels;j++){
613 if(info->chmuxlist[j]==i){
614 zerobundle[ch_in_bundle]=0;
615 if(nonzero[j])zerobundle[ch_in_bundle]=1;
616 res_bundle[ch_in_bundle]=vb->pcm[j];
617 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
621 classifications=_residue_P[ci->residue_type[resnum]]->
622 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
624 _residue_P[ci->residue_type[resnum]]->
625 forward(vb,b->residue[resnum],
626 couple_bundle,NULL,zerobundle,ch_in_bundle,classifications);
629 /* ok, done encoding. Mark this protopacket and prepare next. */
630 oggpack_writealign(&vb->opb);
631 vbi->packetblob_markers[k]=oggpack_bytes(&vb->opb);
639 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
644 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
645 vorbis_dsp_state *vd=vb->vd;
646 vorbis_info *vi=vd->vi;
647 codec_setup_info *ci=vi->codec_setup;
648 backend_lookup_state *b=vd->backend_state;
649 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
652 long n=vb->pcmend=ci->blocksizes[vb->W];
654 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
655 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
657 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
658 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
660 /* recover the spectral envelope; store it in the PCM vector for now */
661 for(i=0;i<vi->channels;i++){
662 int submap=info->chmuxlist[i];
663 floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
664 inverse1(vb,b->flr[info->floorsubmap[submap]]);
669 memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
672 /* channel coupling can 'dirty' the nonzero listing */
673 for(i=0;i<info->coupling_steps;i++){
674 if(nonzero[info->coupling_mag[i]] ||
675 nonzero[info->coupling_ang[i]]){
676 nonzero[info->coupling_mag[i]]=1;
677 nonzero[info->coupling_ang[i]]=1;
681 /* recover the residue into our working vectors */
682 for(i=0;i<info->submaps;i++){
684 for(j=0;j<vi->channels;j++){
685 if(info->chmuxlist[j]==i){
687 zerobundle[ch_in_bundle]=1;
689 zerobundle[ch_in_bundle]=0;
690 pcmbundle[ch_in_bundle++]=vb->pcm[j];
694 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
695 inverse(vb,b->residue[info->residuesubmap[i]],
696 pcmbundle,zerobundle,ch_in_bundle);
699 /* channel coupling */
700 for(i=info->coupling_steps-1;i>=0;i--){
701 float *pcmM=vb->pcm[info->coupling_mag[i]];
702 float *pcmA=vb->pcm[info->coupling_ang[i]];
727 /* compute and apply spectral envelope */
728 for(i=0;i<vi->channels;i++){
729 float *pcm=vb->pcm[i];
730 int submap=info->chmuxlist[i];
731 _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
732 inverse2(vb,b->flr[info->floorsubmap[submap]],
736 /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
737 /* only MDCT right now.... */
738 for(i=0;i<vi->channels;i++){
739 float *pcm=vb->pcm[i];
740 mdct_backward(b->transform[vb->W][0],pcm,pcm);
743 /* window the data */
744 for(i=0;i<vi->channels;i++){
745 float *pcm=vb->pcm[i];
747 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
759 vorbis_func_mapping mapping0_exportbundle={