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 
ilog2(unsigned int v)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 
vorbis_block_init(vorbis_dsp_state * v,vorbis_block * vb)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 
_vorbis_block_alloc(vorbis_block * vb,long bytes)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 */
_vorbis_block_ripcord(vorbis_block * vb)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 
vorbis_block_clear(vorbis_block * vb)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 
_vds_shared_init(vorbis_dsp_state * v,vorbis_info * vi,int encp)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 */
vorbis_analysis_init(vorbis_dsp_state * v,vorbis_info * vi)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 
vorbis_dsp_clear(vorbis_dsp_state * v)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 
vorbis_analysis_buffer(vorbis_dsp_state * v,int vals)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 
_preextrapolate_helper(vorbis_dsp_state * v)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 
vorbis_analysis_wrote(vorbis_dsp_state * v,int vals)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 */
vorbis_analysis_blockout(vorbis_dsp_state * v,vorbis_block * vb)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 
vorbis_synthesis_restart(vorbis_dsp_state * v)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 
vorbis_synthesis_init(vorbis_dsp_state * v,vorbis_info * vi)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 
vorbis_synthesis_blockin(vorbis_dsp_state * v,vorbis_block * vb)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 */
vorbis_synthesis_pcmout(vorbis_dsp_state * v,float *** pcm)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 
vorbis_synthesis_read(vorbis_dsp_state * v,int n)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. */
vorbis_synthesis_lapout(vorbis_dsp_state * v,float *** pcm)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 
vorbis_window(vorbis_dsp_state * v,int W)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 }
1017