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.63 2002/03/29 07:10:38 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   vb->lW=v->lW;
 506   vb->W=v->W;
 507   vb->nW=v->nW;
 508
 509   if(v->W){
 510     if(!v->lW || !v->nW){
 511       vbi->blocktype=BLOCKTYPE_TRANSITION;
 512       fprintf(stderr,"-");
 513     }else{
 514       vbi->blocktype=BLOCKTYPE_LONG;
 515       fprintf(stderr,"_");
 516     }
 517   }else{
 518     if(_ve_envelope_mark(v)){
 519       vbi->blocktype=BLOCKTYPE_IMPULSE;
 520       fprintf(stderr,"|");
 521
 522     }else{
 523       vbi->blocktype=BLOCKTYPE_PADDING;
 524       fprintf(stderr,".");
 525
 526     }
 527   }
 528
 529   vb->vd=v;
 530   vb->sequence=v->sequence++;
 531   vb->granulepos=v->granulepos;
 532   vb->pcmend=ci->blocksizes[v->W];
 533
 534   /* copy the vectors; this uses the local storage in vb */
 535
 536   /* this tracks 'strongest peak' for later psychoacoustics */
 537   /* moved to the global psy state; clean this mess up */
 538   if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
 539   g->ampmax=_vp_ampmax_decay(g->ampmax,v);
 540   vbi->ampmax=g->ampmax;
 541
 542   vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
 543   vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
 544   for(i=0;i<vi->channels;i++){
 545     vbi->pcmdelay[i]=
 546       _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
 547     memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
 548     vb->pcm[i]=vbi->pcmdelay[i]+beginW;
 549
 550     /* before we added the delay
 551        vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
 552        memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
 553     */
 554
 555   }
 556
 557   /* handle eof detection: eof==0 means that we've not yet received EOF
 558                            eof>0  marks the last 'real' sample in pcm[]
 559                            eof<0  'no more to do'; doesn't get here */
 560
 561   if(v->eofflag){
 562     if(v->centerW>=v->eofflag){
 563       v->eofflag=-1;
 564       vb->eofflag=1;
 565       return(1);
 566     }
 567   }
 568
 569   /* advance storage vectors and clean up */
 570   {
 571     int new_centerNext=ci->blocksizes[1]/2+gi->delaycache;
 572     int movementW=centerNext-new_centerNext;
 573
 574     if(movementW>0){
 575
 576       _ve_envelope_shift(b->ve,movementW);
 577       v->pcm_current-=movementW;
 578
 579       for(i=0;i<vi->channels;i++)
 580         memmove(v->pcm[i],v->pcm[i]+movementW,
 581                 v->pcm_current*sizeof(*v->pcm[i]));
 582
 583
 584       v->lW=v->W;
 585       v->W=v->nW;
 586       v->centerW=new_centerNext;
 587
 588       if(v->eofflag){
 589         v->eofflag-=movementW;
 590         /* do not add padding to end of stream! */
 591         if(v->centerW>=v->eofflag){
 592           v->granulepos+=movementW-(v->centerW-v->eofflag);
 593         }else{
 594           v->granulepos+=movementW;
 595         }
 596       }else{
 597         v->granulepos+=movementW;
 598       }
 599     }
 600   }
 601
 602   /* done */
 603   return(1);
 604 }
 605
 606 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
 607   _vds_shared_init(v,vi,0);
 608
 609   v->pcm_returned=-1;
 610   v->granulepos=-1;
 611   v->sequence=-1;
 612
 613   return(0);
 614 }
 615
 616 /* Unlike in analysis, the window is only partially applied for each
 617    block.  The time domain envelope is not yet handled at the point of
 618    calling (as it relies on the previous block). */
 619
 620 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
 621   vorbis_info *vi=v->vi;
 622   codec_setup_info *ci=vi->codec_setup;
 623   int i,j;
 624
 625   if(!vb)return(OV_EINVAL);
 626   if(v->pcm_current>v->pcm_returned  && v->pcm_returned!=-1)return(OV_EINVAL);
 627
 628   v->lW=v->W;
 629   v->W=vb->W;
 630   v->nW=-1;
 631
 632   if(v->sequence+1 != vb->sequence)v->granulepos=-1; /* out of sequence;
 633                                                         lose count */
 634   v->sequence=vb->sequence;
 635
 636   if(vb->pcm){  /* not pcm to process if vorbis_synthesis_trackonly
 637                    was called on block */
 638     int n=ci->blocksizes[v->W]/2;
 639     int n0=ci->blocksizes[0]/2;
 640     int n1=ci->blocksizes[1]/2;
 641
 642     int thisCenter;
 643     int prevCenter;
 644
 645     v->glue_bits+=vb->glue_bits;
 646     v->time_bits+=vb->time_bits;
 647     v->floor_bits+=vb->floor_bits;
 648     v->res_bits+=vb->res_bits;
 649
 650     if(v->centerW){
 651       thisCenter=n1;
 652       prevCenter=0;
 653     }else{
 654         thisCenter=0;
 655         prevCenter=n1;
 656     }
 657
 658     /* v->pcm is now used like a two-stage double buffer.  We don't want
 659        to have to constantly shift *or* adjust memory usage.  Don't
 660        accept a new block until the old is shifted out */
 661
 662     /* overlap/add PCM */
 663
 664     for(j=0;j<vi->channels;j++){
 665       /* the overlap/add section */
 666       if(v->lW){
 667         if(v->W){
 668           /* large/large */
 669           float *pcm=v->pcm[j]+prevCenter;
 670           float *p=vb->pcm[j];
 671           for(i=0;i<n1;i++)
 672             pcm[i]+=p[i];
 673         }else{
 674           /* large/small */
 675           float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
 676           float *p=vb->pcm[j];
 677           for(i=0;i<n0;i++)
 678             pcm[i]+=p[i];
 679         }
 680       }else{
 681         if(v->W){
 682           /* small/large */
 683           float *pcm=v->pcm[j]+prevCenter;
 684           float *p=vb->pcm[j]+n1/2-n0/2;
 685           for(i=0;i<n0;i++)
 686             pcm[i]+=p[i];
 687           for(;i<n1/2+n0/2;i++)
 688             pcm[i]=p[i];
 689         }else{
 690           /* small/small */
 691           float *pcm=v->pcm[j]+prevCenter;
 692           float *p=vb->pcm[j];
 693           for(i=0;i<n0;i++)
 694             pcm[i]+=p[i];
 695         }
 696       }
 697
 698       /* the copy section */
 699       {
 700         float *pcm=v->pcm[j]+thisCenter;
 701         float *p=vb->pcm[j]+n;
 702         for(i=0;i<n;i++)
 703           pcm[i]=p[i];
 704       }
 705     }
 706
 707     if(v->centerW)
 708       v->centerW=0;
 709     else
 710       v->centerW=n1;
 711
 712     /* deal with initial packet state; we do this using the explicit
 713        pcm_returned==-1 flag otherwise we're sensitive to first block
 714        being short or long */
 715
 716     if(v->pcm_returned==-1){
 717       v->pcm_returned=thisCenter;
 718       v->pcm_current=thisCenter;
 719     }else{
 720       v->pcm_returned=prevCenter;
 721       v->pcm_current=prevCenter+
 722         ci->blocksizes[v->lW]/4+
 723         ci->blocksizes[v->W]/4;
 724     }
 725
 726   }
 727
 728   /* track the frame number... This is for convenience, but also
 729      making sure our last packet doesn't end with added padding.  If
 730      the last packet is partial, the number of samples we'll have to
 731      return will be past the vb->granulepos.
 732
 733      This is not foolproof!  It will be confused if we begin
 734      decoding at the last page after a seek or hole.  In that case,
 735      we don't have a starting point to judge where the last frame
 736      is.  For this reason, vorbisfile will always try to make sure
 737      it reads the last two marked pages in proper sequence */
 738
 739   if(v->granulepos==-1){
 740     if(vb->granulepos!=-1){ /* only set if we have a position to set to */
 741       v->granulepos=vb->granulepos;
 742     }
 743   }else{
 744     v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
 745     if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
 746
 747       if(v->granulepos>vb->granulepos){
 748         long extra=v->granulepos-vb->granulepos;
 749
 750         if(vb->eofflag){
 751           /* partial last frame.  Strip the extra samples off */
 752           v->pcm_current-=extra;
 753         }else if(vb->sequence == 1){
 754           /* ^^^ argh, this can be 1 from seeking! */
 755
 756
 757           /* partial first frame.  Discard extra leading samples */
 758           v->pcm_returned+=extra;
 759           if(v->pcm_returned>v->pcm_current)
 760             v->pcm_returned=v->pcm_current;
 761
 762         } /* else {Shouldn't happen *unless* the bitstream is out of
 763              spec.  Either way, believe the bitstream } */
 764       } /* else {Shouldn't happen *unless* the bitstream is out of
 765            spec.  Either way, believe the bitstream } */
 766       v->granulepos=vb->granulepos;
 767     }
 768   }
 769
 770   /* Update, cleanup */
 771
 772   if(vb->eofflag)v->eofflag=1;
 773   return(0);
 774
 775 }
 776
 777 /* pcm==NULL indicates we just want the pending samples, no more */
 778 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
 779   vorbis_info *vi=v->vi;
 780   if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
 781     if(pcm){
 782       int i;
 783       for(i=0;i<vi->channels;i++)
 784         v->pcmret[i]=v->pcm[i]+v->pcm_returned;
 785       *pcm=v->pcmret;
 786     }
 787     return(v->pcm_current-v->pcm_returned);
 788   }
 789   return(0);
 790 }
 791
 792 int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
 793   if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
 794   v->pcm_returned+=n;
 795   return(0);
 796 }
 797