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