?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
K2.6 patches and update.
[tomato.git] / release / src / router / libvorbis / lib / mapping0.c
blob716fa4cd84e0d42821fb2a3565daf84794b87324
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-2009 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
10 * *
11 ********************************************************************
12
13 function: channel mapping 0 implementation
14 last mod: $Id: mapping0.c 16227 2009-07-08 06:58:46Z xiphmont $
15
16 ********************************************************************/
17
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"
30
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.
35
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 */
39
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 }
47
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 }
57
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;
62
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. */
69
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);
75
76 if(info->coupling_steps>0){
77 oggpack_write(opb,1,1);
78 oggpack_write(opb,info->coupling_steps-1,8);
79
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);
86
87 oggpack_write(opb,0,2); /* 2,3:reserved */
88
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 }
100
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));
107
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;
115
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));
124
125 if(testM<0 ||
126 testA<0 ||
127 testM==testA ||
128 testM>=vi->channels ||
129 testA>=vi->channels) goto err_out;
130 }
131
132 }
133
134 if(oggpack_read(opb,2)!=0)goto err_out; /* 2,3:reserved */
135
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 }
149
150 return info;
151
152 err_out:
153 mapping0_free_info(info);
154 return(NULL);
155 }
156
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"
164
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 };
234
235 #endif
236
237
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;
246
247 int *nonzero = alloca(sizeof(*nonzero)*vi->channels);
248 float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
249 int **ilogmaskch= _vorbis_block_alloc(vb,vi->channels*sizeof(*ilogmaskch));
250 int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
251
252 float global_ampmax=vbi->ampmax;
253 float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
254 int blocktype=vbi->blocktype;
255
256 int modenumber=vb->W;
257 vorbis_info_mapping0 *info=ci->map_param[modenumber];
258 vorbis_look_psy *psy_look=
259 b->psy+blocktype+(vb->W?2:0);
260
261 vb->mode=modenumber;
262
263 for(i=0;i<vi->channels;i++){
264 float scale=4.f/n;
265 float scale_dB;
266
267 float *pcm =vb->pcm[i];
268 float *logfft =pcm;
269
270 gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
271
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. */
286
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
297
298 /* window the PCM data */
299 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
300
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
311
312 /* transform the PCM data */
313 /* only MDCT right now.... */
314 mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
315
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 }
352
353 if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
354 if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
355
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
367
368 }
369
370 {
371 float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
372 float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
373
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 */
377
378 int submap=info->chmuxlist[i];
379
380 /* the following makes things clearer to *me* anyway */
381 float *mdct =gmdct[i];
382 float *logfft =vb->pcm[i];
383
384 float *logmdct =logfft+n/2;
385 float *logmask =logfft;
386
387 vb->mode=modenumber;
388
389 floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
390 memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
391
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. */
407
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
418
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) */
424
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
439
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 */
443
444 _vp_tonemask(psy_look,
445 logfft,
446 tone,
447 global_ampmax,
448 local_ampmax[i]);
449
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
460
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. */
465
466 #if 0
467 {
468 float aotuv[psy_look->n];
469 #endif
470
471 _vp_offset_and_mix(psy_look,
472 noise,
473 tone,
474 1,
475 logmask,
476 mdct,
477 logmdct);
478
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
490
491
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
502
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);
507
508 floor_posts[i][PACKETBLOBS/2]=
509 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
510 logmdct,
511 logmask);
512
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 */
517
518 _vp_offset_and_mix(psy_look,
519 noise,
520 tone,
521 2,
522 logmask,
523 mdct,
524 logmdct);
525
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
536
537 floor_posts[i][PACKETBLOBS-1]=
538 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
539 logmdct,
540 logmask);
541
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);
550
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
561
562 floor_posts[i][0]=
563 floor1_fit(vb,b->flr[info->floorsubmap[submap]],
564 logmdct,
565 logmask);
566
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;
585
586 /*
587 the next phases are performed once for vbr-only and PACKETBLOB
588 times for bitrate managed modes.
589
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
595
596 */
597
598 /* iterate over the many masking curve fits we've created */
599
600 {
601 float **res_bundle=alloca(sizeof(*res_bundle)*vi->channels);
602 float **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
603 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
604 int **sortindex=alloca(sizeof(*sortindex)*vi->channels);
605 float **mag_memo=NULL;
606 int **mag_sort=NULL;
607
608 if(info->coupling_steps){
609 mag_memo=_vp_quantize_couple_memo(vb,
610 &ci->psy_g_param,
611 psy_look,
612 info,
613 gmdct);
614
615 mag_sort=_vp_quantize_couple_sort(vb,
616 psy_look,
617 info,
618 mag_memo);
619
620 hf_reduction(&ci->psy_g_param,
621 psy_look,
622 info,
623 mag_memo);
624 }
625
626 memset(sortindex,0,sizeof(*sortindex)*vi->channels);
627 if(psy_look->vi->normal_channel_p){
628 for(i=0;i<vi->channels;i++){
629 float *mdct =gmdct[i];
630 sortindex[i]=alloca(sizeof(**sortindex)*n/2);
631 _vp_noise_normalize_sort(psy_look,mdct,sortindex[i]);
632 }
633 }
634
635 for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
636 k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
637 k++){
638 oggpack_buffer *opb=vbi->packetblob[k];
639
640 /* start out our new packet blob with packet type and mode */
641 /* Encode the packet type */
642 oggpack_write(opb,0,1);
643 /* Encode the modenumber */
644 /* Encode frame mode, pre,post windowsize, then dispatch */
645 oggpack_write(opb,modenumber,b->modebits);
646 if(vb->W){
647 oggpack_write(opb,vb->lW,1);
648 oggpack_write(opb,vb->nW,1);
649 }
650
651 /* encode floor, compute masking curve, sep out residue */
652 for(i=0;i<vi->channels;i++){
653 int submap=info->chmuxlist[i];
654 float *mdct =gmdct[i];
655 float *res =vb->pcm[i];
656 int *ilogmask=ilogmaskch[i]=
657 _vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
658
659 nonzero[i]=floor1_encode(opb,vb,b->flr[info->floorsubmap[submap]],
660 floor_posts[i][k],
661 ilogmask);
662 #if 0
663 {
664 char buf[80];
665 sprintf(buf,"maskI%c%d",i?'R':'L',k);
666 float work[n/2];
667 for(j=0;j<n/2;j++)
668 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]];
669 _analysis_output(buf,seq,work,n/2,1,1,0);
670 }
671 #endif
672 _vp_remove_floor(psy_look,
673 mdct,
674 ilogmask,
675 res,
676 ci->psy_g_param.sliding_lowpass[vb->W][k]);
677
678 _vp_noise_normalize(psy_look,res,res+n/2,sortindex[i]);
679
680
681 #if 0
682 {
683 char buf[80];
684 float work[n/2];
685 for(j=0;j<n/2;j++)
686 work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]]*(res+n/2)[j];
687 sprintf(buf,"resI%c%d",i?'R':'L',k);
688 _analysis_output(buf,seq,work,n/2,1,1,0);
689
690 }
691 #endif
692 }
693
694 /* our iteration is now based on masking curve, not prequant and
695 coupling. Only one prequant/coupling step */
696
697 /* quantize/couple */
698 /* incomplete implementation that assumes the tree is all depth
699 one, or no tree at all */
700 if(info->coupling_steps){
701 _vp_couple(k,
702 &ci->psy_g_param,
703 psy_look,
704 info,
705 vb->pcm,
706 mag_memo,
707 mag_sort,
708 ilogmaskch,
709 nonzero,
710 ci->psy_g_param.sliding_lowpass[vb->W][k]);
711 }
712
713 /* classify and encode by submap */
714 for(i=0;i<info->submaps;i++){
715 int ch_in_bundle=0;
716 long **classifications;
717 int resnum=info->residuesubmap[i];
718
719 for(j=0;j<vi->channels;j++){
720 if(info->chmuxlist[j]==i){
721 zerobundle[ch_in_bundle]=0;
722 if(nonzero[j])zerobundle[ch_in_bundle]=1;
723 res_bundle[ch_in_bundle]=vb->pcm[j];
724 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
725 }
726 }
727
728 classifications=_residue_P[ci->residue_type[resnum]]->
729 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
730
731 /* couple_bundle is destructively overwritten by
732 the class function if some but not all of the channels are
733 marked as silence; build a fresh copy */
734 ch_in_bundle=0;
735 for(j=0;j<vi->channels;j++)
736 if(info->chmuxlist[j]==i)
737 couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
738
739 _residue_P[ci->residue_type[resnum]]->
740 forward(opb,vb,b->residue[resnum],
741 couple_bundle,NULL,zerobundle,ch_in_bundle,classifications);
742 }
743
744 /* ok, done encoding. Next protopacket. */
745 }
746
747 }
748
749 #if 0
750 seq++;
751 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
752 #endif
753 return(0);
754 }
755
756 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
757 vorbis_dsp_state *vd=vb->vd;
758 vorbis_info *vi=vd->vi;
759 codec_setup_info *ci=vi->codec_setup;
760 private_state *b=vd->backend_state;
761 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
762
763 int i,j;
764 long n=vb->pcmend=ci->blocksizes[vb->W];
765
766 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
767 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
768
769 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
770 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
771
772 /* recover the spectral envelope; store it in the PCM vector for now */
773 for(i=0;i<vi->channels;i++){
774 int submap=info->chmuxlist[i];
775 floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
776 inverse1(vb,b->flr[info->floorsubmap[submap]]);
777 if(floormemo[i])
778 nonzero[i]=1;
779 else
780 nonzero[i]=0;
781 memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
782 }
783
784 /* channel coupling can 'dirty' the nonzero listing */
785 for(i=0;i<info->coupling_steps;i++){
786 if(nonzero[info->coupling_mag[i]] ||
787 nonzero[info->coupling_ang[i]]){
788 nonzero[info->coupling_mag[i]]=1;
789 nonzero[info->coupling_ang[i]]=1;
790 }
791 }
792
793 /* recover the residue into our working vectors */
794 for(i=0;i<info->submaps;i++){
795 int ch_in_bundle=0;
796 for(j=0;j<vi->channels;j++){
797 if(info->chmuxlist[j]==i){
798 if(nonzero[j])
799 zerobundle[ch_in_bundle]=1;
800 else
801 zerobundle[ch_in_bundle]=0;
802 pcmbundle[ch_in_bundle++]=vb->pcm[j];
803 }
804 }
805
806 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
807 inverse(vb,b->residue[info->residuesubmap[i]],
808 pcmbundle,zerobundle,ch_in_bundle);
809 }
810
811 /* channel coupling */
812 for(i=info->coupling_steps-1;i>=0;i--){
813 float *pcmM=vb->pcm[info->coupling_mag[i]];
814 float *pcmA=vb->pcm[info->coupling_ang[i]];
815
816 for(j=0;j<n/2;j++){
817 float mag=pcmM[j];
818 float ang=pcmA[j];
819
820 if(mag>0)
821 if(ang>0){
822 pcmM[j]=mag;
823 pcmA[j]=mag-ang;
824 }else{
825 pcmA[j]=mag;
826 pcmM[j]=mag+ang;
827 }
828 else
829 if(ang>0){
830 pcmM[j]=mag;
831 pcmA[j]=mag+ang;
832 }else{
833 pcmA[j]=mag;
834 pcmM[j]=mag-ang;
835 }
836 }
837 }
838
839 /* compute and apply spectral envelope */
840 for(i=0;i<vi->channels;i++){
841 float *pcm=vb->pcm[i];
842 int submap=info->chmuxlist[i];
843 _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
844 inverse2(vb,b->flr[info->floorsubmap[submap]],
845 floormemo[i],pcm);
846 }
847
848 /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
849 /* only MDCT right now.... */
850 for(i=0;i<vi->channels;i++){
851 float *pcm=vb->pcm[i];
852 mdct_backward(b->transform[vb->W][0],pcm,pcm);
853 }
854
855 /* all done! */
856 return(0);
857 }
858
859 /* export hooks */
860 const vorbis_func_mapping mapping0_exportbundle={
861 &mapping0_pack,
862 &mapping0_unpack,
863 &mapping0_free_info,
864 &mapping0_forward,
865 &mapping0_inverse
866 };
Tomato firmware and modifications.