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