The Tor Browser / file comparison

comparison: media/libvorbis/lib/vorbis_mapping0.c

media/libvorbis/lib/vorbis_mapping0.c

branch
TOR_BUG_9701
changeset 8
97036ab72558
equal deleted inserted replaced
-1:000000000000 0:94933cf549e0
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 ********************************************************************
12
13 function: channel mapping 0 implementation
14 last mod: $Id: mapping0.c 17022 2010-03-25 03:45:42Z 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 **iwork = _vorbis_block_alloc(vb,vi->channels*sizeof(*iwork));
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=b->psy+blocktype+(vb->W?2:0);
259
260 vb->mode=modenumber;
261
262 for(i=0;i<vi->channels;i++){
263 float scale=4.f/n;
264 float scale_dB;
265
266 float *pcm =vb->pcm[i];
267 float *logfft =pcm;
268
269 iwork[i]=_vorbis_block_alloc(vb,n/2*sizeof(**iwork));
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 int **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
602 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
603
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];
608
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 }
619
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];
624
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 }
639
640 /* our iteration is now based on masking curve, not prequant and
641 coupling. Only one prequant/coupling step */
642
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);
655
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
666
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];
672
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 }
680
681 classifications=_residue_P[ci->residue_type[resnum]]->
682 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
683
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];
688
689 _residue_P[ci->residue_type[resnum]]->
690 forward(opb,vb,b->residue[resnum],
691 couple_bundle,zerobundle,ch_in_bundle,classifications,i);
692 }
693
694 /* ok, done encoding. Next protopacket. */
695 }
696
697 }
698
699 #if 0
700 seq++;
701 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
702 #endif
703 return(0);
704 }
705
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;
712
713 int i,j;
714 long n=vb->pcmend=ci->blocksizes[vb->W];
715
716 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
717 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
718
719 int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
720 void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
721
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 }
733
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 }
742
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 }
755
756 _residue_P[ci->residue_type[info->residuesubmap[i]]]->
757 inverse(vb,b->residue[info->residuesubmap[i]],
758 pcmbundle,zerobundle,ch_in_bundle);
759 }
760
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]];
765
766 for(j=0;j<n/2;j++){
767 float mag=pcmM[j];
768 float ang=pcmA[j];
769
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 }
788
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 }
797
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 }
804
805 /* all done! */
806 return(0);
807 }
808
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 };

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial