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