1 /********************************************************************
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. *
8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
11 ********************************************************************
13 function: PCM data vector blocking, windowing and dis/reassembly
16 Handle windowing, overlap-add, etc of the PCM vectors. This is made
17 more amusing by Vorbis' current two allowed block sizes.
19 ********************************************************************/
25 #include "vorbis/codec.h"
26 #include "codec_internal.h"
34 static int ilog2(unsigned int v){
44 /* pcm accumulator examples (not exhaustive):
46 <-------------- lW ---------------->
47 <--------------- W ---------------->
48 : .....|..... _______________ |
49 : .''' | '''_--- | |\ |
50 :.....''' |_____--- '''......| | \_______|
51 :.................|__________________|_______|__|______|
52 |<------ Sl ------>| > Sr < |endW
53 |beginSl |endSl | |endSr
54 |beginW |endlW |beginSr
58 <--------------- W ---------------->
59 | | .. ______________ |
61 |___.'___/`. | ---_____|
62 |_______|__|_______|_________________|
63 | >|Sl|< |<------ Sr ----->|endW
64 | | |endSl |beginSr |endSr
66 mult[0] |beginSl mult[n]
68 <-------------- lW ----------------->
70 : .............. ___ | |
72 :.....''' |/`....\|...|
73 :.........................|___|___|___|
82 /* block abstraction setup *********************************************/
88 int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
90 memset(vb,0,sizeof(*vb));
95 vorbis_block_internal *vbi=
96 vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
99 for(i=0;i<PACKETBLOBS;i++){
100 if(i==PACKETBLOBS/2){
101 vbi->packetblob[i]=&vb->opb;
104 _ogg_calloc(1,sizeof(oggpack_buffer));
106 oggpack_writeinit(vbi->packetblob[i]);
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 */
118 struct alloc_chain *link=_ogg_malloc(sizeof(*link));
119 vb->totaluse+=vb->localtop;
121 link->ptr=vb->localstore;
124 /* highly conservative */
125 vb->localalloc=bytes;
126 vb->localstore=_ogg_malloc(vb->localalloc);
130 void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
136 /* reap the chain, pull the ripcord */
137 void _vorbis_block_ripcord(vorbis_block *vb){
139 struct alloc_chain *reap=vb->reap;
141 struct alloc_chain *next=reap->next;
142 _ogg_free(reap->ptr);
143 memset(reap,0,sizeof(*reap));
147 /* consolidate storage */
149 vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
150 vb->localalloc+=vb->totaluse;
154 /* pull the ripcord */
159 int vorbis_block_clear(vorbis_block *vb){
161 vorbis_block_internal *vbi=vb->internal;
163 _vorbis_block_ripcord(vb);
164 if(vb->localstore)_ogg_free(vb->localstore);
167 for(i=0;i<PACKETBLOBS;i++){
168 oggpack_writeclear(vbi->packetblob[i]);
169 if(i!=PACKETBLOBS/2)_ogg_free(vbi->packetblob[i]);
173 memset(vb,0,sizeof(*vb));
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 */
181 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
183 codec_setup_info *ci=vi->codec_setup;
184 private_state *b=NULL;
187 if(ci==NULL) return 1;
188 hs=ci->halfrate_flag;
190 memset(v,0,sizeof(*v));
191 b=v->backend_state=_ogg_calloc(1,sizeof(*b));
194 b->modebits=ilog2(ci->modes);
196 b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
197 b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
199 /* MDCT is tranform 0 */
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);
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;
210 if(encp){ /* encode/decode differ here */
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]);
216 /* finish the codebooks */
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]);
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,
228 ci->blocksizes[ci->psy_param[i]->blockflag]/2,
234 /* finish the codebooks */
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)
240 if(vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]))
242 /* decode codebooks are now standalone after init */
243 vorbis_staticbook_destroy(ci->book_param[i]);
244 ci->book_param[i]=NULL;
249 /* initialize the storage vectors. blocksize[1] is small for encode,
250 but the correct size for decode */
251 v->pcm_storage=ci->blocksizes[1];
252 v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
253 v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
256 for(i=0;i<vi->channels;i++)
257 v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
260 /* all 1 (large block) or 0 (small block) */
261 /* explicitly set for the sake of clarity */
262 v->lW=0; /* previous window size */
263 v->W=0; /* current window size */
265 /* all vector indexes */
266 v->centerW=ci->blocksizes[1]/2;
268 v->pcm_current=v->centerW;
270 /* initialize all the backend lookups */
271 b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
272 b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
274 for(i=0;i<ci->floors;i++)
275 b->flr[i]=_floor_P[ci->floor_type[i]]->
276 look(v,ci->floor_param[i]);
278 for(i=0;i<ci->residues;i++)
279 b->residue[i]=_residue_P[ci->residue_type[i]]->
280 look(v,ci->residue_param[i]);
284 for(i=0;i<ci->books;i++){
285 if(ci->book_param[i]!=NULL){
286 vorbis_staticbook_destroy(ci->book_param[i]);
287 ci->book_param[i]=NULL;
294 /* arbitrary settings and spec-mandated numbers get filled in here */
295 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
296 private_state *b=NULL;
298 if(_vds_shared_init(v,vi,1))return 1;
300 b->psy_g_look=_vp_global_look(vi);
302 /* Initialize the envelope state storage */
303 b->ve=_ogg_calloc(1,sizeof(*b->ve));
304 _ve_envelope_init(b->ve,vi);
306 vorbis_bitrate_init(vi,&b->bms);
308 /* compressed audio packets start after the headers
309 with sequence number 3 */
315 void vorbis_dsp_clear(vorbis_dsp_state *v){
318 vorbis_info *vi=v->vi;
319 codec_setup_info *ci=(vi?vi->codec_setup:NULL);
320 private_state *b=v->backend_state;
325 _ve_envelope_clear(b->ve);
330 mdct_clear(b->transform[0][0]);
331 _ogg_free(b->transform[0][0]);
332 _ogg_free(b->transform[0]);
335 mdct_clear(b->transform[1][0]);
336 _ogg_free(b->transform[1][0]);
337 _ogg_free(b->transform[1]);
342 for(i=0;i<ci->floors;i++)
343 _floor_P[ci->floor_type[i]]->
344 free_look(b->flr[i]);
349 for(i=0;i<ci->residues;i++)
350 _residue_P[ci->residue_type[i]]->
351 free_look(b->residue[i]);
352 _ogg_free(b->residue);
356 for(i=0;i<ci->psys;i++)
357 _vp_psy_clear(b->psy+i);
361 if(b->psy_g_look)_vp_global_free(b->psy_g_look);
362 vorbis_bitrate_clear(&b->bms);
364 drft_clear(&b->fft_look[0]);
365 drft_clear(&b->fft_look[1]);
371 for(i=0;i<vi->channels;i++)
372 if(v->pcm[i])_ogg_free(v->pcm[i]);
374 if(v->pcmret)_ogg_free(v->pcmret);
378 /* free header, header1, header2 */
379 if(b->header)_ogg_free(b->header);
380 if(b->header1)_ogg_free(b->header1);
381 if(b->header2)_ogg_free(b->header2);
385 memset(v,0,sizeof(*v));
389 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
391 vorbis_info *vi=v->vi;
392 private_state *b=v->backend_state;
394 /* free header, header1, header2 */
395 if(b->header)_ogg_free(b->header);b->header=NULL;
396 if(b->header1)_ogg_free(b->header1);b->header1=NULL;
397 if(b->header2)_ogg_free(b->header2);b->header2=NULL;
399 /* Do we have enough storage space for the requested buffer? If not,
400 expand the PCM (and envelope) storage */
402 if(v->pcm_current+vals>=v->pcm_storage){
403 v->pcm_storage=v->pcm_current+vals*2;
405 for(i=0;i<vi->channels;i++){
406 v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
410 for(i=0;i<vi->channels;i++)
411 v->pcmret[i]=v->pcm[i]+v->pcm_current;
416 static void _preextrapolate_helper(vorbis_dsp_state *v){
419 float *lpc=alloca(order*sizeof(*lpc));
420 float *work=alloca(v->pcm_current*sizeof(*work));
424 if(v->pcm_current-v->centerW>order*2){ /* safety */
425 for(i=0;i<v->vi->channels;i++){
426 /* need to run the extrapolation in reverse! */
427 for(j=0;j<v->pcm_current;j++)
428 work[j]=v->pcm[i][v->pcm_current-j-1];
431 vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
434 if(v->vi->channels==2){
436 _analysis_output("predataL",0,work,v->pcm_current-v->centerW,0,0,0);
438 _analysis_output("predataR",0,work,v->pcm_current-v->centerW,0,0,0);
440 _analysis_output("predata",0,work,v->pcm_current-v->centerW,0,0,0);
444 /* run the predictor filter */
445 vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
447 work+v->pcm_current-v->centerW,
450 for(j=0;j<v->pcm_current;j++)
451 v->pcm[i][v->pcm_current-j-1]=work[j];
458 /* call with val<=0 to set eof */
460 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
461 vorbis_info *vi=v->vi;
462 codec_setup_info *ci=vi->codec_setup;
467 float *lpc=alloca(order*sizeof(*lpc));
469 /* if it wasn't done earlier (very short sample) */
470 if(!v->preextrapolate)
471 _preextrapolate_helper(v);
473 /* We're encoding the end of the stream. Just make sure we have
474 [at least] a few full blocks of zeroes at the end. */
475 /* actually, we don't want zeroes; that could drop a large
476 amplitude off a cliff, creating spread spectrum noise that will
477 suck to encode. Extrapolate for the sake of cleanliness. */
479 vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
480 v->eofflag=v->pcm_current;
481 v->pcm_current+=ci->blocksizes[1]*3;
483 for(i=0;i<vi->channels;i++){
484 if(v->eofflag>order*2){
485 /* extrapolate with LPC to fill in */
488 /* make a predictor filter */
490 if(n>ci->blocksizes[1])n=ci->blocksizes[1];
491 vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
493 /* run the predictor filter */
494 vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
495 v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
497 /* not enough data to extrapolate (unlikely to happen due to
498 guarding the overlap, but bulletproof in case that
499 assumtion goes away). zeroes will do. */
500 memset(v->pcm[i]+v->eofflag,0,
501 (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
507 if(v->pcm_current+vals>v->pcm_storage)
510 v->pcm_current+=vals;
512 /* we may want to reverse extrapolate the beginning of a stream
513 too... in case we're beginning on a cliff! */
514 /* clumsy, but simple. It only runs once, so simple is good. */
515 if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
516 _preextrapolate_helper(v);
522 /* do the deltas, envelope shaping, pre-echo and determine the size of
523 the next block on which to continue analysis */
524 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
526 vorbis_info *vi=v->vi;
527 codec_setup_info *ci=vi->codec_setup;
528 private_state *b=v->backend_state;
529 vorbis_look_psy_global *g=b->psy_g_look;
530 long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
531 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
533 /* check to see if we're started... */
534 if(!v->preextrapolate)return(0);
536 /* check to see if we're done... */
537 if(v->eofflag==-1)return(0);
539 /* By our invariant, we have lW, W and centerW set. Search for
540 the next boundary so we can determine nW (the next window size)
541 which lets us compute the shape of the current block's window */
543 /* we do an envelope search even on a single blocksize; we may still
544 be throwing more bits at impulses, and envelope search handles
545 marking impulses too. */
547 long bp=_ve_envelope_search(v);
550 if(v->eofflag==0)return(0); /* not enough data currently to search for a
555 if(ci->blocksizes[0]==ci->blocksizes[1])
562 centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
565 /* center of next block + next block maximum right side. */
567 long blockbound=centerNext+ci->blocksizes[v->nW]/2;
568 if(v->pcm_current<blockbound)return(0); /* not enough data yet;
569 although this check is
572 the search is not run
579 /* fill in the block. Note that for a short window, lW and nW are *short*
580 regardless of actual settings in the stream */
582 _vorbis_block_ripcord(vb);
588 if(!v->lW || !v->nW){
589 vbi->blocktype=BLOCKTYPE_TRANSITION;
590 /*fprintf(stderr,"-");*/
592 vbi->blocktype=BLOCKTYPE_LONG;
593 /*fprintf(stderr,"_");*/
596 if(_ve_envelope_mark(v)){
597 vbi->blocktype=BLOCKTYPE_IMPULSE;
598 /*fprintf(stderr,"|");*/
601 vbi->blocktype=BLOCKTYPE_PADDING;
602 /*fprintf(stderr,".");*/
608 vb->sequence=v->sequence++;
609 vb->granulepos=v->granulepos;
610 vb->pcmend=ci->blocksizes[v->W];
612 /* copy the vectors; this uses the local storage in vb */
614 /* this tracks 'strongest peak' for later psychoacoustics */
615 /* moved to the global psy state; clean this mess up */
616 if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
617 g->ampmax=_vp_ampmax_decay(g->ampmax,v);
618 vbi->ampmax=g->ampmax;
620 vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
621 vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
622 for(i=0;i<vi->channels;i++){
624 _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
625 memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
626 vb->pcm[i]=vbi->pcmdelay[i]+beginW;
628 /* before we added the delay
629 vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
630 memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
635 /* handle eof detection: eof==0 means that we've not yet received EOF
636 eof>0 marks the last 'real' sample in pcm[]
637 eof<0 'no more to do'; doesn't get here */
640 if(v->centerW>=v->eofflag){
647 /* advance storage vectors and clean up */
649 int new_centerNext=ci->blocksizes[1]/2;
650 int movementW=centerNext-new_centerNext;
654 _ve_envelope_shift(b->ve,movementW);
655 v->pcm_current-=movementW;
657 for(i=0;i<vi->channels;i++)
658 memmove(v->pcm[i],v->pcm[i]+movementW,
659 v->pcm_current*sizeof(*v->pcm[i]));
664 v->centerW=new_centerNext;
667 v->eofflag-=movementW;
668 if(v->eofflag<=0)v->eofflag=-1;
669 /* do not add padding to end of stream! */
670 if(v->centerW>=v->eofflag){
671 v->granulepos+=movementW-(v->centerW-v->eofflag);
673 v->granulepos+=movementW;
676 v->granulepos+=movementW;
685 int vorbis_synthesis_restart(vorbis_dsp_state *v){
686 vorbis_info *vi=v->vi;
687 codec_setup_info *ci;
690 if(!v->backend_state)return -1;
694 hs=ci->halfrate_flag;
696 v->centerW=ci->blocksizes[1]>>(hs+1);
697 v->pcm_current=v->centerW>>hs;
703 ((private_state *)(v->backend_state))->sample_count=-1;
708 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
709 if(_vds_shared_init(v,vi,0)){
713 vorbis_synthesis_restart(v);
717 /* Unlike in analysis, the window is only partially applied for each
718 block. The time domain envelope is not yet handled at the point of
719 calling (as it relies on the previous block). */
721 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
722 vorbis_info *vi=v->vi;
723 codec_setup_info *ci=vi->codec_setup;
724 private_state *b=v->backend_state;
725 int hs=ci->halfrate_flag;
728 if(!vb)return(OV_EINVAL);
729 if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
735 if((v->sequence==-1)||
736 (v->sequence+1 != vb->sequence)){
737 v->granulepos=-1; /* out of sequence; lose count */
741 v->sequence=vb->sequence;
743 if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
744 was called on block */
745 int n=ci->blocksizes[v->W]>>(hs+1);
746 int n0=ci->blocksizes[0]>>(hs+1);
747 int n1=ci->blocksizes[1]>>(hs+1);
752 v->glue_bits+=vb->glue_bits;
753 v->time_bits+=vb->time_bits;
754 v->floor_bits+=vb->floor_bits;
755 v->res_bits+=vb->res_bits;
765 /* v->pcm is now used like a two-stage double buffer. We don't want
766 to have to constantly shift *or* adjust memory usage. Don't
767 accept a new block until the old is shifted out */
769 for(j=0;j<vi->channels;j++){
770 /* the overlap/add section */
774 float *w=_vorbis_window_get(b->window[1]-hs);
775 float *pcm=v->pcm[j]+prevCenter;
778 pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
781 float *w=_vorbis_window_get(b->window[0]-hs);
782 float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
785 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
790 float *w=_vorbis_window_get(b->window[0]-hs);
791 float *pcm=v->pcm[j]+prevCenter;
792 float *p=vb->pcm[j]+n1/2-n0/2;
794 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
795 for(;i<n1/2+n0/2;i++)
799 float *w=_vorbis_window_get(b->window[0]-hs);
800 float *pcm=v->pcm[j]+prevCenter;
803 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
807 /* the copy section */
809 float *pcm=v->pcm[j]+thisCenter;
810 float *p=vb->pcm[j]+n;
821 /* deal with initial packet state; we do this using the explicit
822 pcm_returned==-1 flag otherwise we're sensitive to first block
823 being short or long */
825 if(v->pcm_returned==-1){
826 v->pcm_returned=thisCenter;
827 v->pcm_current=thisCenter;
829 v->pcm_returned=prevCenter;
830 v->pcm_current=prevCenter+
831 ((ci->blocksizes[v->lW]/4+
832 ci->blocksizes[v->W]/4)>>hs);
837 /* track the frame number... This is for convenience, but also
838 making sure our last packet doesn't end with added padding. If
839 the last packet is partial, the number of samples we'll have to
840 return will be past the vb->granulepos.
842 This is not foolproof! It will be confused if we begin
843 decoding at the last page after a seek or hole. In that case,
844 we don't have a starting point to judge where the last frame
845 is. For this reason, vorbisfile will always try to make sure
846 it reads the last two marked pages in proper sequence */
848 if(b->sample_count==-1){
851 b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
854 if(v->granulepos==-1){
855 if(vb->granulepos!=-1){ /* only set if we have a position to set to */
857 v->granulepos=vb->granulepos;
859 /* is this a short page? */
860 if(b->sample_count>v->granulepos){
861 /* corner case; if this is both the first and last audio page,
862 then spec says the end is cut, not beginning */
865 /* no preceeding granulepos; assume we started at zero (we'd
866 have to in a short single-page stream) */
867 /* granulepos could be -1 due to a seek, but that would result
868 in a long count, not short count */
870 v->pcm_current-=(b->sample_count-v->granulepos)>>hs;
872 /* trim the beginning */
873 v->pcm_returned+=(b->sample_count-v->granulepos)>>hs;
874 if(v->pcm_returned>v->pcm_current)
875 v->pcm_returned=v->pcm_current;
882 v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
883 if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
885 if(v->granulepos>vb->granulepos){
886 long extra=v->granulepos-vb->granulepos;
890 /* partial last frame. Strip the extra samples off */
891 v->pcm_current-=extra>>hs;
892 } /* else {Shouldn't happen *unless* the bitstream is out of
893 spec. Either way, believe the bitstream } */
894 } /* else {Shouldn't happen *unless* the bitstream is out of
895 spec. Either way, believe the bitstream } */
896 v->granulepos=vb->granulepos;
900 /* Update, cleanup */
902 if(vb->eofflag)v->eofflag=1;
907 /* pcm==NULL indicates we just want the pending samples, no more */
908 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
909 vorbis_info *vi=v->vi;
911 if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
914 for(i=0;i<vi->channels;i++)
915 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
918 return(v->pcm_current-v->pcm_returned);
923 int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
924 if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
929 /* intended for use with a specific vorbisfile feature; we want access
930 to the [usually synthetic/postextrapolated] buffer and lapping at
931 the end of a decode cycle, specifically, a half-short-block worth.
932 This funtion works like pcmout above, except it will also expose
933 this implicit buffer data not normally decoded. */
934 int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
935 vorbis_info *vi=v->vi;
936 codec_setup_info *ci=vi->codec_setup;
937 int hs=ci->halfrate_flag;
939 int n=ci->blocksizes[v->W]>>(hs+1);
940 int n0=ci->blocksizes[0]>>(hs+1);
941 int n1=ci->blocksizes[1]>>(hs+1);
944 if(v->pcm_returned<0)return 0;
946 /* our returned data ends at pcm_returned; because the synthesis pcm
947 buffer is a two-fragment ring, that means our data block may be
948 fragmented by buffering, wrapping or a short block not filling
949 out a buffer. To simplify things, we unfragment if it's at all
950 possibly needed. Otherwise, we'd need to call lapout more than
951 once as well as hold additional dsp state. Opt for
954 /* centerW was advanced by blockin; it would be the center of the
957 /* the data buffer wraps; swap the halves */
958 /* slow, sure, small */
959 for(j=0;j<vi->channels;j++){
973 /* solidify buffer into contiguous space */
975 /* long/short or short/long */
976 for(j=0;j<vi->channels;j++){
978 float *d=v->pcm[j]+(n1-n0)/2;
979 for(i=(n1+n0)/2-1;i>=0;--i)
982 v->pcm_returned+=(n1-n0)/2;
983 v->pcm_current+=(n1-n0)/2;
987 for(j=0;j<vi->channels;j++){
989 float *d=v->pcm[j]+n1-n0;
993 v->pcm_returned+=n1-n0;
994 v->pcm_current+=n1-n0;
1000 for(i=0;i<vi->channels;i++)
1001 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
1005 return(n1+n-v->pcm_returned);
1009 float *vorbis_window(vorbis_dsp_state *v,int W){
1010 vorbis_info *vi=v->vi;
1011 codec_setup_info *ci=vi->codec_setup;
1012 int hs=ci->halfrate_flag;
1013 private_state *b=v->backend_state;
1015 if(b->window[W]-1<0)return NULL;
1016 return _vorbis_window_get(b->window[W]-hs);