lib/block.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE Ogg Vorbis SOFTWARE CODEC SOURCE CODE.  *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
   5  * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
   6  * PLEASE READ THESE TERMS DISTRIBUTING.                            *
   7  *                                                                  *
   8  * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-2000             *
   9  * by Monty <monty@xiph.org> and The XIPHOPHORUS Company            *
  10  * http://www.xiph.org/                                             *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  function: PCM data vector blocking, windowing and dis/reassembly
  15  last mod: $Id: block.c,v 1.30 2000/05/08 20:49:48 xiphmont Exp $
  16
  17  Handle windowing, overlap-add, etc of the PCM vectors.  This is made
  18  more amusing by Vorbis' current two allowed block sizes.
  19
  20  Vorbis manipulates the dynamic range of the incoming PCM data
  21  envelope to minimise time-domain energy leakage from percussive and
  22  plosive waveforms being quantized in the MDCT domain.
  23
  24  ********************************************************************/
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include "vorbis/codec.h"
  30
  31 #include "window.h"
  32 #include "envelope.h"
  33 #include "mdct.h"
  34 #include "lpc.h"
  35 #include "bitwise.h"
  36 #include "registry.h"
  37 #include "sharedbook.h"
  38 #include "bookinternal.h"
  39 #include "misc.h"
  40
  41 static int ilog2(unsigned int v){
  42   int ret=0;
  43   while(v>1){
  44     ret++;
  45     v>>=1;
  46   }
  47   return(ret);
  48 }
  49
  50 /* pcm accumulator examples (not exhaustive):
  51
  52  <-------------- lW ---------------->
  53                    <--------------- W ---------------->
  54 :            .....|.....       _______________         |
  55 :        .'''     |     '''_---      |       |\        |
  56 :.....'''         |_____--- '''......|       | \_______|
  57 :.................|__________________|_______|__|______|
  58                   |<------ Sl ------>|      > Sr <     |endW
  59                   |beginSl           |endSl  |  |endSr
  60                   |beginW            |endlW  |beginSr
  61
  62
  63                       |< lW >|
  64                    <--------------- W ---------------->
  65                   |   |  ..  ______________            |
  66                   |   | '  `/        |     ---_        |
  67                   |___.'___/`.       |         ---_____|
  68                   |_______|__|_______|_________________|
  69                   |      >|Sl|<      |<------ Sr ----->|endW
  70                   |       |  |endSl  |beginSr          |endSr
  71                   |beginW |  |endlW
  72                   mult[0] |beginSl                     mult[n]
  73
  74  <-------------- lW ----------------->
  75                           |<--W-->|
  76 :            ..............  ___  |   |
  77 :        .'''             |`/   \ |   |
  78 :.....'''                 |/`....\|...|
  79 :.........................|___|___|___|
  80                           |Sl |Sr |endW
  81                           |   |   |endSr
  82                           |   |beginSr
  83                           |   |endSl
  84                           |beginSl
  85                           |beginW
  86 */
  87
  88 /* block abstraction setup *********************************************/
  89
  90 #ifndef WORD_ALIGN
  91 #define WORD_ALIGN 8
  92 #endif
  93
  94 int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
  95   memset(vb,0,sizeof(vorbis_block));
  96   vb->vd=v;
  97   vb->localalloc=0;
  98   vb->localstore=NULL;
  99   if(v->analysisp)
 100     _oggpack_writeinit(&vb->opb);
 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 realloc... there are outstanding pointers */
 109     if(vb->localstore){
 110       struct alloc_chain *link=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=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     free(reap->ptr);
 135     memset(reap,0,sizeof(struct alloc_chain));
 136     free(reap);
 137     reap=next;
 138   }
 139   /* consolidate storage */
 140   if(vb->totaluse){
 141     vb->localstore=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)free(vb->localstore);
 157
 158   memset(vb,0,sizeof(vorbis_block));
 159   return(0);
 160 }
 161
 162 /* Analysis side code, but directly related to blocking.  Thus it's
 163    here and not in analysis.c (which is for analysis transforms only).
 164    The init is here because some of it is shared */
 165
 166 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
 167   int i;
 168   memset(v,0,sizeof(vorbis_dsp_state));
 169
 170   v->vi=vi;
 171   v->modebits=ilog2(vi->modes);
 172
 173   v->transform[0]=calloc(VI_TRANSFORMB,sizeof(vorbis_look_transform *));
 174   v->transform[1]=calloc(VI_TRANSFORMB,sizeof(vorbis_look_transform *));
 175
 176   /* MDCT is tranform 0 */
 177
 178   v->transform[0][0]=calloc(1,sizeof(mdct_lookup));
 179   v->transform[1][0]=calloc(1,sizeof(mdct_lookup));
 180   mdct_init(v->transform[0][0],vi->blocksizes[0]);
 181   mdct_init(v->transform[1][0],vi->blocksizes[1]);
 182
 183   v->window[0][0][0]=calloc(VI_WINDOWB,sizeof(double *));
 184   v->window[0][0][1]=v->window[0][0][0];
 185   v->window[0][1][0]=v->window[0][0][0];
 186   v->window[0][1][1]=v->window[0][0][0];
 187   v->window[1][0][0]=calloc(VI_WINDOWB,sizeof(double *));
 188   v->window[1][0][1]=calloc(VI_WINDOWB,sizeof(double *));
 189   v->window[1][1][0]=calloc(VI_WINDOWB,sizeof(double *));
 190   v->window[1][1][1]=calloc(VI_WINDOWB,sizeof(double *));
 191
 192   for(i=0;i<VI_WINDOWB;i++){
 193     v->window[0][0][0][i]=
 194       _vorbis_window(i,vi->blocksizes[0],vi->blocksizes[0]/2,vi->blocksizes[0]/2);
 195     v->window[1][0][0][i]=
 196       _vorbis_window(i,vi->blocksizes[1],vi->blocksizes[0]/2,vi->blocksizes[0]/2);
 197     v->window[1][0][1][i]=
 198       _vorbis_window(i,vi->blocksizes[1],vi->blocksizes[0]/2,vi->blocksizes[1]/2);
 199     v->window[1][1][0][i]=
 200       _vorbis_window(i,vi->blocksizes[1],vi->blocksizes[1]/2,vi->blocksizes[0]/2);
 201     v->window[1][1][1][i]=
 202       _vorbis_window(i,vi->blocksizes[1],vi->blocksizes[1]/2,vi->blocksizes[1]/2);
 203   }
 204
 205   if(encp){ /* encode/decode differ here */
 206     /* finish the codebooks */
 207     v->fullbooks=calloc(vi->books,sizeof(codebook));
 208     for(i=0;i<vi->books;i++)
 209       vorbis_book_init_encode(v->fullbooks+i,vi->book_param[i]);
 210     v->analysisp=1;
 211   }else{
 212     /* finish the codebooks */
 213     v->fullbooks=calloc(vi->books,sizeof(codebook));
 214     for(i=0;i<vi->books;i++)
 215       vorbis_book_init_decode(v->fullbooks+i,vi->book_param[i]);
 216   }
 217
 218   /* initialize the storage vectors to a decent size greater than the
 219      minimum */
 220
 221   v->pcm_storage=8192; /* we'll assume later that we have
 222                           a minimum of twice the blocksize of
 223                           accumulated samples in analysis */
 224   v->pcm=malloc(vi->channels*sizeof(double *));
 225   v->pcmret=malloc(vi->channels*sizeof(double *));
 226   {
 227     int i;
 228     for(i=0;i<vi->channels;i++)
 229       v->pcm[i]=calloc(v->pcm_storage,sizeof(double));
 230   }
 231
 232   /* all 1 (large block) or 0 (small block) */
 233   /* explicitly set for the sake of clarity */
 234   v->lW=0; /* previous window size */
 235   v->W=0;  /* current window size */
 236
 237   /* all vector indexes; multiples of samples_per_envelope_step */
 238   v->centerW=vi->blocksizes[1]/2;
 239
 240   v->pcm_current=v->centerW;
 241
 242   /* initialize all the mapping/backend lookups */
 243   v->mode=calloc(vi->modes,sizeof(vorbis_look_mapping *));
 244   for(i=0;i<vi->modes;i++){
 245     int mapnum=vi->mode_param[i]->mapping;
 246     int maptype=vi->map_type[mapnum];
 247     v->mode[i]=_mapping_P[maptype]->look(v,vi->mode_param[i],
 248                                          vi->map_param[mapnum]);
 249   }
 250
 251   return(0);
 252 }
 253
 254 /* arbitrary settings and spec-mandated numbers get filled in here */
 255 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
 256   _vds_shared_init(v,vi,1);
 257
 258   /* Initialize the envelope multiplier storage */
 259
 260   v->envelope_storage=v->pcm_storage/vi->envelopesa;
 261   v->multipliers=calloc(v->envelope_storage,sizeof(double));
 262   _ve_envelope_init(&v->ve,vi->envelopesa);
 263
 264   v->envelope_current=v->centerW/vi->envelopesa;
 265   return(0);
 266 }
 267
 268 void vorbis_dsp_clear(vorbis_dsp_state *v){
 269   int i,j,k;
 270   if(v){
 271     vorbis_info *vi=v->vi;
 272
 273     if(v->window[0][0][0]){
 274       for(i=0;i<VI_WINDOWB;i++)
 275         if(v->window[0][0][0][i])free(v->window[0][0][0][i]);
 276       free(v->window[0][0][0]);
 277
 278       for(j=0;j<2;j++)
 279         for(k=0;k<2;k++){
 280           for(i=0;i<VI_WINDOWB;i++)
 281             if(v->window[1][j][k][i])free(v->window[1][j][k][i]);
 282           free(v->window[1][j][k]);
 283         }
 284     }
 285
 286     if(v->pcm){
 287       for(i=0;i<vi->channels;i++)
 288         if(v->pcm[i])free(v->pcm[i]);
 289       free(v->pcm);
 290       if(v->pcmret)free(v->pcmret);
 291     }
 292     if(v->multipliers)free(v->multipliers);
 293
 294     _ve_envelope_clear(&v->ve);
 295     if(v->transform[0]){
 296       mdct_clear(v->transform[0][0]);
 297       free(v->transform[0][0]);
 298       free(v->transform[0]);
 299     }
 300     if(v->transform[1]){
 301       mdct_clear(v->transform[1][0]);
 302       free(v->transform[1][0]);
 303       free(v->transform[1]);
 304     }
 305
 306     /* free mode lookups; these are actually vorbis_look_mapping structs */
 307     if(vi){
 308       for(i=0;i<vi->modes;i++){
 309         int mapnum=vi->mode_param[i]->mapping;
 310         int maptype=vi->map_type[mapnum];
 311         _mapping_P[maptype]->free_look(v->mode[i]);
 312       }
 313       /* free codebooks */
 314       for(i=0;i<vi->books;i++)
 315         vorbis_book_clear(v->fullbooks+i);
 316     }
 317
 318     if(v->mode)free(v->mode);
 319     if(v->fullbooks)free(v->fullbooks);
 320
 321     /* free header, header1, header2 */
 322     if(v->header)free(v->header);
 323     if(v->header1)free(v->header1);
 324     if(v->header2)free(v->header2);
 325
 326     memset(v,0,sizeof(vorbis_dsp_state));
 327   }
 328 }
 329
 330 double **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
 331   int i;
 332   vorbis_info *vi=v->vi;
 333
 334   /* free header, header1, header2 */
 335   if(v->header)free(v->header);v->header=NULL;
 336   if(v->header1)free(v->header1);v->header1=NULL;
 337   if(v->header2)free(v->header2);v->header2=NULL;
 338
 339   /* Do we have enough storage space for the requested buffer? If not,
 340      expand the PCM (and envelope) storage */
 341
 342   if(v->pcm_current+vals>=v->pcm_storage){
 343     v->pcm_storage=v->pcm_current+vals*2;
 344     v->envelope_storage=v->pcm_storage/v->vi->envelopesa;
 345
 346     for(i=0;i<vi->channels;i++){
 347       v->pcm[i]=realloc(v->pcm[i],v->pcm_storage*sizeof(double));
 348     }
 349     v->multipliers=realloc(v->multipliers,v->envelope_storage*sizeof(double));
 350   }
 351
 352   for(i=0;i<vi->channels;i++)
 353     v->pcmret[i]=v->pcm[i]+v->pcm_current;
 354
 355   return(v->pcmret);
 356 }
 357
 358 /* call with val<=0 to set eof */
 359
 360 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
 361   vorbis_info *vi=v->vi;
 362   if(vals<=0){
 363     /* We're encoding the end of the stream.  Just make sure we have
 364        [at least] a full block of zeroes at the end. */
 365
 366     int i;
 367     vorbis_analysis_buffer(v,v->vi->blocksizes[1]*2);
 368     v->eofflag=v->pcm_current;
 369     v->pcm_current+=v->vi->blocksizes[1]*2;
 370     for(i=0;i<vi->channels;i++)
 371       memset(v->pcm[i]+v->eofflag,0,
 372              (v->pcm_current-v->eofflag)*sizeof(double));
 373   }else{
 374
 375     if(v->pcm_current+vals>v->pcm_storage)
 376       return(-1);
 377
 378     v->pcm_current+=vals;
 379   }
 380   return(0);
 381 }
 382
 383 /* do the deltas, envelope shaping, pre-echo and determine the size of
 384    the next block on which to continue analysis */
 385 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
 386   int i;
 387   vorbis_info *vi=v->vi;
 388   long beginW=v->centerW-vi->blocksizes[v->W]/2,centerNext;
 389
 390   /* check to see if we're done... */
 391   if(v->eofflag==-1)return(0);
 392
 393   /* if we have any unfilled envelope blocks for which we have PCM
 394      data, fill them up in before proceeding. */
 395
 396   if(v->pcm_current/vi->envelopesa>v->envelope_current){
 397     /* This generates the multipliers, but does not sparsify the vector.
 398        That's done by block before coding */
 399     _ve_envelope_deltas(v);
 400   }
 401
 402   /* By our invariant, we have lW, W and centerW set.  Search for
 403      the next boundary so we can determine nW (the next window size)
 404      which lets us compute the shape of the current block's window */
 405
 406   if(vi->blocksizes[0]<vi->blocksizes[1]){
 407
 408     if(v->W)
 409       /* this is a long window; we start the search forward of centerW
 410          because that's the fastest we could react anyway */
 411       i=v->centerW+vi->blocksizes[1]/4-vi->blocksizes[0]/4;
 412     else
 413       /* short window.  Search from centerW */
 414       i=v->centerW;
 415     i/=vi->envelopesa;
 416
 417     for(;i<v->envelope_current-1;i++){
 418       /* Compare last with current; do we have an abrupt energy change? */
 419
 420       if(v->multipliers[i-1]*vi->preecho_thresh<
 421          v->multipliers[i])break;
 422
 423       /* because the overlapping nature of the delta finding
 424          'smears' the energy cliffs, also compare completely
 425          unoverlapped areas just in case the plosive happened in an
 426          unlucky place */
 427
 428       if(v->multipliers[i-1]*vi->preecho_thresh<
 429          v->multipliers[i+1])break;
 430
 431     }
 432
 433     if(i<v->envelope_current-1){
 434       /* Ooo, we hit a multiplier. Is it beyond the boundary to make the
 435          upcoming block large ? */
 436       long largebound;
 437       if(v->W)
 438         /* min boundary; nW large, next small */
 439         largebound=v->centerW+vi->blocksizes[1]*3/4+vi->blocksizes[0]/4;
 440       else
 441         /* min boundary; nW large, next small */
 442         largebound=v->centerW+vi->blocksizes[0]/2+vi->blocksizes[1]/2;
 443       largebound/=vi->envelopesa;
 444
 445       if(i>=largebound)
 446         v->nW=1;
 447       else
 448         v->nW=0;
 449
 450     }else{
 451       /* Assume maximum; if the block is incomplete given current
 452          buffered data, this will be detected below */
 453       v->nW=1;
 454     }
 455   }else
 456     v->nW=0;
 457
 458   /* Do we actually have enough data *now* for the next block? The
 459      reason to check is that if we had no multipliers, that could
 460      simply been due to running out of data.  In that case, we don't
 461      know the size of the next block for sure and we need that now to
 462      figure out the window shape of this block */
 463
 464   centerNext=v->centerW+vi->blocksizes[v->W]/4+vi->blocksizes[v->nW]/4;
 465
 466   {
 467     /* center of next block + next block maximum right side.  Note
 468        that the next block needs an additional vi->envelopesa samples
 469        to actually be written (for the last multiplier), but we didn't
 470        need that to determine its size */
 471
 472     long blockbound=centerNext+vi->blocksizes[v->nW]/2;
 473     if(v->pcm_current<blockbound)return(0); /* not enough data yet */
 474   }
 475
 476   /* fill in the block.  Note that for a short window, lW and nW are *short*
 477      regardless of actual settings in the stream */
 478
 479   _vorbis_block_ripcord(vb);
 480   if(v->W){
 481     vb->lW=v->lW;
 482     vb->W=v->W;
 483     vb->nW=v->nW;
 484   }else{
 485     vb->lW=0;
 486     vb->W=v->W;
 487     vb->nW=0;
 488   }
 489   vb->vd=v;
 490   vb->sequence=v->sequence;
 491   vb->frameno=v->frameno;
 492   vb->pcmend=vi->blocksizes[v->W];
 493
 494   /* copy the vectors; this uses the local storage in vb */
 495   {
 496     vb->pcm=_vorbis_block_alloc(vb,sizeof(double *)*vi->channels);
 497     for(i=0;i<vi->channels;i++){
 498       vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(double));
 499       memcpy(vb->pcm[i],v->pcm[i]+beginW,vi->blocksizes[v->W]*sizeof(double));
 500     }
 501   }
 502
 503   /* handle eof detection: eof==0 means that we've not yet received EOF
 504                            eof>0  marks the last 'real' sample in pcm[]
 505                            eof<0  'no more to do'; doesn't get here */
 506
 507   if(v->eofflag){
 508     if(v->centerW>=v->eofflag){
 509       v->eofflag=-1;
 510       vb->eofflag=1;
 511     }
 512   }
 513
 514   /* advance storage vectors and clean up */
 515   {
 516     int new_centerNext=vi->blocksizes[1]/2;
 517     int movementW=centerNext-new_centerNext;
 518     int movementM=movementW/vi->envelopesa;
 519
 520     /* the multipliers and pcm stay synced up because the blocksize
 521        must be multiples of samples_per_envelope_step (minimum
 522        multiple is 2) */
 523
 524     v->pcm_current-=movementW;
 525     v->envelope_current-=movementM;
 526
 527     for(i=0;i<vi->channels;i++)
 528       memmove(v->pcm[i],v->pcm[i]+movementW,
 529               v->pcm_current*sizeof(double));
 530
 531     memmove(v->multipliers,v->multipliers+movementM,
 532             v->envelope_current*sizeof(double));
 533
 534     v->lW=v->W;
 535     v->W=v->nW;
 536     v->centerW=new_centerNext;
 537
 538     v->sequence++;
 539     v->frameno+=movementW;
 540
 541     if(v->eofflag)
 542       v->eofflag-=movementW;
 543   }
 544
 545   /* done */
 546   return(1);
 547 }
 548
 549 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
 550   _vds_shared_init(v,vi,0);
 551
 552   /* Adjust centerW to allow an easier mechanism for determining output */
 553   v->pcm_returned=v->centerW;
 554   v->centerW-= vi->blocksizes[v->W]/4+vi->blocksizes[v->lW]/4;
 555   return(0);
 556 }
 557
 558 /* Unike in analysis, the window is only partially applied for each
 559    block.  The time domain envelope is not yet handled at the point of
 560    calling (as it relies on the previous block). */
 561
 562 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
 563   vorbis_info *vi=v->vi;
 564
 565   /* Shift out any PCM/multipliers that we returned previously */
 566   /* centerW is currently the center of the last block added */
 567   if(v->pcm_returned  && v->centerW>vi->blocksizes[1]/2){
 568
 569     /* don't shift too much; we need to have a minimum PCM buffer of
 570        1/2 long block */
 571
 572     int shiftPCM=v->centerW-vi->blocksizes[1]/2;
 573     shiftPCM=(v->pcm_returned<shiftPCM?v->pcm_returned:shiftPCM);
 574
 575     v->pcm_current-=shiftPCM;
 576     v->centerW-=shiftPCM;
 577     v->pcm_returned-=shiftPCM;
 578
 579     if(shiftPCM){
 580       int i;
 581       for(i=0;i<vi->channels;i++)
 582         memmove(v->pcm[i],v->pcm[i]+shiftPCM,
 583                 v->pcm_current*sizeof(double));
 584     }
 585   }
 586
 587   v->lW=v->W;
 588   v->W=vb->W;
 589   v->nW=-1;
 590
 591   v->glue_bits+=vb->glue_bits;
 592   v->time_bits+=vb->time_bits;
 593   v->floor_bits+=vb->floor_bits;
 594   v->res_bits+=vb->res_bits;
 595   v->sequence=vb->sequence;
 596
 597   {
 598     int sizeW=vi->blocksizes[v->W];
 599     int centerW=v->centerW+vi->blocksizes[v->lW]/4+sizeW/4;
 600     int beginW=centerW-sizeW/2;
 601     int endW=beginW+sizeW;
 602     int beginSl;
 603     int endSl;
 604     int i,j;
 605
 606     /* Do we have enough PCM/mult storage for the block? */
 607     if(endW>v->pcm_storage){
 608       /* expand the storage */
 609       v->pcm_storage=endW+vi->blocksizes[1];
 610
 611       for(i=0;i<vi->channels;i++)
 612         v->pcm[i]=realloc(v->pcm[i],v->pcm_storage*sizeof(double));
 613     }
 614
 615     /* overlap/add PCM */
 616
 617     switch(v->W){
 618     case 0:
 619       beginSl=0;
 620       endSl=vi->blocksizes[0]/2;
 621       break;
 622     case 1:
 623       beginSl=vi->blocksizes[1]/4-vi->blocksizes[v->lW]/4;
 624       endSl=beginSl+vi->blocksizes[v->lW]/2;
 625       break;
 626     }
 627
 628     for(j=0;j<vi->channels;j++){
 629       double *pcm=v->pcm[j]+beginW;
 630
 631       /* the overlap/add section */
 632       for(i=beginSl;i<endSl;i++)
 633         pcm[i]+=vb->pcm[j][i];
 634       /* the remaining section */
 635       for(;i<sizeW;i++)
 636         pcm[i]=vb->pcm[j][i];
 637     }
 638
 639     /* Update, cleanup */
 640
 641     v->centerW=centerW;
 642     v->pcm_current=endW;
 643
 644     if(vb->eofflag)v->eofflag=1;
 645   }
 646   return(0);
 647 }
 648
 649 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,double ***pcm){
 650   vorbis_info *vi=v->vi;
 651   if(v->pcm_returned<v->centerW){
 652     int i;
 653     for(i=0;i<vi->channels;i++)
 654       v->pcmret[i]=v->pcm[i]+v->pcm_returned;
 655     *pcm=v->pcmret;
 656     return(v->centerW-v->pcm_returned);
 657   }
 658   return(0);
 659 }
 660
 661 int vorbis_synthesis_read(vorbis_dsp_state *v,int bytes){
 662   if(bytes && v->pcm_returned+bytes>v->centerW)return(-1);
 663   v->pcm_returned+=bytes;
 664   return(0);
 665 }
 666