lib/block.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-2001             *
   9  * by the XIPHOPHORUS Company http://www.xiph.org/                  *
  10
  11  ********************************************************************
  12
  13  function: PCM data vector blocking, windowing and dis/reassembly
  14  last mod: $Id: block.c,v 1.47 2001/03/26 23:27:42 xiphmont Exp $
  15
  16  Handle windowing, overlap-add, etc of the PCM vectors.  This is made
  17  more amusing by Vorbis' current two allowed block sizes.
  18
  19  ********************************************************************/
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <ogg/ogg.h>
  25 #include "vorbis/codec.h"
  26 #include "codec_internal.h"
  27
  28 #include "window.h"
  29 #include "envelope.h"
  30 #include "mdct.h"
  31 #include "lpc.h"
  32 #include "registry.h"
  33 #include "codebook.h"
  34 #include "misc.h"
  35 #include "os.h"
  36 #include "psy.h"
  37
  38 static int ilog2(unsigned int v){
  39   int ret=0;
  40   while(v>1){
  41     ret++;
  42     v>>=1;
  43   }
  44   return(ret);
  45 }
  46
  47 /* pcm accumulator examples (not exhaustive):
  48
  49  <-------------- lW ---------------->
  50                    <--------------- W ---------------->
  51 :            .....|.....       _______________         |
  52 :        .'''     |     '''_---      |       |\        |
  53 :.....'''         |_____--- '''......|       | \_______|
  54 :.................|__________________|_______|__|______|
  55                   |<------ Sl ------>|      > Sr <     |endW
  56                   |beginSl           |endSl  |  |endSr
  57                   |beginW            |endlW  |beginSr
  58
  59
  60                       |< lW >|
  61                    <--------------- W ---------------->
  62                   |   |  ..  ______________            |
  63                   |   | '  `/        |     ---_        |
  64                   |___.'___/`.       |         ---_____|
  65                   |_______|__|_______|_________________|
  66                   |      >|Sl|<      |<------ Sr ----->|endW
  67                   |       |  |endSl  |beginSr          |endSr
  68                   |beginW |  |endlW
  69                   mult[0] |beginSl                     mult[n]
  70
  71  <-------------- lW ----------------->
  72                           |<--W-->|
  73 :            ..............  ___  |   |
  74 :        .'''             |`/   \ |   |
  75 :.....'''                 |/`....\|...|
  76 :.........................|___|___|___|
  77                           |Sl |Sr |endW
  78                           |   |   |endSr
  79                           |   |beginSr
  80                           |   |endSl
  81                           |beginSl
  82                           |beginW
  83 */
  84
  85 /* block abstraction setup *********************************************/
  86
  87 #ifndef WORD_ALIGN
  88 #define WORD_ALIGN 8
  89 #endif
  90
  91 int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
  92   memset(vb,0,sizeof(vorbis_block));
  93   vb->vd=v;
  94   vb->localalloc=0;
  95   vb->localstore=NULL;
  96   if(v->analysisp){
  97     oggpack_writeinit(&vb->opb);
  98     vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
  99     ((vorbis_block_internal *)vb->internal)->ampmax=-9999;
 100   }
 101
 102   return(0);
 103 }
 104
 105 void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
 106   bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
 107   if(bytes+vb->localtop>vb->localalloc){
 108     /* can't just _ogg_realloc... there are outstanding pointers */
 109     if(vb->localstore){
 110       struct alloc_chain *link=_ogg_malloc(sizeof(struct alloc_chain));
 111       vb->totaluse+=vb->localtop;
 112       link->next=vb->reap;
 113       link->ptr=vb->localstore;
 114       vb->reap=link;
 115     }
 116     /* highly conservative */
 117     vb->localalloc=bytes;
 118     vb->localstore=_ogg_malloc(vb->localalloc);
 119     vb->localtop=0;
 120   }
 121   {
 122     void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
 123     vb->localtop+=bytes;
 124     return ret;
 125   }
 126 }
 127
 128 /* reap the chain, pull the ripcord */
 129 void _vorbis_block_ripcord(vorbis_block *vb){
 130   /* reap the chain */
 131   struct alloc_chain *reap=vb->reap;
 132   while(reap){
 133     struct alloc_chain *next=reap->next;
 134     _ogg_free(reap->ptr);
 135     memset(reap,0,sizeof(struct alloc_chain));
 136     _ogg_free(reap);
 137     reap=next;
 138   }
 139   /* consolidate storage */
 140   if(vb->totaluse){
 141     vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
 142     vb->localalloc+=vb->totaluse;
 143     vb->totaluse=0;
 144   }
 145
 146   /* pull the ripcord */
 147   vb->localtop=0;
 148   vb->reap=NULL;
 149 }
 150
 151 int vorbis_block_clear(vorbis_block *vb){
 152   if(vb->vd)
 153     if(vb->vd->analysisp)
 154       oggpack_writeclear(&vb->opb);
 155   _vorbis_block_ripcord(vb);
 156   if(vb->localstore)_ogg_free(vb->localstore);
 157   if(vb->internal)_ogg_free(vb->internal);
 158
 159   memset(vb,0,sizeof(vorbis_block));
 160   return(0);
 161 }
 162
 163 /* Analysis side code, but directly related to blocking.  Thus it's
 164    here and not in analysis.c (which is for analysis transforms only).
 165    The init is here because some of it is shared */
 166
 167 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
 168   int i;
 169   codec_setup_info *ci=vi->codec_setup;
 170   backend_lookup_state *b=NULL;
 171
 172   memset(v,0,sizeof(vorbis_dsp_state));
 173   b=v->backend_state=_ogg_calloc(1,sizeof(backend_lookup_state));
 174
 175   v->vi=vi;
 176   b->modebits=ilog2(ci->modes);
 177   b->ampmax=-9999;
 178
 179   b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(vorbis_look_transform *));
 180   b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(vorbis_look_transform *));
 181
 182   /* MDCT is tranform 0 */
 183
 184   b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
 185   b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
 186   mdct_init(b->transform[0][0],ci->blocksizes[0]);
 187   mdct_init(b->transform[1][0],ci->blocksizes[1]);
 188
 189   b->window[0][0][0]=_ogg_calloc(VI_WINDOWB,sizeof(float *));
 190   b->window[0][0][1]=b->window[0][0][0];
 191   b->window[0][1][0]=b->window[0][0][0];
 192   b->window[0][1][1]=b->window[0][0][0];
 193   b->window[1][0][0]=_ogg_calloc(VI_WINDOWB,sizeof(float *));
 194   b->window[1][0][1]=_ogg_calloc(VI_WINDOWB,sizeof(float *));
 195   b->window[1][1][0]=_ogg_calloc(VI_WINDOWB,sizeof(float *));
 196   b->window[1][1][1]=_ogg_calloc(VI_WINDOWB,sizeof(float *));
 197
 198   for(i=0;i<VI_WINDOWB;i++){
 199     b->window[0][0][0][i]=
 200       _vorbis_window(i,ci->blocksizes[0],ci->blocksizes[0]/2,ci->blocksizes[0]/2);
 201     b->window[1][0][0][i]=
 202       _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[0]/2,ci->blocksizes[0]/2);
 203     b->window[1][0][1][i]=
 204       _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[0]/2,ci->blocksizes[1]/2);
 205     b->window[1][1][0][i]=
 206       _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[1]/2,ci->blocksizes[0]/2);
 207     b->window[1][1][1][i]=
 208       _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[1]/2,ci->blocksizes[1]/2);
 209   }
 210
 211   if(encp){ /* encode/decode differ here */
 212     /* finish the codebooks */
 213     b->fullbooks=_ogg_calloc(ci->books,sizeof(codebook));
 214     for(i=0;i<ci->books;i++)
 215       vorbis_book_init_encode(b->fullbooks+i,ci->book_param[i]);
 216     v->analysisp=1;
 217   }else{
 218     /* finish the codebooks */
 219     b->fullbooks=_ogg_calloc(ci->books,sizeof(codebook));
 220     for(i=0;i<ci->books;i++)
 221       vorbis_book_init_decode(b->fullbooks+i,ci->book_param[i]);
 222   }
 223
 224   /* initialize the storage vectors to a decent size greater than the
 225      minimum */
 226
 227   v->pcm_storage=8192; /* we'll assume later that we have
 228                           a minimum of twice the blocksize of
 229                           accumulated samples in analysis */
 230   v->pcm=_ogg_malloc(vi->channels*sizeof(float *));
 231   v->pcmret=_ogg_malloc(vi->channels*sizeof(float *));
 232   {
 233     int i;
 234     for(i=0;i<vi->channels;i++)
 235       v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(float));
 236   }
 237
 238   /* all 1 (large block) or 0 (small block) */
 239   /* explicitly set for the sake of clarity */
 240   v->lW=0; /* previous window size */
 241   v->W=0;  /* current window size */
 242
 243   /* all vector indexes */
 244   v->centerW=ci->blocksizes[1]/2;
 245
 246   v->pcm_current=v->centerW;
 247
 248   /* initialize all the mapping/backend lookups */
 249   b->mode=_ogg_calloc(ci->modes,sizeof(vorbis_look_mapping *));
 250   for(i=0;i<ci->modes;i++){
 251     int mapnum=ci->mode_param[i]->mapping;
 252     int maptype=ci->map_type[mapnum];
 253     b->mode[i]=_mapping_P[maptype]->look(v,ci->mode_param[i],
 254                                          ci->map_param[mapnum]);
 255   }
 256
 257   return(0);
 258 }
 259
 260 /* arbitrary settings and spec-mandated numbers get filled in here */
 261 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
 262   backend_lookup_state *b=NULL;
 263
 264   _vds_shared_init(v,vi,1);
 265   b=v->backend_state;
 266
 267   /* Initialize the envelope state storage */
 268   b->ve=_ogg_calloc(1,sizeof(envelope_lookup));
 269   _ve_envelope_init(b->ve,vi);
 270
 271   return(0);
 272 }
 273
 274 void vorbis_dsp_clear(vorbis_dsp_state *v){
 275   int i,j,k;
 276   if(v){
 277     vorbis_info *vi=v->vi;
 278     codec_setup_info *ci=(vi?vi->codec_setup:NULL);
 279     backend_lookup_state *b=v->backend_state;
 280
 281     if(b){
 282       if(b->window[0][0][0]){
 283         for(i=0;i<VI_WINDOWB;i++)
 284           if(b->window[0][0][0][i])_ogg_free(b->window[0][0][0][i]);
 285         _ogg_free(b->window[0][0][0]);
 286
 287         for(j=0;j<2;j++)
 288           for(k=0;k<2;k++){
 289             for(i=0;i<VI_WINDOWB;i++)
 290               if(b->window[1][j][k][i])_ogg_free(b->window[1][j][k][i]);
 291             _ogg_free(b->window[1][j][k]);
 292           }
 293       }
 294
 295       if(b->ve){
 296         _ve_envelope_clear(b->ve);
 297         _ogg_free(b->ve);
 298       }
 299
 300       if(b->transform[0]){
 301         mdct_clear(b->transform[0][0]);
 302         _ogg_free(b->transform[0][0]);
 303         _ogg_free(b->transform[0]);
 304       }
 305       if(b->transform[1]){
 306         mdct_clear(b->transform[1][0]);
 307         _ogg_free(b->transform[1][0]);
 308         _ogg_free(b->transform[1]);
 309       }
 310
 311     }
 312
 313     if(v->pcm){
 314       for(i=0;i<vi->channels;i++)
 315         if(v->pcm[i])_ogg_free(v->pcm[i]);
 316       _ogg_free(v->pcm);
 317       if(v->pcmret)_ogg_free(v->pcmret);
 318     }
 319
 320     /* free mode lookups; these are actually vorbis_look_mapping structs */
 321     if(ci){
 322       for(i=0;i<ci->modes;i++){
 323         int mapnum=ci->mode_param[i]->mapping;
 324         int maptype=ci->map_type[mapnum];
 325         if(b && b->mode)_mapping_P[maptype]->free_look(b->mode[i]);
 326       }
 327       /* free codebooks */
 328       for(i=0;i<ci->books;i++)
 329         if(b && b->fullbooks)vorbis_book_clear(b->fullbooks+i);
 330     }
 331
 332     if(b){
 333       if(b->mode)_ogg_free(b->mode);
 334       if(b->fullbooks)_ogg_free(b->fullbooks);
 335
 336       /* free header, header1, header2 */
 337       if(b->header)_ogg_free(b->header);
 338       if(b->header1)_ogg_free(b->header1);
 339       if(b->header2)_ogg_free(b->header2);
 340       _ogg_free(b);
 341     }
 342
 343     memset(v,0,sizeof(vorbis_dsp_state));
 344   }
 345 }
 346
 347 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
 348   int i;
 349   vorbis_info *vi=v->vi;
 350   backend_lookup_state *b=v->backend_state;
 351
 352   /* free header, header1, header2 */
 353   if(b->header)_ogg_free(b->header);b->header=NULL;
 354   if(b->header1)_ogg_free(b->header1);b->header1=NULL;
 355   if(b->header2)_ogg_free(b->header2);b->header2=NULL;
 356
 357   /* Do we have enough storage space for the requested buffer? If not,
 358      expand the PCM (and envelope) storage */
 359
 360   if(v->pcm_current+vals>=v->pcm_storage){
 361     v->pcm_storage=v->pcm_current+vals*2;
 362
 363     for(i=0;i<vi->channels;i++){
 364       v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(float));
 365     }
 366   }
 367
 368   for(i=0;i<vi->channels;i++)
 369     v->pcmret[i]=v->pcm[i]+v->pcm_current;
 370
 371   return(v->pcmret);
 372 }
 373
 374 static void _preextrapolate_helper(vorbis_dsp_state *v){
 375   int i;
 376   int order=32;
 377   float *lpc=alloca(order*sizeof(float));
 378   float *work=alloca(v->pcm_current*sizeof(float));
 379   long j;
 380   v->preextrapolate=1;
 381
 382   if(v->pcm_current-v->centerW>order*2){ /* safety */
 383     for(i=0;i<v->vi->channels;i++){
 384
 385       /* need to run the extrapolation in reverse! */
 386       for(j=0;j<v->pcm_current;j++)
 387         work[j]=v->pcm[i][v->pcm_current-j-1];
 388
 389       /* prime as above */
 390       vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
 391
 392       /* run the predictor filter */
 393       vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
 394                          order,
 395                          work+v->pcm_current-v->centerW,
 396                          v->centerW);
 397       for(j=0;j<v->pcm_current;j++)
 398         v->pcm[i][v->pcm_current-j-1]=work[j];
 399     }
 400   }
 401 }
 402
 403
 404 /* call with val<=0 to set eof */
 405
 406 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
 407   vorbis_info *vi=v->vi;
 408   codec_setup_info *ci=vi->codec_setup;
 409
 410   if(vals<=0){
 411     int order=32;
 412     int i;
 413     float *lpc=alloca(order*sizeof(float));
 414
 415     /* if it wasn't done earlier (very short sample) */
 416     if(!v->preextrapolate)
 417       _preextrapolate_helper(v);
 418
 419     /* We're encoding the end of the stream.  Just make sure we have
 420        [at least] a full block of zeroes at the end. */
 421     /* actually, we don't want zeroes; that could drop a large
 422        amplitude off a cliff, creating spread spectrum noise that will
 423        suck to encode.  Extrapolate for the sake of cleanliness. */
 424
 425     vorbis_analysis_buffer(v,ci->blocksizes[1]*2);
 426     v->eofflag=v->pcm_current;
 427     v->pcm_current+=ci->blocksizes[1]*2;
 428
 429     for(i=0;i<vi->channels;i++){
 430       if(v->eofflag>order*2){
 431         /* extrapolate with LPC to fill in */
 432         long n;
 433
 434         /* make a predictor filter */
 435         n=v->eofflag;
 436         if(n>ci->blocksizes[1])n=ci->blocksizes[1];
 437         vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
 438
 439         /* run the predictor filter */
 440         vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
 441                            v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
 442       }else{
 443         /* not enough data to extrapolate (unlikely to happen due to
 444            guarding the overlap, but bulletproof in case that
 445            assumtion goes away). zeroes will do. */
 446         memset(v->pcm[i]+v->eofflag,0,
 447                (v->pcm_current-v->eofflag)*sizeof(float));
 448
 449       }
 450     }
 451   }else{
 452
 453     if(v->pcm_current+vals>v->pcm_storage)
 454       return(OV_EINVAL);
 455
 456     v->pcm_current+=vals;
 457
 458     /* we may want to reverse extrapolate the beginning of a stream
 459        too... in case we're beginning on a cliff! */
 460     /* clumsy, but simple.  It only runs once, so simple is good. */
 461     if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
 462       _preextrapolate_helper(v);
 463
 464   }
 465   return(0);
 466 }
 467
 468 /* do the deltas, envelope shaping, pre-echo and determine the size of
 469    the next block on which to continue analysis */
 470 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
 471   int i;
 472   vorbis_info *vi=v->vi;
 473   codec_setup_info *ci=vi->codec_setup;
 474   backend_lookup_state *b=v->backend_state;
 475   long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
 476
 477   /* check to see if we're started... */
 478   if(!v->preextrapolate)return(0);
 479
 480   /* check to see if we're done... */
 481   if(v->eofflag==-1)return(0);
 482
 483   /* By our invariant, we have lW, W and centerW set.  Search for
 484      the next boundary so we can determine nW (the next window size)
 485      which lets us compute the shape of the current block's window */
 486
 487   if(ci->blocksizes[0]<ci->blocksizes[1]){
 488     long largebound;
 489     long bp;
 490
 491     if(v->W)
 492       /* min boundary; nW large, next small */
 493       largebound=v->centerW+ci->blocksizes[1]*3/4+ci->blocksizes[0]/4;
 494     else
 495       /* min boundary; nW large, next small */
 496       largebound=v->centerW+ci->blocksizes[1]/2+ci->blocksizes[0]/2;
 497
 498     bp=_ve_envelope_search(v,largebound);
 499     if(bp==-1)return(0); /* not enough data currently to search for a
 500                             full long block */
 501     v->nW=bp;
 502
 503   }else
 504     v->nW=0;
 505
 506   centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
 507
 508   {
 509     /* center of next block + next block maximum right side. */
 510
 511     long blockbound=centerNext+ci->blocksizes[v->nW]/2;
 512     if(v->pcm_current<blockbound)return(0); /* not enough data yet;
 513                                                although this check is
 514                                                less strict that the
 515                                                _ve_envelope_search,
 516                                                the search is not run
 517                                                if we only use one
 518                                                block size */
 519   }
 520
 521   /* fill in the block.  Note that for a short window, lW and nW are *short*
 522      regardless of actual settings in the stream */
 523
 524   _vorbis_block_ripcord(vb);
 525   if(v->W){
 526     vb->lW=v->lW;
 527     vb->W=v->W;
 528     vb->nW=v->nW;
 529   }else{
 530     vb->lW=0;
 531     vb->W=v->W;
 532     vb->nW=0;
 533   }
 534   vb->vd=v;
 535   vb->sequence=v->sequence;
 536   vb->granulepos=v->granulepos;
 537   vb->pcmend=ci->blocksizes[v->W];
 538
 539
 540   /* copy the vectors; this uses the local storage in vb */
 541   {
 542     vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
 543
 544     /* this tracks 'strongest peak' for later psychoacoustics */
 545     if(vbi->ampmax>b->ampmax)b->ampmax=vbi->ampmax;
 546     b->ampmax=_vp_ampmax_decay(b->ampmax,v);
 547     vbi->ampmax=b->ampmax;
 548
 549     vb->pcm=_vorbis_block_alloc(vb,sizeof(float *)*vi->channels);
 550     vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(float *)*vi->channels);
 551     for(i=0;i<vi->channels;i++){
 552       vbi->pcmdelay[i]=
 553         _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(float));
 554       memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(float));
 555       vb->pcm[i]=vbi->pcmdelay[i]+beginW;
 556
 557       /* before we added the delay
 558       vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(float));
 559       memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(float));
 560       */
 561
 562     }
 563   }
 564
 565   /* handle eof detection: eof==0 means that we've not yet received EOF
 566                            eof>0  marks the last 'real' sample in pcm[]
 567                            eof<0  'no more to do'; doesn't get here */
 568
 569   if(v->eofflag){
 570     if(v->centerW>=v->eofflag){
 571       v->eofflag=-1;
 572       vb->eofflag=1;
 573       return(1);
 574     }
 575   }
 576
 577   /* advance storage vectors and clean up */
 578   {
 579     int new_centerNext=ci->blocksizes[1]/2+ci->delaycache;
 580     int movementW=centerNext-new_centerNext;
 581
 582     if(movementW>0){
 583
 584       _ve_envelope_shift(b->ve,movementW);
 585       v->pcm_current-=movementW;
 586
 587       for(i=0;i<vi->channels;i++)
 588         memmove(v->pcm[i],v->pcm[i]+movementW,
 589                 v->pcm_current*sizeof(float));
 590
 591
 592       v->lW=v->W;
 593       v->W=v->nW;
 594       v->centerW=new_centerNext;
 595
 596       v->sequence++;
 597
 598       if(v->eofflag){
 599         v->eofflag-=movementW;
 600         /* do not add padding to end of stream! */
 601         if(v->centerW>=v->eofflag){
 602           v->granulepos+=movementW-(v->centerW-v->eofflag);
 603         }else{
 604           v->granulepos+=movementW;
 605         }
 606       }else{
 607         v->granulepos+=movementW;
 608       }
 609     }
 610   }
 611
 612   /* done */
 613   return(1);
 614 }
 615
 616 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
 617   codec_setup_info *ci=vi->codec_setup;
 618   _vds_shared_init(v,vi,0);
 619
 620   v->pcm_returned=-1;
 621   v->granulepos=-1;
 622   v->sequence=-1;
 623
 624   return(0);
 625 }
 626
 627 /* Unlike in analysis, the window is only partially applied for each
 628    block.  The time domain envelope is not yet handled at the point of
 629    calling (as it relies on the previous block). */
 630
 631 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
 632   vorbis_info *vi=v->vi;
 633   codec_setup_info *ci=vi->codec_setup;
 634
 635   /* Shift out any PCM that we returned previously */
 636   /* centerW is currently the center of the last block added */
 637
 638   if(v->centerW>ci->blocksizes[1]/2 &&
 639   /* Quick additional hack; to avoid *alot* of shifts, use an
 640      oversized buffer.  This increases memory usage, but doesn't make
 641      much difference wrt L1/L2 cache pressure. */
 642      v->pcm_returned>8192){
 643
 644     /* don't shift too much; we need to have a minimum PCM buffer of
 645        1/2 long block */
 646
 647     int shiftPCM=v->centerW-ci->blocksizes[1]/2;
 648     shiftPCM=(v->pcm_returned<shiftPCM?v->pcm_returned:shiftPCM);
 649
 650     v->pcm_current-=shiftPCM;
 651     v->centerW-=shiftPCM;
 652     v->pcm_returned-=shiftPCM;
 653
 654     if(shiftPCM){
 655       int i;
 656       for(i=0;i<vi->channels;i++)
 657         memmove(v->pcm[i],v->pcm[i]+shiftPCM,
 658                 v->pcm_current*sizeof(float));
 659     }
 660   }
 661
 662   v->lW=v->W;
 663   v->W=vb->W;
 664   v->nW=-1;
 665
 666   v->glue_bits+=vb->glue_bits;
 667   v->time_bits+=vb->time_bits;
 668   v->floor_bits+=vb->floor_bits;
 669   v->res_bits+=vb->res_bits;
 670
 671   if(v->sequence+1 != vb->sequence)v->granulepos=-1; /* out of sequence;
 672                                                      lose count */
 673
 674   v->sequence=vb->sequence;
 675
 676   {
 677     int sizeW=ci->blocksizes[v->W];
 678     int centerW=v->centerW+ci->blocksizes[v->lW]/4+sizeW/4;
 679     int beginW=centerW-sizeW/2;
 680     int endW=beginW+sizeW;
 681     int beginSl;
 682     int endSl;
 683     int i,j;
 684
 685     /* Do we have enough PCM/mult storage for the block? */
 686     if(endW>v->pcm_storage){
 687       /* expand the storage */
 688       v->pcm_storage=endW+ci->blocksizes[1];
 689
 690       for(i=0;i<vi->channels;i++)
 691         v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(float));
 692     }
 693
 694     /* overlap/add PCM */
 695
 696     switch(v->W){
 697     case 0:
 698       beginSl=0;
 699       endSl=ci->blocksizes[0]/2;
 700       break;
 701     case 1:
 702       beginSl=ci->blocksizes[1]/4-ci->blocksizes[v->lW]/4;
 703       endSl=beginSl+ci->blocksizes[v->lW]/2;
 704       break;
 705     default:
 706       return(-1);
 707     }
 708
 709     for(j=0;j<vi->channels;j++){
 710       static int seq=0;
 711       float *pcm=v->pcm[j]+beginW;
 712       float *p=vb->pcm[j];
 713
 714       /* the overlap/add section */
 715       for(i=beginSl;i<endSl;i++)
 716         pcm[i]+=p[i];
 717       /* the remaining section */
 718       for(;i<sizeW;i++)
 719         pcm[i]=p[i];
 720
 721       _analysis_output("lapped",seq,pcm,sizeW,0,0);
 722       _analysis_output("buffered",seq++,v->pcm[j],sizeW+beginW,0,0);
 723
 724     }
 725
 726     /* deal with initial packet state; we do this using the explicit
 727        pcm_returned==-1 flag otherwise we're sensitive to first block
 728        being short or long */
 729
 730     if(v->pcm_returned==-1)
 731       v->pcm_returned=centerW;
 732
 733     /* track the frame number... This is for convenience, but also
 734        making sure our last packet doesn't end with added padding.  If
 735        the last packet is partial, the number of samples we'll have to
 736        return will be past the vb->granulepos.
 737
 738        This is not foolproof!  It will be confused if we begin
 739        decoding at the last page after a seek or hole.  In that case,
 740        we don't have a starting point to judge where the last frame
 741        is.  For this reason, vorbisfile will always try to make sure
 742        it reads the last two marked pages in proper sequence */
 743
 744     if(v->granulepos==-1)
 745       if(vb->granulepos==-1){
 746         v->granulepos=0;
 747       }else{
 748         v->granulepos=vb->granulepos;
 749       }
 750     else{
 751       v->granulepos+=(centerW-v->centerW);
 752       if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
 753
 754         if(v->granulepos>vb->granulepos){
 755           long extra=v->granulepos-vb->granulepos;
 756
 757           if(vb->eofflag){
 758             /* partial last frame.  Strip the extra samples off */
 759             centerW-=extra;
 760           }else if(vb->sequence == 1){
 761             /* ^^^ argh, this can be 1 from seeking! */
 762
 763
 764             /* partial first frame.  Discard extra leading samples */
 765             v->pcm_returned+=extra;
 766             if(v->pcm_returned>centerW)v->pcm_returned=centerW;
 767
 768           }
 769
 770         }/* else{ Shouldn't happen *unless* the bitstream is out of
 771             spec.  Either way, believe the bitstream } */
 772         v->granulepos=vb->granulepos;
 773       }
 774     }
 775
 776     /* Update, cleanup */
 777
 778     v->centerW=centerW;
 779     v->pcm_current=endW;
 780
 781     if(vb->eofflag)v->eofflag=1;
 782   }
 783
 784   return(0);
 785 }
 786
 787 /* pcm==NULL indicates we just want the pending samples, no more */
 788 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
 789   vorbis_info *vi=v->vi;
 790   if(v->pcm_returned<v->centerW){
 791     if(pcm){
 792       int i;
 793       for(i=0;i<vi->channels;i++)
 794         v->pcmret[i]=v->pcm[i]+v->pcm_returned;
 795       *pcm=v->pcmret;
 796     }
 797     return(v->centerW-v->pcm_returned);
 798   }
 799   return(0);
 800 }
 801
 802 int vorbis_synthesis_read(vorbis_dsp_state *v,int bytes){
 803   if(bytes && v->pcm_returned+bytes>v->centerW)return(OV_EINVAL);
 804   v->pcm_returned+=bytes;
 805   return(0);
 806 }
 807