lib/block.c

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