dbf-halloween2015
view libs/vorbis/mapping0.c @ 1:c3f5c32cb210
barfed all the libraries in the source tree to make porting easier
| author | John Tsiombikas <nuclear@member.fsf.org> |
|---|---|
| date | Sun, 01 Nov 2015 00:36:56 +0200 |
| parents | |
| children |
line source
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 ********************************************************************
13 function: channel mapping 0 implementation
14 last mod: $Id: mapping0.c 17022 2010-03-25 03:45:42Z xiphmont $
16 ********************************************************************/
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"
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.
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;
42 if(info){
43 memset(info,0,sizeof(*info));
44 _ogg_free(info);
45 }
46 }
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 }
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;
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. */
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);
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));
83 }
84 }else
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... */
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 }
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));
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;
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));
125 if(testM<0 ||
126 testA<0 ||
127 testM==testA ||
128 testM>=vi->channels ||
129 testA>=vi->channels) goto err_out;
130 }
132 }
134 if(oggpack_read(opb,2)!=0)goto err_out; /* 2,3:reserved */
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 }
150 return info;
152 err_out:
153 mapping0_free_info(info);
154 return(NULL);
155 }
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"
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 };
235 #endif
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;
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));
252 float global_ampmax=vbi->ampmax;
253 float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
254 int blocktype=vbi->blocktype;
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);
260 vb->mode=modenumber;
262 for(i=0;i<vi->channels;i++){
263 float scale=4.f/n;
264 float scale_dB;
266 float *pcm =vb->pcm[i];
267 float *logfft =pcm;
269 iwork[i]=_vorbis_block_alloc(vb,n/2*sizeof(**iwork));
270 gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
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. */
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
298 /* window the PCM data */
299 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
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
312 /* transform the PCM data */
313 /* only MDCT right now.... */
314 mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
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 }
353 if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
354 if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
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
368 }
370 {
371 float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
372 float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
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 */
378 int submap=info->chmuxlist[i];
380 /* the following makes things clearer to *me* anyway */
381 float *mdct =gmdct[i];
382 float *logfft =vb->pcm[i];
384 float *logmdct =logfft+n/2;
385 float *logmask =logfft;
387 vb->mode=modenumber;
389 floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
390 memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
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. */
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
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) */
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
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 */
444 _vp_tonemask(psy_look,
445 logfft,
446 tone,
447 global_ampmax,
448 local_ampmax[i]);
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
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. */
466 #if 0
467 {
468 float aotuv[psy_look->n];
469 #endif
471 _vp_offset_and_mix(psy_look,
472 noise,
473 tone,
474 1,
475 logmask,
476 mdct,
477 logmdct);
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
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
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);
508 floor_posts[i][PACKETBLOBS/2]=
509 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
510 logmdct,
511 logmask);
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 */
518 _vp_offset_and_mix(psy_look,
519 noise,
520 tone,
521 2,
522 logmask,
523 mdct,
524 logmdct);
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
537 floor_posts[i][PACKETBLOBS-1]=
538 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
539 logmdct,
540 logmask);
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);
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
562 floor_posts[i][0]=
563 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
564 logmdct,
565 logmask);
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;
586 /*
587 the next phases are performed once for vbr-only and PACKETBLOB
588 times for bitrate managed modes.
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
596 */
598 /* iterate over the many masking curve fits we've created */
600 {
601 int **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
602 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
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];
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 }
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];
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 }
640 /* our iteration is now based on masking curve, not prequant and
641 coupling. Only one prequant/coupling step */
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);
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
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];
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 }
681 classifications=_residue_P[ci->residue_type[resnum]]->
682 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
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];
689 _residue_P[ci->residue_type[resnum]]->
690 forward(opb,vb,b->residue[resnum],
691 couple_bundle,zerobundle,ch_in_bundle,classifications,i);
692 }
694 /* ok, done encoding. Next protopacket. */
695 }
697 }
699 #if 0
700 seq++;
701 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
702 #endif
703 return(0);
704 }
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;
713 int i,j;
714 long n=vb->pcmend=ci->blocksizes[vb->W];
716 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
717 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
719 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
720 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
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 }
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 }
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 }
756 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
757 inverse(vb,b->residue[info->residuesubmap[i]],
758 pcmbundle,zerobundle,ch_in_bundle);
759 }
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]];
766 for(j=0;j<n/2;j++){
767 float mag=pcmM[j];
768 float ang=pcmA[j];
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 }
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 }
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 }
805 /* all done! */
806 return(0);
807 }
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 };