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 19441 2015-01-21 01:17:41Z 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 void mapping0_pack(vorbis_info *vi,vorbis_info_mapping *vm, 49 oggpack_buffer *opb){ 50 int i; 51 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm; 52 53 /* another 'we meant to do it this way' hack... up to beta 4, we 54 packed 4 binary zeros here to signify one submapping in use. We 55 now redefine that to mean four bitflags that indicate use of 56 deeper features; bit0:submappings, bit1:coupling, 57 bit2,3:reserved. This is backward compatable with all actual uses 58 of the beta code. */ 59 60 if(info->submaps>1){ 61 oggpack_write(opb,1,1); 62 oggpack_write(opb,info->submaps-1,4); 63 }else 64 oggpack_write(opb,0,1); 65 66 if(info->coupling_steps>0){ 67 oggpack_write(opb,1,1); 68 oggpack_write(opb,info->coupling_steps-1,8); 69 70 for(i=0;i<info->coupling_steps;i++){ 71 oggpack_write(opb,info->coupling_mag[i],ov_ilog(vi->channels-1)); 72 oggpack_write(opb,info->coupling_ang[i],ov_ilog(vi->channels-1)); 73 } 74 }else 75 oggpack_write(opb,0,1); 76 77 oggpack_write(opb,0,2); /* 2,3:reserved */ 78 79 /* we don't write the channel submappings if we only have one... */ 80 if(info->submaps>1){ 81 for(i=0;i<vi->channels;i++) 82 oggpack_write(opb,info->chmuxlist[i],4); 83 } 84 for(i=0;i<info->submaps;i++){ 85 oggpack_write(opb,0,8); /* time submap unused */ 86 oggpack_write(opb,info->floorsubmap[i],8); 87 oggpack_write(opb,info->residuesubmap[i],8); 88 } 89 } 90 91 /* also responsible for range checking */ 92 static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){ 93 int i,b; 94 vorbis_info_mapping0 *info=_ogg_calloc(1,sizeof(*info)); 95 codec_setup_info *ci=vi->codec_setup; 96 memset(info,0,sizeof(*info)); 97 if(vi->channels<=0)goto err_out; 98 99 b=oggpack_read(opb,1); 100 if(b<0)goto err_out; 101 if(b){ 102 info->submaps=oggpack_read(opb,4)+1; 103 if(info->submaps<=0)goto err_out; 104 }else 105 info->submaps=1; 106 107 b=oggpack_read(opb,1); 108 if(b<0)goto err_out; 109 if(b){ 110 info->coupling_steps=oggpack_read(opb,8)+1; 111 if(info->coupling_steps<=0)goto err_out; 112 for(i=0;i<info->coupling_steps;i++){ 113 /* vi->channels > 0 is enforced in the caller */ 114 int testM=info->coupling_mag[i]= 115 oggpack_read(opb,ov_ilog(vi->channels-1)); 116 int testA=info->coupling_ang[i]= 117 oggpack_read(opb,ov_ilog(vi->channels-1)); 118 119 if(testM<0 || 120 testA<0 || 121 testM==testA || 122 testM>=vi->channels || 123 testA>=vi->channels) goto err_out; 124 } 125 126 } 127 128 if(oggpack_read(opb,2)!=0)goto err_out; /* 2,3:reserved */ 129 130 if(info->submaps>1){ 131 for(i=0;i<vi->channels;i++){ 132 info->chmuxlist[i]=oggpack_read(opb,4); 133 if(info->chmuxlist[i]>=info->submaps || info->chmuxlist[i]<0)goto err_out; 134 } 135 } 136 for(i=0;i<info->submaps;i++){ 137 oggpack_read(opb,8); /* time submap unused */ 138 info->floorsubmap[i]=oggpack_read(opb,8); 139 if(info->floorsubmap[i]>=ci->floors || info->floorsubmap[i]<0)goto err_out; 140 info->residuesubmap[i]=oggpack_read(opb,8); 141 if(info->residuesubmap[i]>=ci->residues || info->residuesubmap[i]<0)goto err_out; 142 } 143 144 return info; 145 146 err_out: 147 mapping0_free_info(info); 148 return(NULL); 149 } 150 151 #include "os.h" 152 #include "lpc.h" 153 #include "lsp.h" 154 #include "envelope.h" 155 #include "mdct.h" 156 #include "psy.h" 157 #include "scales.h" 158 159 #if 0 160 static long seq=0; 161 static ogg_int64_t total=0; 162 static float FLOOR1_fromdB_LOOKUP[256]={ 163 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F, 164 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F, 165 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F, 166 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F, 167 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F, 168 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F, 169 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F, 170 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F, 171 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F, 172 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F, 173 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F, 174 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F, 175 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F, 176 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F, 177 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F, 178 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F, 179 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F, 180 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F, 181 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F, 182 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F, 183 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F, 184 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F, ma_tls_start(char * errmsg,size_t errmsg_len)185 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F, 186 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F, 187 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F, 188 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F, 189 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F, 190 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F, 191 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F, 192 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F, 193 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F, 194 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F, 195 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F, 196 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F, 197 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F, 198 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F, 199 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F, 200 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F, 201 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F, 202 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F, 203 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F, 204 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F, 205 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F, 206 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F, 207 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F, 208 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F, 209 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F, 210 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F, 211 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F, 212 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F, 213 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F, 214 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F, 215 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F, 216 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F, 217 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F, 218 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F, 219 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F, 220 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F, 221 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F, 222 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F, 223 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F, 224 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F, 225 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F, 226 0.82788260F, 0.88168307F, 0.9389798F, 1.F, 227 }; 228 229 #endif 230 231 232 static int mapping0_forward(vorbis_block *vb){ 233 vorbis_dsp_state *vd=vb->vd; 234 vorbis_info *vi=vd->vi; 235 codec_setup_info *ci=vi->codec_setup; 236 private_state *b=vb->vd->backend_state; ma_tls_init(MYSQL * mysql)237 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal; 238 int n=vb->pcmend; 239 int i,j,k; 240 241 int *nonzero = alloca(sizeof(*nonzero)*vi->channels); 242 float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct)); 243 int **iwork = _vorbis_block_alloc(vb,vi->channels*sizeof(*iwork)); 244 int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts)); 245 246 float global_ampmax=vbi->ampmax; 247 float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels); 248 int blocktype=vbi->blocktype; 249 250 int modenumber=vb->W; 251 vorbis_info_mapping0 *info=ci->map_param[modenumber]; 252 vorbis_look_psy *psy_look=b->psy+blocktype+(vb->W?2:0); 253 254 vb->mode=modenumber; 255 256 for(i=0;i<vi->channels;i++){ 257 float scale=4.f/n; 258 float scale_dB; 259 260 float *pcm =vb->pcm[i]; 261 float *logfft =pcm; 262 263 iwork[i]=_vorbis_block_alloc(vb,n/2*sizeof(**iwork)); 264 gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct)); 265 266 scale_dB=todB(&scale) + .345; /* + .345 is a hack; the original 267 todB estimation used on IEEE 754 268 compliant machines had a bug that 269 returned dB values about a third 270 of a decibel too high. The bug 271 was harmless because tunings 272 implicitly took that into 273 account. However, fixing the bug 274 in the estimator requires 275 changing all the tunings as well. 276 For now, it's easier to sync 277 things back up here, and 278 recalibrate the tunings in the 279 next major model upgrade. */ 280 281 #if 0 282 if(vi->channels==2){ 283 if(i==0) 284 _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2); 285 else 286 _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2); 287 }else{ 288 _analysis_output("pcm",seq,pcm,n,0,0,total-n/2); 289 } 290 #endif 291 292 /* window the PCM data */ 293 _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW); 294 295 #if 0 296 if(vi->channels==2){ 297 if(i==0) 298 _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2); 299 else 300 _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2); 301 }else{ 302 _analysis_output("windowed",seq,pcm,n,0,0,total-n/2); 303 } 304 #endif 305 306 /* transform the PCM data */ 307 /* only MDCT right now.... */ 308 mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]); 309 310 /* FFT yields more accurate tonal estimation (not phase sensitive) */ 311 drft_forward(&b->fft_look[vb->W],pcm); 312 logfft[0]=scale_dB+todB(pcm) + .345; /* + .345 is a hack; the 313 original todB estimation used on 314 IEEE 754 compliant machines had a 315 bug that returned dB values about 316 a third of a decibel too high. 317 The bug was harmless because 318 tunings implicitly took that into 319 account. However, fixing the bug 320 in the estimator requires 321 changing all the tunings as well. 322 For now, it's easier to sync 323 things back up here, and 324 recalibrate the tunings in the 325 next major model upgrade. */ 326 local_ampmax[i]=logfft[0]; 327 for(j=1;j<n-1;j+=2){ 328 float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1]; 329 temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp) + .345; /* + 330 .345 is a hack; the original todB 331 estimation used on IEEE 754 332 compliant machines had a bug that 333 returned dB values about a third 334 of a decibel too high. The bug 335 was harmless because tunings 336 implicitly took that into 337 account. However, fixing the bug 338 in the estimator requires set_cipher(char * cipher_str,DWORD protocol,ALG_ID * arr,size_t arr_size)339 changing all the tunings as well. 340 For now, it's easier to sync 341 things back up here, and 342 recalibrate the tunings in the 343 next major model upgrade. */ 344 if(temp>local_ampmax[i])local_ampmax[i]=temp; 345 } 346 347 if(local_ampmax[i]>0.f)local_ampmax[i]=0.f; 348 if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i]; 349 350 #if 0 351 if(vi->channels==2){ 352 if(i==0){ 353 _analysis_output("fftL",seq,logfft,n/2,1,0,0); 354 }else{ 355 _analysis_output("fftR",seq,logfft,n/2,1,0,0); 356 } 357 }else{ 358 _analysis_output("fft",seq,logfft,n/2,1,0,0); 359 } 360 #endif 361 362 } ma_tls_connect(MARIADB_TLS * ctls)363 364 { 365 float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise)); 366 float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone)); 367 368 for(i=0;i<vi->channels;i++){ 369 /* the encoder setup assumes that all the modes used by any 370 specific bitrate tweaking use the same floor */ 371 372 int submap=info->chmuxlist[i]; 373 374 /* the following makes things clearer to *me* anyway */ 375 float *mdct =gmdct[i]; 376 float *logfft =vb->pcm[i]; 377 378 float *logmdct =logfft+n/2; 379 float *logmask =logfft; 380 381 vb->mode=modenumber; 382 383 floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts)); 384 memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS); 385 386 for(j=0;j<n/2;j++) 387 logmdct[j]=todB(mdct+j) + .345; /* + .345 is a hack; the original 388 todB estimation used on IEEE 754 389 compliant machines had a bug that 390 returned dB values about a third 391 of a decibel too high. The bug 392 was harmless because tunings 393 implicitly took that into 394 account. However, fixing the bug 395 in the estimator requires 396 changing all the tunings as well. 397 For now, it's easier to sync 398 things back up here, and 399 recalibrate the tunings in the 400 next major model upgrade. */ 401 402 #if 0 403 if(vi->channels==2){ 404 if(i==0) 405 _analysis_output("mdctL",seq,logmdct,n/2,1,0,0); 406 else 407 _analysis_output("mdctR",seq,logmdct,n/2,1,0,0); 408 }else{ 409 _analysis_output("mdct",seq,logmdct,n/2,1,0,0); 410 } 411 #endif 412 413 /* first step; noise masking. Not only does 'noise masking' 414 give us curves from which we can decide how much resolution 415 to give noise parts of the spectrum, it also implicitly hands 416 us a tonality estimate (the larger the value in the 417 'noise_depth' vector, the more tonal that area is) */ 418 419 _vp_noisemask(psy_look, 420 logmdct, 421 noise); /* noise does not have by-frequency offset 422 bias applied yet */ 423 #if 0 424 if(vi->channels==2){ 425 if(i==0) 426 _analysis_output("noiseL",seq,noise,n/2,1,0,0); 427 else 428 _analysis_output("noiseR",seq,noise,n/2,1,0,0); 429 }else{ 430 _analysis_output("noise",seq,noise,n/2,1,0,0); 431 } 432 #endif 433 434 /* second step: 'all the other crap'; all the stuff that isn't 435 computed/fit for bitrate management goes in the second psy 436 vector. This includes tone masking, peak limiting and ATH */ 437 438 _vp_tonemask(psy_look, 439 logfft, 440 tone, 441 global_ampmax, 442 local_ampmax[i]); 443 444 #if 0 445 if(vi->channels==2){ 446 if(i==0) 447 _analysis_output("toneL",seq,tone,n/2,1,0,0); 448 else 449 _analysis_output("toneR",seq,tone,n/2,1,0,0); 450 }else{ 451 _analysis_output("tone",seq,tone,n/2,1,0,0); 452 } 453 #endif 454 455 /* third step; we offset the noise vectors, overlay tone 456 masking. We then do a floor1-specific line fit. If we're 457 performing bitrate management, the line fit is performed 458 multiple times for up/down tweakage on demand. */ 459 460 #if 0 461 { 462 float aotuv[psy_look->n]; 463 #endif 464 465 _vp_offset_and_mix(psy_look, 466 noise, 467 tone, 468 1, 469 logmask, 470 mdct, 471 logmdct); 472 473 #if 0 474 if(vi->channels==2){ 475 if(i==0) 476 _analysis_output("aotuvM1_L",seq,aotuv,psy_look->n,1,1,0); 477 else 478 _analysis_output("aotuvM1_R",seq,aotuv,psy_look->n,1,1,0); 479 }else{ 480 _analysis_output("aotuvM1",seq,aotuv,psy_look->n,1,1,0); 481 } 482 } 483 #endif 484 485 486 #if 0 487 if(vi->channels==2){ 488 if(i==0) 489 _analysis_output("mask1L",seq,logmask,n/2,1,0,0); 490 else 491 _analysis_output("mask1R",seq,logmask,n/2,1,0,0); 492 }else{ 493 _analysis_output("mask1",seq,logmask,n/2,1,0,0); 494 } 495 #endif 496 497 /* this algorithm is hardwired to floor 1 for now; abort out if 498 we're *not* floor1. This won't happen unless someone has 499 broken the encode setup lib. Guard it anyway. */ 500 if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1); 501 502 floor_posts[i][PACKETBLOBS/2]= 503 floor1_fit(vb,b->flr[info->floorsubmap[submap]], 504 logmdct, 505 logmask); 506 507 /* are we managing bitrate? If so, perform two more fits for 508 later rate tweaking (fits represent hi/lo) */ 509 if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){ 510 /* higher rate by way of lower noise curve */ 511 512 _vp_offset_and_mix(psy_look, 513 noise, 514 tone, 515 2, 516 logmask, 517 mdct, 518 logmdct); 519 520 #if 0 521 if(vi->channels==2){ 522 if(i==0) 523 _analysis_output("mask2L",seq,logmask,n/2,1,0,0); 524 else 525 _analysis_output("mask2R",seq,logmask,n/2,1,0,0); 526 }else{ 527 _analysis_output("mask2",seq,logmask,n/2,1,0,0); 528 } 529 #endif 530 531 floor_posts[i][PACKETBLOBS-1]= 532 floor1_fit(vb,b->flr[info->floorsubmap[submap]], 533 logmdct, 534 logmask); 535 536 /* lower rate by way of higher noise curve */ 537 _vp_offset_and_mix(psy_look, 538 noise, 539 tone, 540 0, 541 logmask, 542 mdct, 543 logmdct); 544 545 #if 0 546 if(vi->channels==2){ 547 if(i==0) 548 _analysis_output("mask0L",seq,logmask,n/2,1,0,0); 549 else 550 _analysis_output("mask0R",seq,logmask,n/2,1,0,0); 551 }else{ 552 _analysis_output("mask0",seq,logmask,n/2,1,0,0); 553 } 554 #endif 555 556 floor_posts[i][0]= 557 floor1_fit(vb,b->flr[info->floorsubmap[submap]], 558 logmdct, 559 logmask); 560 561 /* we also interpolate a range of intermediate curves for 562 intermediate rates */ 563 for(k=1;k<PACKETBLOBS/2;k++) 564 floor_posts[i][k]= 565 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]], 566 floor_posts[i][0], 567 floor_posts[i][PACKETBLOBS/2], 568 k*65536/(PACKETBLOBS/2)); 569 for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++) 570 floor_posts[i][k]= 571 floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]], 572 floor_posts[i][PACKETBLOBS/2], 573 floor_posts[i][PACKETBLOBS-1], 574 (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2)); 575 } 576 } 577 } 578 vbi->ampmax=global_ampmax; 579 580 /* 581 the next phases are performed once for vbr-only and PACKETBLOB 582 times for bitrate managed modes. 583 584 1) encode actual mode being used 585 2) encode the floor for each channel, compute coded mask curve/res 586 3) normalize and couple. 587 4) encode residue 588 5) save packet bytes to the packetblob vector 589 590 */ 591 592 /* iterate over the many masking curve fits we've created */ 593 594 { 595 int **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels); 596 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels); 597 598 for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2); 599 k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2); 600 k++){ 601 oggpack_buffer *opb=vbi->packetblob[k]; 602 603 /* start out our new packet blob with packet type and mode */ 604 /* Encode the packet type */ 605 oggpack_write(opb,0,1); 606 /* Encode the modenumber */ 607 /* Encode frame mode, pre,post windowsize, then dispatch */ 608 oggpack_write(opb,modenumber,b->modebits); 609 if(vb->W){ 610 oggpack_write(opb,vb->lW,1); 611 oggpack_write(opb,vb->nW,1); 612 } 613 614 /* encode floor, compute masking curve, sep out residue */ 615 for(i=0;i<vi->channels;i++){ 616 int submap=info->chmuxlist[i]; 617 int *ilogmask=iwork[i]; 618 619 nonzero[i]=floor1_encode(opb,vb,b->flr[info->floorsubmap[submap]], 620 floor_posts[i][k], 621 ilogmask); 622 #if 0 623 { 624 char buf[80]; 625 sprintf(buf,"maskI%c%d",i?'R':'L',k); 626 float work[n/2]; 627 for(j=0;j<n/2;j++) 628 work[j]=FLOOR1_fromdB_LOOKUP[iwork[i][j]]; 629 _analysis_output(buf,seq,work,n/2,1,1,0); 630 } 631 #endif 632 } 633 634 /* our iteration is now based on masking curve, not prequant and 635 coupling. Only one prequant/coupling step */ 636 637 /* quantize/couple */ 638 /* incomplete implementation that assumes the tree is all depth 639 one, or no tree at all */ 640 _vp_couple_quantize_normalize(k, 641 &ci->psy_g_param, 642 psy_look, 643 info, 644 gmdct, 645 iwork, 646 nonzero, 647 ci->psy_g_param.sliding_lowpass[vb->W][k], 648 vi->channels); 649 650 #if 0 651 for(i=0;i<vi->channels;i++){ 652 char buf[80]; 653 sprintf(buf,"res%c%d",i?'R':'L',k); 654 float work[n/2]; 655 for(j=0;j<n/2;j++) 656 work[j]=iwork[i][j]; 657 _analysis_output(buf,seq,work,n/2,1,0,0); 658 } 659 #endif 660 661 /* classify and encode by submap */ 662 for(i=0;i<info->submaps;i++){ 663 int ch_in_bundle=0; 664 long **classifications; 665 int resnum=info->residuesubmap[i]; 666 667 for(j=0;j<vi->channels;j++){ 668 if(info->chmuxlist[j]==i){ 669 zerobundle[ch_in_bundle]=0; 670 if(nonzero[j])zerobundle[ch_in_bundle]=1; 671 couple_bundle[ch_in_bundle++]=iwork[j]; 672 } 673 } 674 675 classifications=_residue_P[ci->residue_type[resnum]]-> 676 class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle); 677 678 ch_in_bundle=0; 679 for(j=0;j<vi->channels;j++) 680 if(info->chmuxlist[j]==i) 681 couple_bundle[ch_in_bundle++]=iwork[j]; 682 683 _residue_P[ci->residue_type[resnum]]-> 684 forward(opb,vb,b->residue[resnum], 685 couple_bundle,zerobundle,ch_in_bundle,classifications,i); 686 } 687 688 /* ok, done encoding. Next protopacket. */ 689 } 690 691 } 692 693 #if 0 694 seq++; 695 total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4; 696 #endif 697 return(0); 698 } 699 700 static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){ 701 vorbis_dsp_state *vd=vb->vd; 702 vorbis_info *vi=vd->vi; 703 codec_setup_info *ci=vi->codec_setup; 704 private_state *b=vd->backend_state; 705 vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l; 706 707 int i,j; 708 long n=vb->pcmend=ci->blocksizes[vb->W]; 709 710 float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels); 711 int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels); 712 713 int *nonzero =alloca(sizeof(*nonzero)*vi->channels); 714 void **floormemo=alloca(sizeof(*floormemo)*vi->channels); 715 716 /* recover the spectral envelope; store it in the PCM vector for now */ 717 for(i=0;i<vi->channels;i++){ 718 int submap=info->chmuxlist[i]; 719 floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]-> 720 inverse1(vb,b->flr[info->floorsubmap[submap]]); 721 if(floormemo[i]) 722 nonzero[i]=1; 723 else 724 nonzero[i]=0; 725 memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2); 726 } 727 728 /* channel coupling can 'dirty' the nonzero listing */ 729 for(i=0;i<info->coupling_steps;i++){ 730 if(nonzero[info->coupling_mag[i]] || 731 nonzero[info->coupling_ang[i]]){ 732 nonzero[info->coupling_mag[i]]=1; 733 nonzero[info->coupling_ang[i]]=1; 734 } 735 } 736 737 /* recover the residue into our working vectors */ 738 for(i=0;i<info->submaps;i++){ 739 int ch_in_bundle=0; 740 for(j=0;j<vi->channels;j++){ 741 if(info->chmuxlist[j]==i){ 742 if(nonzero[j]) 743 zerobundle[ch_in_bundle]=1; 744 else 745 zerobundle[ch_in_bundle]=0; 746 pcmbundle[ch_in_bundle++]=vb->pcm[j]; 747 } 748 } 749 750 _residue_P[ci->residue_type[info->residuesubmap[i]]]-> 751 inverse(vb,b->residue[info->residuesubmap[i]], 752 pcmbundle,zerobundle,ch_in_bundle); 753 } 754 755 /* channel coupling */ 756 for(i=info->coupling_steps-1;i>=0;i--){ 757 float *pcmM=vb->pcm[info->coupling_mag[i]]; 758 float *pcmA=vb->pcm[info->coupling_ang[i]]; 759 760 for(j=0;j<n/2;j++){ 761 float mag=pcmM[j]; 762 float ang=pcmA[j]; 763 764 if(mag>0) 765 if(ang>0){ 766 pcmM[j]=mag; 767 pcmA[j]=mag-ang; 768 }else{ 769 pcmA[j]=mag; 770 pcmM[j]=mag+ang; 771 } 772 else 773 if(ang>0){ 774 pcmM[j]=mag; 775 pcmA[j]=mag+ang; 776 }else{ 777 pcmA[j]=mag; 778 pcmM[j]=mag-ang; 779 } 780 } 781 } 782 783 /* compute and apply spectral envelope */ 784 for(i=0;i<vi->channels;i++){ 785 float *pcm=vb->pcm[i]; 786 int submap=info->chmuxlist[i]; 787 _floor_P[ci->floor_type[info->floorsubmap[submap]]]-> 788 inverse2(vb,b->flr[info->floorsubmap[submap]], 789 floormemo[i],pcm); 790 } 791 792 /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */ 793 /* only MDCT right now.... */ 794 for(i=0;i<vi->channels;i++){ 795 float *pcm=vb->pcm[i]; 796 mdct_backward(b->transform[vb->W][0],pcm,pcm); 797 } 798 799 /* all done! */ 800 return(0); 801 } 802 803 /* export hooks */ 804 const vorbis_func_mapping mapping0_exportbundle={ 805 &mapping0_pack, 806 &mapping0_unpack, 807 &mapping0_free_info, 808 &mapping0_forward, 809 &mapping0_inverse 810 }; 811