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-2002 *
9 * by the XIPHOPHORUS Company http://www.xiph.org/ *
11 ********************************************************************
13 function: PCM data vector blocking, windowing and dis/reassembly
14 last mod: $Id: block.c,v 1.72 2003/03/06 22:05:26 xiphmont Exp $
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){
89 memset(vb,0,sizeof(*vb));
94 vorbis_block_internal *vbi=
95 vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
96 oggpack_writeinit(&vb->opb);
103 void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
104 bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
105 if(bytes+vb->localtop>vb->localalloc){
106 /* can't just _ogg_realloc... there are outstanding pointers */
108 struct alloc_chain *link=_ogg_malloc(sizeof(*link));
109 vb->totaluse+=vb->localtop;
111 link->ptr=vb->localstore;
114 /* highly conservative */
115 vb->localalloc=bytes;
116 vb->localstore=_ogg_malloc(vb->localalloc);
120 void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
126 /* reap the chain, pull the ripcord */
127 void _vorbis_block_ripcord(vorbis_block *vb){
129 struct alloc_chain *reap=vb->reap;
131 struct alloc_chain *next=reap->next;
132 _ogg_free(reap->ptr);
133 memset(reap,0,sizeof(*reap));
137 /* consolidate storage */
139 vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
140 vb->localalloc+=vb->totaluse;
144 /* pull the ripcord */
149 int vorbis_block_clear(vorbis_block *vb){
151 if(vb->vd->analysisp)
152 oggpack_writeclear(&vb->opb);
153 _vorbis_block_ripcord(vb);
154 if(vb->localstore)_ogg_free(vb->localstore);
157 _ogg_free(vb->internal);
159 memset(vb,0,sizeof(*vb));
163 /* Analysis side code, but directly related to blocking. Thus it's
164 here and not in analysis.c (which is for analysis transforms only).
165 The init is here because some of it is shared */
167 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
169 codec_setup_info *ci=vi->codec_setup;
170 private_state *b=NULL;
172 memset(v,0,sizeof(*v));
173 b=v->backend_state=_ogg_calloc(1,sizeof(*b));
176 b->modebits=ilog2(ci->modes);
178 b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
179 b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
181 /* MDCT is tranform 0 */
183 b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
184 b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
185 mdct_init(b->transform[0][0],ci->blocksizes[0]);
186 mdct_init(b->transform[1][0],ci->blocksizes[1]);
188 /* Vorbis I uses only window type 0 */
189 b->window[0]=_vorbis_window_get(0,ci->blocksizes[0]/2);
190 b->window[1]=_vorbis_window_get(0,ci->blocksizes[1]/2);
192 if(encp){ /* encode/decode differ here */
194 /* analysis always needs an fft */
195 drft_init(&b->fft_look[0],ci->blocksizes[0]);
196 drft_init(&b->fft_look[1],ci->blocksizes[1]);
198 /* finish the codebooks */
200 ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
201 for(i=0;i<ci->books;i++)
202 vorbis_book_init_encode(ci->fullbooks+i,ci->book_param[i]);
205 b->psy=_ogg_calloc(ci->psys,sizeof(*b->psy));
206 for(i=0;i<ci->psys;i++){
207 _vp_psy_init(b->psy+i,
210 ci->blocksizes[ci->psy_param[i]->blockflag]/2,
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_decode(ci->fullbooks+i,ci->book_param[i]);
221 /* decode codebooks are now standalone after init */
222 vorbis_staticbook_destroy(ci->book_param[i]);
223 ci->book_param[i]=NULL;
228 /* initialize the storage vectors. blocksize[1] is small for encode,
229 but the correct size for decode */
230 v->pcm_storage=ci->blocksizes[1];
231 v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
232 v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
235 for(i=0;i<vi->channels;i++)
236 v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
239 /* all 1 (large block) or 0 (small block) */
240 /* explicitly set for the sake of clarity */
241 v->lW=0; /* previous window size */
242 v->W=0; /* current window size */
244 /* all vector indexes */
245 v->centerW=ci->blocksizes[1]/2;
247 v->pcm_current=v->centerW;
249 /* initialize all the backend lookups */
250 b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
251 b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
253 for(i=0;i<ci->floors;i++)
254 b->flr[i]=_floor_P[ci->floor_type[i]]->
255 look(v,ci->floor_param[i]);
257 for(i=0;i<ci->residues;i++)
258 b->residue[i]=_residue_P[ci->residue_type[i]]->
259 look(v,ci->residue_param[i]);
264 /* arbitrary settings and spec-mandated numbers get filled in here */
265 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
266 private_state *b=NULL;
268 _vds_shared_init(v,vi,1);
270 b->psy_g_look=_vp_global_look(vi);
272 /* Initialize the envelope state storage */
273 b->ve=_ogg_calloc(1,sizeof(*b->ve));
274 _ve_envelope_init(b->ve,vi);
276 vorbis_bitrate_init(vi,&b->bms);
281 void vorbis_dsp_clear(vorbis_dsp_state *v){
284 vorbis_info *vi=v->vi;
285 codec_setup_info *ci=(vi?vi->codec_setup:NULL);
286 private_state *b=v->backend_state;
291 _ve_envelope_clear(b->ve);
296 mdct_clear(b->transform[0][0]);
297 _ogg_free(b->transform[0][0]);
298 _ogg_free(b->transform[0]);
301 mdct_clear(b->transform[1][0]);
302 _ogg_free(b->transform[1][0]);
303 _ogg_free(b->transform[1]);
307 for(i=0;i<ci->floors;i++)
308 _floor_P[ci->floor_type[i]]->
309 free_look(b->flr[i]);
313 for(i=0;i<ci->residues;i++)
314 _residue_P[ci->residue_type[i]]->
315 free_look(b->residue[i]);
316 _ogg_free(b->residue);
319 for(i=0;i<ci->psys;i++)
320 _vp_psy_clear(b->psy+i);
324 if(b->psy_g_look)_vp_global_free(b->psy_g_look);
325 vorbis_bitrate_clear(&b->bms);
327 drft_clear(&b->fft_look[0]);
328 drft_clear(&b->fft_look[1]);
333 for(i=0;i<vi->channels;i++)
334 if(v->pcm[i])_ogg_free(v->pcm[i]);
336 if(v->pcmret)_ogg_free(v->pcmret);
340 /* free header, header1, header2 */
341 if(b->header)_ogg_free(b->header);
342 if(b->header1)_ogg_free(b->header1);
343 if(b->header2)_ogg_free(b->header2);
347 memset(v,0,sizeof(*v));
351 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
353 vorbis_info *vi=v->vi;
354 private_state *b=v->backend_state;
356 /* free header, header1, header2 */
357 if(b->header)_ogg_free(b->header);b->header=NULL;
358 if(b->header1)_ogg_free(b->header1);b->header1=NULL;
359 if(b->header2)_ogg_free(b->header2);b->header2=NULL;
361 /* Do we have enough storage space for the requested buffer? If not,
362 expand the PCM (and envelope) storage */
364 if(v->pcm_current+vals>=v->pcm_storage){
365 v->pcm_storage=v->pcm_current+vals*2;
367 for(i=0;i<vi->channels;i++){
368 v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
372 for(i=0;i<vi->channels;i++)
373 v->pcmret[i]=v->pcm[i]+v->pcm_current;
378 static void _preextrapolate_helper(vorbis_dsp_state *v){
381 float *lpc=alloca(order*sizeof(*lpc));
382 float *work=alloca(v->pcm_current*sizeof(*work));
386 if(v->pcm_current-v->centerW>order*2){ /* safety */
387 for(i=0;i<v->vi->channels;i++){
388 /* need to run the extrapolation in reverse! */
389 for(j=0;j<v->pcm_current;j++)
390 work[j]=v->pcm[i][v->pcm_current-j-1];
393 vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
395 /* run the predictor filter */
396 vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
398 work+v->pcm_current-v->centerW,
401 for(j=0;j<v->pcm_current;j++)
402 v->pcm[i][v->pcm_current-j-1]=work[j];
409 /* call with val<=0 to set eof */
411 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
412 vorbis_info *vi=v->vi;
413 codec_setup_info *ci=vi->codec_setup;
418 float *lpc=alloca(order*sizeof(*lpc));
420 /* if it wasn't done earlier (very short sample) */
421 if(!v->preextrapolate)
422 _preextrapolate_helper(v);
424 /* We're encoding the end of the stream. Just make sure we have
425 [at least] a few full blocks of zeroes at the end. */
426 /* actually, we don't want zeroes; that could drop a large
427 amplitude off a cliff, creating spread spectrum noise that will
428 suck to encode. Extrapolate for the sake of cleanliness. */
430 vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
431 v->eofflag=v->pcm_current;
432 v->pcm_current+=ci->blocksizes[1]*3;
434 for(i=0;i<vi->channels;i++){
435 if(v->eofflag>order*2){
436 /* extrapolate with LPC to fill in */
439 /* make a predictor filter */
441 if(n>ci->blocksizes[1])n=ci->blocksizes[1];
442 vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
444 /* run the predictor filter */
445 vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
446 v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
448 /* not enough data to extrapolate (unlikely to happen due to
449 guarding the overlap, but bulletproof in case that
450 assumtion goes away). zeroes will do. */
451 memset(v->pcm[i]+v->eofflag,0,
452 (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
458 if(v->pcm_current+vals>v->pcm_storage)
461 v->pcm_current+=vals;
463 /* we may want to reverse extrapolate the beginning of a stream
464 too... in case we're beginning on a cliff! */
465 /* clumsy, but simple. It only runs once, so simple is good. */
466 if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
467 _preextrapolate_helper(v);
473 /* do the deltas, envelope shaping, pre-echo and determine the size of
474 the next block on which to continue analysis */
475 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
477 vorbis_info *vi=v->vi;
478 codec_setup_info *ci=vi->codec_setup;
479 private_state *b=v->backend_state;
480 vorbis_look_psy_global *g=b->psy_g_look;
481 long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
482 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
484 /* check to see if we're started... */
485 if(!v->preextrapolate)return(0);
487 /* check to see if we're done... */
488 if(v->eofflag==-1)return(0);
490 /* By our invariant, we have lW, W and centerW set. Search for
491 the next boundary so we can determine nW (the next window size)
492 which lets us compute the shape of the current block's window */
494 /* we do an envelope search even on a single blocksize; we may still
495 be throwing more bits at impulses, and envelope search handles
496 marking impulses too. */
498 long bp=_ve_envelope_search(v);
501 if(v->eofflag==0)return(0); /* not enough data currently to search for a
506 if(ci->blocksizes[0]==ci->blocksizes[1])
513 centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
516 /* center of next block + next block maximum right side. */
518 long blockbound=centerNext+ci->blocksizes[v->nW]/2;
519 if(v->pcm_current<blockbound)return(0); /* not enough data yet;
520 although this check is
523 the search is not run
530 /* fill in the block. Note that for a short window, lW and nW are *short*
531 regardless of actual settings in the stream */
533 _vorbis_block_ripcord(vb);
539 if(!v->lW || !v->nW){
540 vbi->blocktype=BLOCKTYPE_TRANSITION;
541 /*fprintf(stderr,"-");*/
543 vbi->blocktype=BLOCKTYPE_LONG;
544 /*fprintf(stderr,"_");*/
547 if(_ve_envelope_mark(v)){
548 vbi->blocktype=BLOCKTYPE_IMPULSE;
549 /*fprintf(stderr,"|");*/
552 vbi->blocktype=BLOCKTYPE_PADDING;
553 /*fprintf(stderr,".");*/
559 vb->sequence=v->sequence++;
560 vb->granulepos=v->granulepos;
561 vb->pcmend=ci->blocksizes[v->W];
563 /* copy the vectors; this uses the local storage in vb */
565 /* this tracks 'strongest peak' for later psychoacoustics */
566 /* moved to the global psy state; clean this mess up */
567 if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
568 g->ampmax=_vp_ampmax_decay(g->ampmax,v);
569 vbi->ampmax=g->ampmax;
571 vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
572 vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
573 for(i=0;i<vi->channels;i++){
575 _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
576 memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
577 vb->pcm[i]=vbi->pcmdelay[i]+beginW;
579 /* before we added the delay
580 vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
581 memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
586 /* handle eof detection: eof==0 means that we've not yet received EOF
587 eof>0 marks the last 'real' sample in pcm[]
588 eof<0 'no more to do'; doesn't get here */
591 if(v->centerW>=v->eofflag){
598 /* advance storage vectors and clean up */
600 int new_centerNext=ci->blocksizes[1]/2;
601 int movementW=centerNext-new_centerNext;
605 _ve_envelope_shift(b->ve,movementW);
606 v->pcm_current-=movementW;
608 for(i=0;i<vi->channels;i++)
609 memmove(v->pcm[i],v->pcm[i]+movementW,
610 v->pcm_current*sizeof(*v->pcm[i]));
615 v->centerW=new_centerNext;
618 v->eofflag-=movementW;
619 if(v->eofflag<=0)v->eofflag=-1;
620 /* do not add padding to end of stream! */
621 if(v->centerW>=v->eofflag){
622 v->granulepos+=movementW-(v->centerW-v->eofflag);
624 v->granulepos+=movementW;
627 v->granulepos+=movementW;
636 int vorbis_synthesis_restart(vorbis_dsp_state *v){
637 vorbis_info *vi=v->vi;
638 codec_setup_info *ci;
640 if(!v->backend_state)return -1;
645 v->centerW=ci->blocksizes[1]/2;
646 v->pcm_current=v->centerW;
652 ((private_state *)(v->backend_state))->sample_count=-1;
657 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
658 _vds_shared_init(v,vi,0);
659 vorbis_synthesis_restart(v);
664 /* Unlike in analysis, the window is only partially applied for each
665 block. The time domain envelope is not yet handled at the point of
666 calling (as it relies on the previous block). */
668 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
669 vorbis_info *vi=v->vi;
670 codec_setup_info *ci=vi->codec_setup;
671 private_state *b=v->backend_state;
674 if(!vb)return(OV_EINVAL);
675 if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
681 if((v->sequence==-1)||
682 (v->sequence+1 != vb->sequence)){
683 v->granulepos=-1; /* out of sequence; lose count */
687 v->sequence=vb->sequence;
689 if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
690 was called on block */
691 int n=ci->blocksizes[v->W]/2;
692 int n0=ci->blocksizes[0]/2;
693 int n1=ci->blocksizes[1]/2;
698 v->glue_bits+=vb->glue_bits;
699 v->time_bits+=vb->time_bits;
700 v->floor_bits+=vb->floor_bits;
701 v->res_bits+=vb->res_bits;
711 /* v->pcm is now used like a two-stage double buffer. We don't want
712 to have to constantly shift *or* adjust memory usage. Don't
713 accept a new block until the old is shifted out */
715 /* overlap/add PCM */
717 for(j=0;j<vi->channels;j++){
718 /* the overlap/add section */
722 float *w=b->window[1];
723 float *pcm=v->pcm[j]+prevCenter;
726 pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
729 float *w=b->window[0];
730 float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
733 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
738 float *w=b->window[0];
739 float *pcm=v->pcm[j]+prevCenter;
740 float *p=vb->pcm[j]+n1/2-n0/2;
742 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
743 for(;i<n1/2+n0/2;i++)
747 float *w=b->window[0];
748 float *pcm=v->pcm[j]+prevCenter;
751 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
755 /* the copy section */
757 float *pcm=v->pcm[j]+thisCenter;
758 float *p=vb->pcm[j]+n;
769 /* deal with initial packet state; we do this using the explicit
770 pcm_returned==-1 flag otherwise we're sensitive to first block
771 being short or long */
773 if(v->pcm_returned==-1){
774 v->pcm_returned=thisCenter;
775 v->pcm_current=thisCenter;
777 v->pcm_returned=prevCenter;
778 v->pcm_current=prevCenter+
779 ci->blocksizes[v->lW]/4+
780 ci->blocksizes[v->W]/4;
785 /* track the frame number... This is for convenience, but also
786 making sure our last packet doesn't end with added padding. If
787 the last packet is partial, the number of samples we'll have to
788 return will be past the vb->granulepos.
790 This is not foolproof! It will be confused if we begin
791 decoding at the last page after a seek or hole. In that case,
792 we don't have a starting point to judge where the last frame
793 is. For this reason, vorbisfile will always try to make sure
794 it reads the last two marked pages in proper sequence */
796 if(b->sample_count==-1){
799 b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
802 if(v->granulepos==-1){
803 if(vb->granulepos!=-1){ /* only set if we have a position to set to */
805 v->granulepos=vb->granulepos;
807 /* is this a short page? */
808 if(b->sample_count>v->granulepos){
809 /* corner case; if this is both the first and last audio page,
810 then spec says the end is cut, not beginning */
813 /* no preceeding granulepos; assume we started at zero (we'd
814 have to in a short single-page stream) */
815 /* granulepos could be -1 due to a seek, but that would result
816 in a long count, not short count */
818 v->pcm_current-=(b->sample_count-v->granulepos);
820 /* trim the beginning */
821 v->pcm_returned+=(b->sample_count-v->granulepos);
822 if(v->pcm_returned>v->pcm_current)
823 v->pcm_returned=v->pcm_current;
830 v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
831 if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
833 if(v->granulepos>vb->granulepos){
834 long extra=v->granulepos-vb->granulepos;
838 /* partial last frame. Strip the extra samples off */
839 v->pcm_current-=extra;
840 } /* else {Shouldn't happen *unless* the bitstream is out of
841 spec. Either way, believe the bitstream } */
842 } /* else {Shouldn't happen *unless* the bitstream is out of
843 spec. Either way, believe the bitstream } */
844 v->granulepos=vb->granulepos;
848 /* Update, cleanup */
850 if(vb->eofflag)v->eofflag=1;
855 /* pcm==NULL indicates we just want the pending samples, no more */
856 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
857 vorbis_info *vi=v->vi;
858 if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
861 for(i=0;i<vi->channels;i++)
862 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
865 return(v->pcm_current-v->pcm_returned);
870 int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
871 if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
876 /* intended for use with a specific vorbisfile feature; we want access
877 to the [usually synthetic/postextrapolated] buffer and lapping at
878 the end of a decode cycle, specifically, a half-short-block worth.
879 This funtion works like pcmout above, except it will also expose
880 this implicit buffer data not normally decoded. */
881 int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
882 vorbis_info *vi=v->vi;
883 codec_setup_info *ci=vi->codec_setup;
885 int n=ci->blocksizes[v->W]/2;
886 int n0=ci->blocksizes[0]/2;
887 int n1=ci->blocksizes[1]/2;
890 if(v->pcm_returned<0)return 0;
892 /* our returned data ends at pcm_returned; because the synthesis pcm
893 buffer is a two-fragment ring, that means our data block may be
894 fragmented by buffering, wrapping or a short block not filling
895 out a buffer. To simplify things, we unfragment if it's at all
896 possibly needed. Otherwise, we'd need to call lapout more than
897 once as well as hold additional dsp state. Opt for
900 /* centerW was advanced by blockin; it would be the center of the
903 /* the data buffer wraps; swap the halves */
904 /* slow, sure, small */
905 for(j=0;j<vi->channels;j++){
920 /* long/short or short/long */
921 for(j=0;j<vi->channels;j++){
923 float *d=v->pcm[j]+(n1-n0)/2;
924 for(i=(n1+n0)/2-1;i>=0;--i)
927 v->pcm_returned+=(n1-n0)/2;
928 v->pcm_current+=(n1-n0)/2;
932 for(j=0;j<vi->channels;j++){
934 float *d=v->pcm[j]+n1-n0;
938 v->pcm_returned+=n1-n0;
939 v->pcm_current+=n1-n0;
945 for(i=0;i<vi->channels;i++)
946 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
950 return(n1+n-v->pcm_returned);
954 float *vorbis_window(vorbis_dsp_state *v,int W){
955 private_state *b=v->backend_state;