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-2003             *
   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.76 2003/12/30 11:02:22 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   if(v)--v;
  37   while(v){
  38     ret++;
  39     v>>=1;
  40   }
  41   return(ret);
  42 }
  43
  44 /* pcm accumulator examples (not exhaustive):
  45
  46  <-------------- lW ---------------->
  47                    <--------------- W ---------------->
  48 :            .....|.....       _______________         |
  49 :        .'''     |     '''_---      |       |\        |
  50 :.....'''         |_____--- '''......|       | \_______|
  51 :.................|__________________|_______|__|______|
  52                   |<------ Sl ------>|      > Sr <     |endW
  53                   |beginSl           |endSl  |  |endSr
  54                   |beginW            |endlW  |beginSr
  55
  56
  57                       |< lW >|
  58                    <--------------- W ---------------->
  59                   |   |  ..  ______________            |
  60                   |   | '  `/        |     ---_        |
  61                   |___.'___/`.       |         ---_____|
  62                   |_______|__|_______|_________________|
  63                   |      >|Sl|<      |<------ Sr ----->|endW
  64                   |       |  |endSl  |beginSr          |endSr
  65                   |beginW |  |endlW
  66                   mult[0] |beginSl                     mult[n]
  67
  68  <-------------- lW ----------------->
  69                           |<--W-->|
  70 :            ..............  ___  |   |
  71 :        .'''             |`/   \ |   |
  72 :.....'''                 |/`....\|...|
  73 :.........................|___|___|___|
  74                           |Sl |Sr |endW
  75                           |   |   |endSr
  76                           |   |beginSr
  77                           |   |endSl
  78                           |beginSl
  79                           |beginW
  80 */
  81
  82 /* block abstraction setup *********************************************/
  83
  84 #ifndef WORD_ALIGN
  85 #define WORD_ALIGN 8
  86 #endif
  87
  88 int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
  89   int i;
  90   memset(vb,0,sizeof(*vb));
  91   vb->vd=v;
  92   vb->localalloc=0;
  93   vb->localstore=NULL;
  94   if(v->analysisp){
  95     vorbis_block_internal *vbi=
  96       vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
  97     vbi->ampmax=-9999;
  98
  99     for(i=0;i<PACKETBLOBS;i++){
 100       if(i==PACKETBLOBS/2){
 101         vbi->packetblob[i]=&vb->opb;
 102       }else{
 103         vbi->packetblob[i]=
 104           _ogg_calloc(1,sizeof(oggpack_buffer));
 105       }
 106       oggpack_writeinit(vbi->packetblob[i]);
 107     }
 108   }
 109
 110   return(0);
 111 }
 112
 113 void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
 114   bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
 115   if(bytes+vb->localtop>vb->localalloc){
 116     /* can't just _ogg_realloc... there are outstanding pointers */
 117     if(vb->localstore){
 118       struct alloc_chain *link=_ogg_malloc(sizeof(*link));
 119       vb->totaluse+=vb->localtop;
 120       link->next=vb->reap;
 121       link->ptr=vb->localstore;
 122       vb->reap=link;
 123     }
 124     /* highly conservative */
 125     vb->localalloc=bytes;
 126     vb->localstore=_ogg_malloc(vb->localalloc);
 127     vb->localtop=0;
 128   }
 129   {
 130     void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
 131     vb->localtop+=bytes;
 132     return ret;
 133   }
 134 }
 135
 136 /* reap the chain, pull the ripcord */
 137 void _vorbis_block_ripcord(vorbis_block *vb){
 138   /* reap the chain */
 139   struct alloc_chain *reap=vb->reap;
 140   while(reap){
 141     struct alloc_chain *next=reap->next;
 142     _ogg_free(reap->ptr);
 143     memset(reap,0,sizeof(*reap));
 144     _ogg_free(reap);
 145     reap=next;
 146   }
 147   /* consolidate storage */
 148   if(vb->totaluse){
 149     vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
 150     vb->localalloc+=vb->totaluse;
 151     vb->totaluse=0;
 152   }
 153
 154   /* pull the ripcord */
 155   vb->localtop=0;
 156   vb->reap=NULL;
 157 }
 158
 159 int vorbis_block_clear(vorbis_block *vb){
 160   int i;
 161   vorbis_block_internal *vbi=vb->internal;
 162
 163   _vorbis_block_ripcord(vb);
 164   if(vb->localstore)_ogg_free(vb->localstore);
 165
 166   if(vbi){
 167     for(i=0;i<PACKETBLOBS;i++){
 168       oggpack_writeclear(vbi->packetblob[i]);
 169       if(i!=PACKETBLOBS/2)_ogg_free(vbi->packetblob[i]);
 170     }
 171     _ogg_free(vbi);
 172   }
 173   memset(vb,0,sizeof(*vb));
 174   return(0);
 175 }
 176
 177 /* Analysis side code, but directly related to blocking.  Thus it's
 178    here and not in analysis.c (which is for analysis transforms only).
 179    The init is here because some of it is shared */
 180
 181 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
 182   int i;
 183   codec_setup_info *ci=vi->codec_setup;
 184   private_state *b=NULL;
 185   int hs;
 186
 187   if(ci==NULL) return 1;
 188   hs=ci->halfrate_flag;
 189
 190   memset(v,0,sizeof(*v));
 191   b=v->backend_state=_ogg_calloc(1,sizeof(*b));
 192
 193   v->vi=vi;
 194   b->modebits=ilog2(ci->modes);
 195
 196   b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
 197   b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
 198
 199   /* MDCT is tranform 0 */
 200
 201   b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
 202   b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
 203   mdct_init(b->transform[0][0],ci->blocksizes[0]>>hs);
 204   mdct_init(b->transform[1][0],ci->blocksizes[1]>>hs);
 205
 206   /* Vorbis I uses only window type 0 */
 207   b->window[0]=ilog2(ci->blocksizes[0])-6;
 208   b->window[1]=ilog2(ci->blocksizes[1])-6;
 209
 210   if(encp){ /* encode/decode differ here */
 211
 212     /* analysis always needs an fft */
 213     drft_init(&b->fft_look[0],ci->blocksizes[0]);
 214     drft_init(&b->fft_look[1],ci->blocksizes[1]);
 215
 216     /* finish the codebooks */
 217     if(!ci->fullbooks){
 218       ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
 219       for(i=0;i<ci->books;i++)
 220         vorbis_book_init_encode(ci->fullbooks+i,ci->book_param[i]);
 221     }
 222
 223     b->psy=_ogg_calloc(ci->psys,sizeof(*b->psy));
 224     for(i=0;i<ci->psys;i++){
 225       _vp_psy_init(b->psy+i,
 226                    ci->psy_param[i],
 227                    &ci->psy_g_param,
 228                    ci->blocksizes[ci->psy_param[i]->blockflag]/2,
 229                    vi->rate);
 230     }
 231
 232     v->analysisp=1;
 233   }else{
 234     /* finish the codebooks */
 235     if(!ci->fullbooks){
 236       ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
 237       for(i=0;i<ci->books;i++){
 238         vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]);
 239         /* decode codebooks are now standalone after init */
 240         vorbis_staticbook_destroy(ci->book_param[i]);
 241         ci->book_param[i]=NULL;
 242       }
 243     }
 244   }
 245
 246   /* initialize the storage vectors. blocksize[1] is small for encode,
 247      but the correct size for decode */
 248   v->pcm_storage=ci->blocksizes[1];
 249   v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
 250   v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
 251   {
 252     int i;
 253     for(i=0;i<vi->channels;i++)
 254       v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
 255   }
 256
 257   /* all 1 (large block) or 0 (small block) */
 258   /* explicitly set for the sake of clarity */
 259   v->lW=0; /* previous window size */
 260   v->W=0;  /* current window size */
 261
 262   /* all vector indexes */
 263   v->centerW=ci->blocksizes[1]/2;
 264
 265   v->pcm_current=v->centerW;
 266
 267   /* initialize all the backend lookups */
 268   b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
 269   b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
 270
 271   for(i=0;i<ci->floors;i++)
 272     b->flr[i]=_floor_P[ci->floor_type[i]]->
 273       look(v,ci->floor_param[i]);
 274
 275   for(i=0;i<ci->residues;i++)
 276     b->residue[i]=_residue_P[ci->residue_type[i]]->
 277       look(v,ci->residue_param[i]);
 278
 279   return 0;
 280 }
 281
 282 /* arbitrary settings and spec-mandated numbers get filled in here */
 283 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
 284   private_state *b=NULL;
 285
 286   if(_vds_shared_init(v,vi,1))return 1;
 287   b=v->backend_state;
 288   b->psy_g_look=_vp_global_look(vi);
 289
 290   /* Initialize the envelope state storage */
 291   b->ve=_ogg_calloc(1,sizeof(*b->ve));
 292   _ve_envelope_init(b->ve,vi);
 293
 294   vorbis_bitrate_init(vi,&b->bms);
 295
 296   return(0);
 297 }
 298
 299 void vorbis_dsp_clear(vorbis_dsp_state *v){
 300   int i;
 301   if(v){
 302     vorbis_info *vi=v->vi;
 303     codec_setup_info *ci=(vi?vi->codec_setup:NULL);
 304     private_state *b=v->backend_state;
 305
 306     if(b){
 307
 308       if(b->ve){
 309         _ve_envelope_clear(b->ve);
 310         _ogg_free(b->ve);
 311       }
 312
 313       if(b->transform[0]){
 314         mdct_clear(b->transform[0][0]);
 315         _ogg_free(b->transform[0][0]);
 316         _ogg_free(b->transform[0]);
 317       }
 318       if(b->transform[1]){
 319         mdct_clear(b->transform[1][0]);
 320         _ogg_free(b->transform[1][0]);
 321         _ogg_free(b->transform[1]);
 322       }
 323
 324       if(b->flr){
 325         for(i=0;i<ci->floors;i++)
 326           _floor_P[ci->floor_type[i]]->
 327             free_look(b->flr[i]);
 328         _ogg_free(b->flr);
 329       }
 330       if(b->residue){
 331         for(i=0;i<ci->residues;i++)
 332           _residue_P[ci->residue_type[i]]->
 333             free_look(b->residue[i]);
 334         _ogg_free(b->residue);
 335       }
 336       if(b->psy){
 337         for(i=0;i<ci->psys;i++)
 338           _vp_psy_clear(b->psy+i);
 339         _ogg_free(b->psy);
 340       }
 341
 342       if(b->psy_g_look)_vp_global_free(b->psy_g_look);
 343       vorbis_bitrate_clear(&b->bms);
 344
 345       drft_clear(&b->fft_look[0]);
 346       drft_clear(&b->fft_look[1]);
 347
 348     }
 349
 350     if(v->pcm){
 351       for(i=0;i<vi->channels;i++)
 352         if(v->pcm[i])_ogg_free(v->pcm[i]);
 353       _ogg_free(v->pcm);
 354       if(v->pcmret)_ogg_free(v->pcmret);
 355     }
 356
 357     if(b){
 358       /* free header, header1, header2 */
 359       if(b->header)_ogg_free(b->header);
 360       if(b->header1)_ogg_free(b->header1);
 361       if(b->header2)_ogg_free(b->header2);
 362       _ogg_free(b);
 363     }
 364
 365     memset(v,0,sizeof(*v));
 366   }
 367 }
 368
 369 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
 370   int i;
 371   vorbis_info *vi=v->vi;
 372   private_state *b=v->backend_state;
 373
 374   /* free header, header1, header2 */
 375   if(b->header)_ogg_free(b->header);b->header=NULL;
 376   if(b->header1)_ogg_free(b->header1);b->header1=NULL;
 377   if(b->header2)_ogg_free(b->header2);b->header2=NULL;
 378
 379   /* Do we have enough storage space for the requested buffer? If not,
 380      expand the PCM (and envelope) storage */
 381
 382   if(v->pcm_current+vals>=v->pcm_storage){
 383     v->pcm_storage=v->pcm_current+vals*2;
 384
 385     for(i=0;i<vi->channels;i++){
 386       v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
 387     }
 388   }
 389
 390   for(i=0;i<vi->channels;i++)
 391     v->pcmret[i]=v->pcm[i]+v->pcm_current;
 392
 393   return(v->pcmret);
 394 }
 395
 396 static void _preextrapolate_helper(vorbis_dsp_state *v){
 397   int i;
 398   int order=32;
 399   float *lpc=alloca(order*sizeof(*lpc));
 400   float *work=alloca(v->pcm_current*sizeof(*work));
 401   long j;
 402   v->preextrapolate=1;
 403
 404   if(v->pcm_current-v->centerW>order*2){ /* safety */
 405     for(i=0;i<v->vi->channels;i++){
 406       /* need to run the extrapolation in reverse! */
 407       for(j=0;j<v->pcm_current;j++)
 408         work[j]=v->pcm[i][v->pcm_current-j-1];
 409
 410       /* prime as above */
 411       vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
 412
 413       /* run the predictor filter */
 414       vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
 415                          order,
 416                          work+v->pcm_current-v->centerW,
 417                          v->centerW);
 418
 419       for(j=0;j<v->pcm_current;j++)
 420         v->pcm[i][v->pcm_current-j-1]=work[j];
 421
 422     }
 423   }
 424 }
 425
 426
 427 /* call with val<=0 to set eof */
 428
 429 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
 430   vorbis_info *vi=v->vi;
 431   codec_setup_info *ci=vi->codec_setup;
 432
 433   if(vals<=0){
 434     int order=32;
 435     int i;
 436     float *lpc=alloca(order*sizeof(*lpc));
 437
 438     /* if it wasn't done earlier (very short sample) */
 439     if(!v->preextrapolate)
 440       _preextrapolate_helper(v);
 441
 442     /* We're encoding the end of the stream.  Just make sure we have
 443        [at least] a few full blocks of zeroes at the end. */
 444     /* actually, we don't want zeroes; that could drop a large
 445        amplitude off a cliff, creating spread spectrum noise that will
 446        suck to encode.  Extrapolate for the sake of cleanliness. */
 447
 448     vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
 449     v->eofflag=v->pcm_current;
 450     v->pcm_current+=ci->blocksizes[1]*3;
 451
 452     for(i=0;i<vi->channels;i++){
 453       if(v->eofflag>order*2){
 454         /* extrapolate with LPC to fill in */
 455         long n;
 456
 457         /* make a predictor filter */
 458         n=v->eofflag;
 459         if(n>ci->blocksizes[1])n=ci->blocksizes[1];
 460         vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
 461
 462         /* run the predictor filter */
 463         vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
 464                            v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
 465       }else{
 466         /* not enough data to extrapolate (unlikely to happen due to
 467            guarding the overlap, but bulletproof in case that
 468            assumtion goes away). zeroes will do. */
 469         memset(v->pcm[i]+v->eofflag,0,
 470                (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
 471
 472       }
 473     }
 474   }else{
 475
 476     if(v->pcm_current+vals>v->pcm_storage)
 477       return(OV_EINVAL);
 478
 479     v->pcm_current+=vals;
 480
 481     /* we may want to reverse extrapolate the beginning of a stream
 482        too... in case we're beginning on a cliff! */
 483     /* clumsy, but simple.  It only runs once, so simple is good. */
 484     if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
 485       _preextrapolate_helper(v);
 486
 487   }
 488   return(0);
 489 }
 490
 491 /* do the deltas, envelope shaping, pre-echo and determine the size of
 492    the next block on which to continue analysis */
 493 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
 494   int i;
 495   vorbis_info *vi=v->vi;
 496   codec_setup_info *ci=vi->codec_setup;
 497   private_state *b=v->backend_state;
 498   vorbis_look_psy_global *g=b->psy_g_look;
 499   long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
 500   vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
 501
 502   /* check to see if we're started... */
 503   if(!v->preextrapolate)return(0);
 504
 505   /* check to see if we're done... */
 506   if(v->eofflag==-1)return(0);
 507
 508   /* By our invariant, we have lW, W and centerW set.  Search for
 509      the next boundary so we can determine nW (the next window size)
 510      which lets us compute the shape of the current block's window */
 511
 512   /* we do an envelope search even on a single blocksize; we may still
 513      be throwing more bits at impulses, and envelope search handles
 514      marking impulses too. */
 515   {
 516     long bp=_ve_envelope_search(v);
 517     if(bp==-1){
 518
 519       if(v->eofflag==0)return(0); /* not enough data currently to search for a
 520                                      full long block */
 521       v->nW=0;
 522     }else{
 523
 524       if(ci->blocksizes[0]==ci->blocksizes[1])
 525         v->nW=0;
 526       else
 527         v->nW=bp;
 528     }
 529   }
 530
 531   centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
 532
 533   {
 534     /* center of next block + next block maximum right side. */
 535
 536     long blockbound=centerNext+ci->blocksizes[v->nW]/2;
 537     if(v->pcm_current<blockbound)return(0); /* not enough data yet;
 538                                                although this check is
 539                                                less strict that the
 540                                                _ve_envelope_search,
 541                                                the search is not run
 542                                                if we only use one
 543                                                block size */
 544
 545
 546   }
 547
 548   /* fill in the block.  Note that for a short window, lW and nW are *short*
 549      regardless of actual settings in the stream */
 550
 551   _vorbis_block_ripcord(vb);
 552   vb->lW=v->lW;
 553   vb->W=v->W;
 554   vb->nW=v->nW;
 555
 556   if(v->W){
 557     if(!v->lW || !v->nW){
 558       vbi->blocktype=BLOCKTYPE_TRANSITION;
 559       /*fprintf(stderr,"-");*/
 560     }else{
 561       vbi->blocktype=BLOCKTYPE_LONG;
 562       /*fprintf(stderr,"_");*/
 563     }
 564   }else{
 565     if(_ve_envelope_mark(v)){
 566       vbi->blocktype=BLOCKTYPE_IMPULSE;
 567       /*fprintf(stderr,"|");*/
 568
 569     }else{
 570       vbi->blocktype=BLOCKTYPE_PADDING;
 571       /*fprintf(stderr,".");*/
 572
 573     }
 574   }
 575
 576   vb->vd=v;
 577   vb->sequence=v->sequence++;
 578   vb->granulepos=v->granulepos;
 579   vb->pcmend=ci->blocksizes[v->W];
 580
 581   /* copy the vectors; this uses the local storage in vb */
 582
 583   /* this tracks 'strongest peak' for later psychoacoustics */
 584   /* moved to the global psy state; clean this mess up */
 585   if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
 586   g->ampmax=_vp_ampmax_decay(g->ampmax,v);
 587   vbi->ampmax=g->ampmax;
 588
 589   vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
 590   vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
 591   for(i=0;i<vi->channels;i++){
 592     vbi->pcmdelay[i]=
 593       _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
 594     memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
 595     vb->pcm[i]=vbi->pcmdelay[i]+beginW;
 596
 597     /* before we added the delay
 598        vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
 599        memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
 600     */
 601
 602   }
 603
 604   /* handle eof detection: eof==0 means that we've not yet received EOF
 605                            eof>0  marks the last 'real' sample in pcm[]
 606                            eof<0  'no more to do'; doesn't get here */
 607
 608   if(v->eofflag){
 609     if(v->centerW>=v->eofflag){
 610       v->eofflag=-1;
 611       vb->eofflag=1;
 612       return(1);
 613     }
 614   }
 615
 616   /* advance storage vectors and clean up */
 617   {
 618     int new_centerNext=ci->blocksizes[1]/2;
 619     int movementW=centerNext-new_centerNext;
 620
 621     if(movementW>0){
 622
 623       _ve_envelope_shift(b->ve,movementW);
 624       v->pcm_current-=movementW;
 625
 626       for(i=0;i<vi->channels;i++)
 627         memmove(v->pcm[i],v->pcm[i]+movementW,
 628                 v->pcm_current*sizeof(*v->pcm[i]));
 629
 630
 631       v->lW=v->W;
 632       v->W=v->nW;
 633       v->centerW=new_centerNext;
 634
 635       if(v->eofflag){
 636         v->eofflag-=movementW;
 637         if(v->eofflag<=0)v->eofflag=-1;
 638         /* do not add padding to end of stream! */
 639         if(v->centerW>=v->eofflag){
 640           v->granulepos+=movementW-(v->centerW-v->eofflag);
 641         }else{
 642           v->granulepos+=movementW;
 643         }
 644       }else{
 645         v->granulepos+=movementW;
 646       }
 647     }
 648   }
 649
 650   /* done */
 651   return(1);
 652 }
 653
 654 int vorbis_synthesis_restart(vorbis_dsp_state *v){
 655   vorbis_info *vi=v->vi;
 656   codec_setup_info *ci;
 657   int hs;
 658
 659   if(!v->backend_state)return -1;
 660   if(!vi)return -1;
 661   ci=vi->codec_setup;
 662   if(!ci)return -1;
 663   hs=ci->halfrate_flag;
 664
 665   v->centerW=ci->blocksizes[1]>>(hs+1);
 666   v->pcm_current=v->centerW>>hs;
 667
 668   v->pcm_returned=-1;
 669   v->granulepos=-1;
 670   v->sequence=-1;
 671   v->eofflag=0;
 672   ((private_state *)(v->backend_state))->sample_count=-1;
 673
 674   return(0);
 675 }
 676
 677 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
 678   if(_vds_shared_init(v,vi,0)) return 1;
 679   vorbis_synthesis_restart(v);
 680
 681   return 0;
 682 }
 683
 684 /* Unlike in analysis, the window is only partially applied for each
 685    block.  The time domain envelope is not yet handled at the point of
 686    calling (as it relies on the previous block). */
 687
 688 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
 689   vorbis_info *vi=v->vi;
 690   codec_setup_info *ci=vi->codec_setup;
 691   private_state *b=v->backend_state;
 692   int hs=ci->halfrate_flag;
 693   int i,j;
 694
 695   if(!vb)return(OV_EINVAL);
 696   if(v->pcm_current>v->pcm_returned  && v->pcm_returned!=-1)return(OV_EINVAL);
 697
 698   v->lW=v->W;
 699   v->W=vb->W;
 700   v->nW=-1;
 701
 702   if((v->sequence==-1)||
 703      (v->sequence+1 != vb->sequence)){
 704     v->granulepos=-1; /* out of sequence; lose count */
 705     b->sample_count=-1;
 706   }
 707
 708   v->sequence=vb->sequence;
 709
 710   if(vb->pcm){  /* no pcm to process if vorbis_synthesis_trackonly
 711                    was called on block */
 712     int n=ci->blocksizes[v->W]>>(hs+1);
 713     int n0=ci->blocksizes[0]>>(hs+1);
 714     int n1=ci->blocksizes[1]>>(hs+1);
 715
 716     int thisCenter;
 717     int prevCenter;
 718
 719     v->glue_bits+=vb->glue_bits;
 720     v->time_bits+=vb->time_bits;
 721     v->floor_bits+=vb->floor_bits;
 722     v->res_bits+=vb->res_bits;
 723
 724     if(v->centerW){
 725       thisCenter=n1;
 726       prevCenter=0;
 727     }else{
 728       thisCenter=0;
 729       prevCenter=n1;
 730     }
 731
 732     /* v->pcm is now used like a two-stage double buffer.  We don't want
 733        to have to constantly shift *or* adjust memory usage.  Don't
 734        accept a new block until the old is shifted out */
 735
 736     for(j=0;j<vi->channels;j++){
 737       /* the overlap/add section */
 738       if(v->lW){
 739         if(v->W){
 740           /* large/large */
 741           float *w=_vorbis_window_get(b->window[1]-hs);
 742           float *pcm=v->pcm[j]+prevCenter;
 743           float *p=vb->pcm[j];
 744           for(i=0;i<n1;i++)
 745             pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
 746         }else{
 747           /* large/small */
 748           float *w=_vorbis_window_get(b->window[0]-hs);
 749           float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
 750           float *p=vb->pcm[j];
 751           for(i=0;i<n0;i++)
 752             pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
 753         }
 754       }else{
 755         if(v->W){
 756           /* small/large */
 757           float *w=_vorbis_window_get(b->window[0]-hs);
 758           float *pcm=v->pcm[j]+prevCenter;
 759           float *p=vb->pcm[j]+n1/2-n0/2;
 760           for(i=0;i<n0;i++)
 761             pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
 762           for(;i<n1/2+n0/2;i++)
 763             pcm[i]=p[i];
 764         }else{
 765           /* small/small */
 766           float *w=_vorbis_window_get(b->window[0]-hs);
 767           float *pcm=v->pcm[j]+prevCenter;
 768           float *p=vb->pcm[j];
 769           for(i=0;i<n0;i++)
 770             pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
 771         }
 772       }
 773
 774       /* the copy section */
 775       {
 776         float *pcm=v->pcm[j]+thisCenter;
 777         float *p=vb->pcm[j]+n;
 778         for(i=0;i<n;i++)
 779           pcm[i]=p[i];
 780       }
 781     }
 782
 783     if(v->centerW)
 784       v->centerW=0;
 785     else
 786       v->centerW=n1;
 787
 788     /* deal with initial packet state; we do this using the explicit
 789        pcm_returned==-1 flag otherwise we're sensitive to first block
 790        being short or long */
 791
 792     if(v->pcm_returned==-1){
 793       v->pcm_returned=thisCenter;
 794       v->pcm_current=thisCenter;
 795     }else{
 796       v->pcm_returned=prevCenter;
 797       v->pcm_current=prevCenter+
 798         ((ci->blocksizes[v->lW]/4+
 799         ci->blocksizes[v->W]/4)>>hs);
 800     }
 801
 802   }
 803
 804   /* track the frame number... This is for convenience, but also
 805      making sure our last packet doesn't end with added padding.  If
 806      the last packet is partial, the number of samples we'll have to
 807      return will be past the vb->granulepos.
 808
 809      This is not foolproof!  It will be confused if we begin
 810      decoding at the last page after a seek or hole.  In that case,
 811      we don't have a starting point to judge where the last frame
 812      is.  For this reason, vorbisfile will always try to make sure
 813      it reads the last two marked pages in proper sequence */
 814
 815   if(b->sample_count==-1){
 816     b->sample_count=0;
 817   }else{
 818     b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
 819   }
 820
 821   if(v->granulepos==-1){
 822     if(vb->granulepos!=-1){ /* only set if we have a position to set to */
 823
 824       v->granulepos=vb->granulepos;
 825
 826       /* is this a short page? */
 827       if(b->sample_count>v->granulepos){
 828         /* corner case; if this is both the first and last audio page,
 829            then spec says the end is cut, not beginning */
 830         if(vb->eofflag){
 831           /* trim the end */
 832           /* no preceeding granulepos; assume we started at zero (we'd
 833              have to in a short single-page stream) */
 834           /* granulepos could be -1 due to a seek, but that would result
 835              in a long count, not short count */
 836
 837           v->pcm_current-=(b->sample_count-v->granulepos)>>hs;
 838         }else{
 839           /* trim the beginning */
 840           v->pcm_returned+=(b->sample_count-v->granulepos)>>hs;
 841           if(v->pcm_returned>v->pcm_current)
 842             v->pcm_returned=v->pcm_current;
 843         }
 844
 845       }
 846
 847     }
 848   }else{
 849     v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
 850     if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
 851
 852       if(v->granulepos>vb->granulepos){
 853         long extra=v->granulepos-vb->granulepos;
 854
 855         if(extra)
 856           if(vb->eofflag){
 857             /* partial last frame.  Strip the extra samples off */
 858             v->pcm_current-=extra>>hs;
 859           } /* else {Shouldn't happen *unless* the bitstream is out of
 860                spec.  Either way, believe the bitstream } */
 861       } /* else {Shouldn't happen *unless* the bitstream is out of
 862            spec.  Either way, believe the bitstream } */
 863       v->granulepos=vb->granulepos;
 864     }
 865   }
 866
 867   /* Update, cleanup */
 868
 869   if(vb->eofflag)v->eofflag=1;
 870   return(0);
 871
 872 }
 873
 874 /* pcm==NULL indicates we just want the pending samples, no more */
 875 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
 876   vorbis_info *vi=v->vi;
 877
 878   if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
 879     if(pcm){
 880       int i;
 881       for(i=0;i<vi->channels;i++)
 882         v->pcmret[i]=v->pcm[i]+v->pcm_returned;
 883       *pcm=v->pcmret;
 884     }
 885     return(v->pcm_current-v->pcm_returned);
 886   }
 887   return(0);
 888 }
 889
 890 int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
 891   if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
 892   v->pcm_returned+=n;
 893   return(0);
 894 }
 895
 896 /* intended for use with a specific vorbisfile feature; we want access
 897    to the [usually synthetic/postextrapolated] buffer and lapping at
 898    the end of a decode cycle, specifically, a half-short-block worth.
 899    This funtion works like pcmout above, except it will also expose
 900    this implicit buffer data not normally decoded. */
 901 int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
 902   vorbis_info *vi=v->vi;
 903   codec_setup_info *ci=vi->codec_setup;
 904   int hs=ci->halfrate_flag;
 905
 906   int n=ci->blocksizes[v->W]>>(hs+1);
 907   int n0=ci->blocksizes[0]>>(hs+1);
 908   int n1=ci->blocksizes[1]>>(hs+1);
 909   int i,j;
 910
 911   if(v->pcm_returned<0)return 0;
 912
 913   /* our returned data ends at pcm_returned; because the synthesis pcm
 914      buffer is a two-fragment ring, that means our data block may be
 915      fragmented by buffering, wrapping or a short block not filling
 916      out a buffer.  To simplify things, we unfragment if it's at all
 917      possibly needed. Otherwise, we'd need to call lapout more than
 918      once as well as hold additional dsp state.  Opt for
 919      simplicity. */
 920
 921   /* centerW was advanced by blockin; it would be the center of the
 922      *next* block */
 923   if(v->centerW==n1){
 924     /* the data buffer wraps; swap the halves */
 925     /* slow, sure, small */
 926     for(j=0;j<vi->channels;j++){
 927       float *p=v->pcm[j];
 928       for(i=0;i<n1;i++){
 929         float temp=p[i];
 930         p[i]=p[i+n1];
 931         p[i+n1]=temp;
 932       }
 933     }
 934
 935     v->pcm_current-=n1;
 936     v->pcm_returned-=n1;
 937     v->centerW=0;
 938   }
 939
 940   /* solidify buffer into contiguous space */
 941   if((v->lW^v->W)==1){
 942     /* long/short or short/long */
 943     for(j=0;j<vi->channels;j++){
 944       float *s=v->pcm[j];
 945       float *d=v->pcm[j]+(n1-n0)/2;
 946       for(i=(n1+n0)/2-1;i>=0;--i)
 947         d[i]=s[i];
 948     }
 949     v->pcm_returned+=(n1-n0)/2;
 950     v->pcm_current+=(n1-n0)/2;
 951   }else{
 952     if(v->lW==0){
 953       /* short/short */
 954       for(j=0;j<vi->channels;j++){
 955         float *s=v->pcm[j];
 956         float *d=v->pcm[j]+n1-n0;
 957         for(i=n0-1;i>=0;--i)
 958           d[i]=s[i];
 959       }
 960       v->pcm_returned+=n1-n0;
 961       v->pcm_current+=n1-n0;
 962     }
 963   }
 964
 965   if(pcm){
 966     int i;
 967     for(i=0;i<vi->channels;i++)
 968       v->pcmret[i]=v->pcm[i]+v->pcm_returned;
 969     *pcm=v->pcmret;
 970   }
 971
 972   return(n1+n-v->pcm_returned);
 973
 974 }
 975
 976 float *vorbis_window(vorbis_dsp_state *v,int W){
 977   vorbis_info *vi=v->vi;
 978   codec_setup_info *ci=vi->codec_setup;
 979   int hs=ci->halfrate_flag;
 980   private_state *b=v->backend_state;
 981
 982   if(b->window[W]-1<0)return NULL;
 983   return _vorbis_window_get(b->window[W]-hs);
 984 }
 985