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