Dependencies/libvorbis/lib/mapping0.c

   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 };