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