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-2007 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
11 ********************************************************************
13 function: channel mapping 0 implementation
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,
233 static int mapping0_forward(vorbis_block *vb){
234 vorbis_dsp_state *vd=vb->vd;
235 vorbis_info *vi=vd->vi;
236 codec_setup_info *ci=vi->codec_setup;
237 private_state *b=vb->vd->backend_state;
238 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
242 int *nonzero = alloca(sizeof(*nonzero)*vi->channels);
243 float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
244 int **ilogmaskch= _vorbis_block_alloc(vb,vi->channels*sizeof(*ilogmaskch));
245 int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
247 float global_ampmax=vbi->ampmax;
248 float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
249 int blocktype=vbi->blocktype;
251 int modenumber=vb->W;
252 vorbis_info_mapping0 *info=ci->map_param[modenumber];
253 vorbis_look_psy *psy_look=
254 b->psy+blocktype+(vb->W?2:0);
258 for(i=0;i<vi->channels;i++){
262 float *pcm =vb->pcm[i];
265 gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
267 scale_dB=todB(&scale) + .345; /* + .345 is a hack; the original
268 todB estimation used on IEEE 754
269 compliant machines had a bug that
270 returned dB values about a third
271 of a decibel too high. The bug
272 was harmless because tunings
273 implicitly took that into
274 account. However, fixing the bug
275 in the estimator requires
276 changing all the tunings as well.
277 For now, it's easier to sync
278 things back up here, and
279 recalibrate the tunings in the
280 next major model upgrade. */
285 _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2);
287 _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2);
289 _analysis_output("pcm",seq,pcm,n,0,0,total-n/2);
293 /* window the PCM data */
294 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
299 _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2);
301 _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2);
303 _analysis_output("windowed",seq,pcm,n,0,0,total-n/2);
307 /* transform the PCM data */
308 /* only MDCT right now.... */
309 mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
311 /* FFT yields more accurate tonal estimation (not phase sensitive) */
312 drft_forward(&b->fft_look[vb->W],pcm);
313 logfft[0]=scale_dB+todB(pcm) + .345; /* + .345 is a hack; the
314 original todB estimation used on
315 IEEE 754 compliant machines had a
316 bug that returned dB values about
317 a third of a decibel too high.
318 The bug was harmless because
319 tunings implicitly took that into
320 account. However, fixing the bug
321 in the estimator requires
322 changing all the tunings as well.
323 For now, it's easier to sync
324 things back up here, and
325 recalibrate the tunings in the
326 next major model upgrade. */
327 local_ampmax[i]=logfft[0];
329 float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1];
330 temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp) + .345; /* +
331 .345 is a hack; the original todB
332 estimation used on IEEE 754
333 compliant machines had a bug that
334 returned dB values about a third
335 of a decibel too high. The bug
336 was harmless because tunings
337 implicitly took that into
338 account. However, fixing the bug
339 in the estimator requires
340 changing all the tunings as well.
341 For now, it's easier to sync
342 things back up here, and
343 recalibrate the tunings in the
344 next major model upgrade. */
345 if(temp>local_ampmax[i])local_ampmax[i]=temp;
348 if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
349 if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
354 _analysis_output("fftL",seq,logfft,n/2,1,0,0);
356 _analysis_output("fftR",seq,logfft,n/2,1,0,0);
359 _analysis_output("fft",seq,logfft,n/2,1,0,0);
366 float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
367 float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
369 for(i=0;i<vi->channels;i++){
370 /* the encoder setup assumes that all the modes used by any
371 specific bitrate tweaking use the same floor */
373 int submap=info->chmuxlist[i];
375 /* the following makes things clearer to *me* anyway */
376 float *mdct =gmdct[i];
377 float *logfft =vb->pcm[i];
379 float *logmdct =logfft+n/2;
380 float *logmask =logfft;
384 floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
385 memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
388 logmdct[j]=todB(mdct+j) + .345; /* + .345 is a hack; the original
389 todB estimation used on IEEE 754
390 compliant machines had a bug that
391 returned dB values about a third
392 of a decibel too high. The bug
393 was harmless because tunings
394 implicitly took that into
395 account. However, fixing the bug
396 in the estimator requires
397 changing all the tunings as well.
398 For now, it's easier to sync
399 things back up here, and
400 recalibrate the tunings in the
401 next major model upgrade. */
406 _analysis_output("mdctL",seq,logmdct,n/2,1,0,0);
408 _analysis_output("mdctR",seq,logmdct,n/2,1,0,0);
410 _analysis_output("mdct",seq,logmdct,n/2,1,0,0);
414 /* first step; noise masking. Not only does 'noise masking'
415 give us curves from which we can decide how much resolution
416 to give noise parts of the spectrum, it also implicitly hands
417 us a tonality estimate (the larger the value in the
418 'noise_depth' vector, the more tonal that area is) */
420 _vp_noisemask(psy_look,
422 noise); /* noise does not have by-frequency offset
427 _analysis_output("noiseL",seq,noise,n/2,1,0,0);
429 _analysis_output("noiseR",seq,noise,n/2,1,0,0);
431 _analysis_output("noise",seq,noise,n/2,1,0,0);
435 /* second step: 'all the other crap'; all the stuff that isn't
436 computed/fit for bitrate management goes in the second psy
437 vector. This includes tone masking, peak limiting and ATH */
439 _vp_tonemask(psy_look,
448 _analysis_output("toneL",seq,tone,n/2,1,0,0);
450 _analysis_output("toneR",seq,tone,n/2,1,0,0);
452 _analysis_output("tone",seq,tone,n/2,1,0,0);
456 /* third step; we offset the noise vectors, overlay tone
457 masking. We then do a floor1-specific line fit. If we're
458 performing bitrate management, the line fit is performed
459 multiple times for up/down tweakage on demand. */
463 float aotuv[psy_look->n];
466 _vp_offset_and_mix(psy_look,
477 _analysis_output("aotuvM1_L",seq,aotuv,psy_look->n,1,1,0);
479 _analysis_output("aotuvM1_R",seq,aotuv,psy_look->n,1,1,0);
481 _analysis_output("aotuvM1",seq,aotuv,psy_look->n,1,1,0);
490 _analysis_output("mask1L",seq,logmask,n/2,1,0,0);
492 _analysis_output("mask1R",seq,logmask,n/2,1,0,0);
494 _analysis_output("mask1",seq,logmask,n/2,1,0,0);
498 /* this algorithm is hardwired to floor 1 for now; abort out if
499 we're *not* floor1. This won't happen unless someone has
500 broken the encode setup lib. Guard it anyway. */
501 if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1);
503 floor_posts[i][PACKETBLOBS/2]=
504 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
508 /* are we managing bitrate? If so, perform two more fits for
509 later rate tweaking (fits represent hi/lo) */
510 if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){
511 /* higher rate by way of lower noise curve */
513 _vp_offset_and_mix(psy_look,
524 _analysis_output("mask2L",seq,logmask,n/2,1,0,0);
526 _analysis_output("mask2R",seq,logmask,n/2,1,0,0);
528 _analysis_output("mask2",seq,logmask,n/2,1,0,0);
532 floor_posts[i][PACKETBLOBS-1]=
533 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
537 /* lower rate by way of higher noise curve */
538 _vp_offset_and_mix(psy_look,
549 _analysis_output("mask0L",seq,logmask,n/2,1,0,0);
551 _analysis_output("mask0R",seq,logmask,n/2,1,0,0);
553 _analysis_output("mask0",seq,logmask,n/2,1,0,0);
558 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
562 /* we also interpolate a range of intermediate curves for
563 intermediate rates */
564 for(k=1;k<PACKETBLOBS/2;k++)
566 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
568 floor_posts[i][PACKETBLOBS/2],
569 k*65536/(PACKETBLOBS/2));
570 for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++)
572 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
573 floor_posts[i][PACKETBLOBS/2],
574 floor_posts[i][PACKETBLOBS-1],
575 (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2));
579 vbi->ampmax=global_ampmax;
582 the next phases are performed once for vbr-only and PACKETBLOB
583 times for bitrate managed modes.
585 1) encode actual mode being used
586 2) encode the floor for each channel, compute coded mask curve/res
587 3) normalize and couple.
589 5) save packet bytes to the packetblob vector
593 /* iterate over the many masking curve fits we've created */
596 float **res_bundle=alloca(sizeof(*res_bundle)*vi->channels);
597 float **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
598 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
599 int **sortindex=alloca(sizeof(*sortindex)*vi->channels);
600 float **mag_memo=NULL;
603 if(info->coupling_steps){
604 mag_memo=_vp_quantize_couple_memo(vb,
610 mag_sort=_vp_quantize_couple_sort(vb,
615 hf_reduction(&ci->psy_g_param,
621 memset(sortindex,0,sizeof(*sortindex)*vi->channels);
622 if(psy_look->vi->normal_channel_p){
623 for(i=0;i<vi->channels;i++){
624 float *mdct =gmdct[i];
625 sortindex[i]=alloca(sizeof(**sortindex)*n/2);
626 _vp_noise_normalize_sort(psy_look,mdct,sortindex[i]);
630 for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
631 k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
633 oggpack_buffer *opb=vbi->packetblob[k];
635 /* start out our new packet blob with packet type and mode */
636 /* Encode the packet type */
637 oggpack_write(opb,0,1);
638 /* Encode the modenumber */
639 /* Encode frame mode, pre,post windowsize, then dispatch */
640 oggpack_write(opb,modenumber,b->modebits);
642 oggpack_write(opb,vb->lW,1);
643 oggpack_write(opb,vb->nW,1);
646 /* encode floor, compute masking curve, sep out residue */
647 for(i=0;i<vi->channels;i++){
648 int submap=info->chmuxlist[i];
649 float *mdct =gmdct[i];
650 float *res =vb->pcm[i];
651 int *ilogmask=ilogmaskch[i]=
652 _vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
654 nonzero[i]=floor1_encode(opb,vb,b->flr[info->floorsubmap[submap]],
660 sprintf(buf,"maskI%c%d",i?'R':'L',k);
663 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]];
664 _analysis_output(buf,seq,work,n/2,1,1,0);
667 _vp_remove_floor(psy_look,
671 ci->psy_g_param.sliding_lowpass[vb->W][k]);
673 _vp_noise_normalize(psy_look,res,res+n/2,sortindex[i]);
681 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]]*(res+n/2)[j];
682 sprintf(buf,"resI%c%d",i?'R':'L',k);
683 _analysis_output(buf,seq,work,n/2,1,1,0);
689 /* our iteration is now based on masking curve, not prequant and
690 coupling. Only one prequant/coupling step */
692 /* quantize/couple */
693 /* incomplete implementation that assumes the tree is all depth
694 one, or no tree at all */
695 if(info->coupling_steps){
705 ci->psy_g_param.sliding_lowpass[vb->W][k]);
708 /* classify and encode by submap */
709 for(i=0;i<info->submaps;i++){
711 long **classifications;
712 int resnum=info->residuesubmap[i];
714 for(j=0;j<vi->channels;j++){
715 if(info->chmuxlist[j]==i){
716 zerobundle[ch_in_bundle]=0;
717 if(nonzero[j])zerobundle[ch_in_bundle]=1;
718 res_bundle[ch_in_bundle]=vb->pcm[j];
719 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
723 classifications=_residue_P[ci->residue_type[resnum]]->
724 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
726 /* couple_bundle is destructively overwritten by
727 the class function if some but not all of the channels are
728 marked as silence; build a fresh copy */
730 for(j=0;j<vi->channels;j++)
731 if(info->chmuxlist[j]==i)
732 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
734 _residue_P[ci->residue_type[resnum]]->
735 forward(opb,vb,b->residue[resnum],
736 couple_bundle,NULL,zerobundle,ch_in_bundle,classifications);
739 /* ok, done encoding. Next protopacket. */
746 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
751 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
752 vorbis_dsp_state *vd=vb->vd;
753 vorbis_info *vi=vd->vi;
754 codec_setup_info *ci=vi->codec_setup;
755 private_state *b=vd->backend_state;
756 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
759 long n=vb->pcmend=ci->blocksizes[vb->W];
761 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
762 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
764 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
765 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
767 /* recover the spectral envelope; store it in the PCM vector for now */
768 for(i=0;i<vi->channels;i++){
769 int submap=info->chmuxlist[i];
770 floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
771 inverse1(vb,b->flr[info->floorsubmap[submap]]);
776 memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
779 /* channel coupling can 'dirty' the nonzero listing */
780 for(i=0;i<info->coupling_steps;i++){
781 if(nonzero[info->coupling_mag[i]] ||
782 nonzero[info->coupling_ang[i]]){
783 nonzero[info->coupling_mag[i]]=1;
784 nonzero[info->coupling_ang[i]]=1;
788 /* recover the residue into our working vectors */
789 for(i=0;i<info->submaps;i++){
791 for(j=0;j<vi->channels;j++){
792 if(info->chmuxlist[j]==i){
794 zerobundle[ch_in_bundle]=1;
796 zerobundle[ch_in_bundle]=0;
797 pcmbundle[ch_in_bundle++]=vb->pcm[j];
801 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
802 inverse(vb,b->residue[info->residuesubmap[i]],
803 pcmbundle,zerobundle,ch_in_bundle);
806 /* channel coupling */
807 for(i=info->coupling_steps-1;i>=0;i--){
808 float *pcmM=vb->pcm[info->coupling_mag[i]];
809 float *pcmA=vb->pcm[info->coupling_ang[i]];
834 /* compute and apply spectral envelope */
835 for(i=0;i<vi->channels;i++){
836 float *pcm=vb->pcm[i];
837 int submap=info->chmuxlist[i];
838 _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
839 inverse2(vb,b->flr[info->floorsubmap[submap]],
843 /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
844 /* only MDCT right now.... */
845 for(i=0;i<vi->channels;i++){
846 float *pcm=vb->pcm[i];
847 mdct_backward(b->transform[vb->W][0],pcm,pcm);
855 const vorbis_func_mapping mapping0_exportbundle={