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