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.56 2002/01/19 04:52:39 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){
43 /* pcm accumulator examples (not exhaustive):
45 <-------------- lW ---------------->
46 <--------------- W ---------------->
47 : .....|..... _______________ |
48 : .''' | '''_--- | |\ |
49 :.....''' |_____--- '''......| | \_______|
50 :.................|__________________|_______|__|______|
51 |<------ Sl ------>| > Sr < |endW
52 |beginSl |endSl | |endSr
53 |beginW |endlW |beginSr
57 <--------------- W ---------------->
58 | | .. ______________ |
60 |___.'___/`. | ---_____|
61 |_______|__|_______|_________________|
62 | >|Sl|< |<------ Sr ----->|endW
63 | | |endSl |beginSr |endSr
65 mult[0] |beginSl mult[n]
67 <-------------- lW ----------------->
69 : .............. ___ | |
71 :.....''' |/`....\|...|
72 :.........................|___|___|___|
81 /* block abstraction setup *********************************************/
87 int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
88 memset(vb,0,sizeof(*vb));
93 vorbis_block_internal *vbi=
94 vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
95 oggpack_writeinit(&vb->opb);
97 vbi->packet_markers=_ogg_malloc(vorbis_bitrate_maxmarkers()*
98 sizeof(*vbi->packet_markers));
104 void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
105 bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
106 if(bytes+vb->localtop>vb->localalloc){
107 /* can't just _ogg_realloc... there are outstanding pointers */
109 struct alloc_chain *link=_ogg_malloc(sizeof(*link));
110 vb->totaluse+=vb->localtop;
112 link->ptr=vb->localstore;
115 /* highly conservative */
116 vb->localalloc=bytes;
117 vb->localstore=_ogg_malloc(vb->localalloc);
121 void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
127 /* reap the chain, pull the ripcord */
128 void _vorbis_block_ripcord(vorbis_block *vb){
130 struct alloc_chain *reap=vb->reap;
132 struct alloc_chain *next=reap->next;
133 _ogg_free(reap->ptr);
134 memset(reap,0,sizeof(*reap));
138 /* consolidate storage */
140 vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
141 vb->localalloc+=vb->totaluse;
145 /* pull the ripcord */
150 int vorbis_block_clear(vorbis_block *vb){
152 if(vb->vd->analysisp)
153 oggpack_writeclear(&vb->opb);
154 _vorbis_block_ripcord(vb);
155 if(vb->localstore)_ogg_free(vb->localstore);
158 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
159 if(vbi->packet_markers)_ogg_free(vbi->packet_markers);
161 _ogg_free(vb->internal);
164 memset(vb,0,sizeof(*vb));
168 /* Analysis side code, but directly related to blocking. Thus it's
169 here and not in analysis.c (which is for analysis transforms only).
170 The init is here because some of it is shared */
172 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
174 codec_setup_info *ci=vi->codec_setup;
175 backend_lookup_state *b=NULL;
177 memset(v,0,sizeof(*v));
178 b=v->backend_state=_ogg_calloc(1,sizeof(*b));
181 b->modebits=ilog2(ci->modes);
183 b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
184 b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
186 /* MDCT is tranform 0 */
188 b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
189 b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
190 mdct_init(b->transform[0][0],ci->blocksizes[0]);
191 mdct_init(b->transform[1][0],ci->blocksizes[1]);
193 b->window[0][0][0]=_ogg_calloc(VI_WINDOWB,sizeof(*b->window[0][0][0]));
194 b->window[0][0][1]=b->window[0][0][0];
195 b->window[0][1][0]=b->window[0][0][0];
196 b->window[0][1][1]=b->window[0][0][0];
197 b->window[1][0][0]=_ogg_calloc(VI_WINDOWB,sizeof(*b->window[1][0][0]));
198 b->window[1][0][1]=_ogg_calloc(VI_WINDOWB,sizeof(*b->window[1][0][1]));
199 b->window[1][1][0]=_ogg_calloc(VI_WINDOWB,sizeof(*b->window[1][1][0]));
200 b->window[1][1][1]=_ogg_calloc(VI_WINDOWB,sizeof(*b->window[1][1][1]));
202 for(i=0;i<VI_WINDOWB;i++){
203 b->window[0][0][0][i]=
204 _vorbis_window(i,ci->blocksizes[0],ci->blocksizes[0]/2,ci->blocksizes[0]/2);
205 b->window[1][0][0][i]=
206 _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[0]/2,ci->blocksizes[0]/2);
207 b->window[1][0][1][i]=
208 _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[0]/2,ci->blocksizes[1]/2);
209 b->window[1][1][0][i]=
210 _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[1]/2,ci->blocksizes[0]/2);
211 b->window[1][1][1][i]=
212 _vorbis_window(i,ci->blocksizes[1],ci->blocksizes[1]/2,ci->blocksizes[1]/2);
215 if(encp){ /* encode/decode differ here */
216 /* finish the codebooks */
217 b->fullbooks=_ogg_calloc(ci->books,sizeof(*b->fullbooks));
218 for(i=0;i<ci->books;i++)
219 vorbis_book_init_encode(b->fullbooks+i,ci->book_param[i]);
222 /* finish the codebooks */
223 b->fullbooks=_ogg_calloc(ci->books,sizeof(*b->fullbooks));
224 for(i=0;i<ci->books;i++){
225 vorbis_book_init_decode(b->fullbooks+i,ci->book_param[i]);
226 /* decode codebooks are now standalone after init */
227 vorbis_staticbook_destroy(ci->book_param[i]);
228 ci->book_param[i]=NULL;
232 /* initialize the storage vectors to a decent size greater than the
235 v->pcm_storage=8192; /* we'll assume later that we have
236 a minimum of twice the blocksize of
237 accumulated samples in analysis */
238 v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
239 v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
242 for(i=0;i<vi->channels;i++)
243 v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
246 /* all 1 (large block) or 0 (small block) */
247 /* explicitly set for the sake of clarity */
248 v->lW=0; /* previous window size */
249 v->W=0; /* current window size */
251 /* all vector indexes */
252 v->centerW=ci->blocksizes[1]/2;
254 v->pcm_current=v->centerW;
256 /* initialize all the mapping/backend lookups */
257 b->mode=_ogg_calloc(ci->modes,sizeof(*b->mode));
258 for(i=0;i<ci->modes;i++){
259 int mapnum=ci->mode_param[i]->mapping;
260 int maptype=ci->map_type[mapnum];
261 b->mode[i]=_mapping_P[maptype]->look(v,ci->mode_param[i],
262 ci->map_param[mapnum]);
268 /* arbitrary settings and spec-mandated numbers get filled in here */
269 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
270 backend_lookup_state *b=NULL;
272 _vds_shared_init(v,vi,1);
274 b->psy_g_look=_vp_global_look(vi);
276 /* Initialize the envelope state storage */
277 b->ve=_ogg_calloc(1,sizeof(*b->ve));
278 _ve_envelope_init(b->ve,vi);
280 vorbis_bitrate_init(vi,&b->bms);
285 void vorbis_dsp_clear(vorbis_dsp_state *v){
288 vorbis_info *vi=v->vi;
289 codec_setup_info *ci=(vi?vi->codec_setup:NULL);
290 backend_lookup_state *b=v->backend_state;
293 if(b->window[0][0][0]){
294 for(i=0;i<VI_WINDOWB;i++)
295 if(b->window[0][0][0][i])_ogg_free(b->window[0][0][0][i]);
296 _ogg_free(b->window[0][0][0]);
300 for(i=0;i<VI_WINDOWB;i++)
301 if(b->window[1][j][k][i])_ogg_free(b->window[1][j][k][i]);
302 _ogg_free(b->window[1][j][k]);
307 _ve_envelope_clear(b->ve);
312 mdct_clear(b->transform[0][0]);
313 _ogg_free(b->transform[0][0]);
314 _ogg_free(b->transform[0]);
317 mdct_clear(b->transform[1][0]);
318 _ogg_free(b->transform[1][0]);
319 _ogg_free(b->transform[1]);
321 if(b->psy_g_look)_vp_global_free(b->psy_g_look);
322 vorbis_bitrate_clear(&b->bms);
326 for(i=0;i<vi->channels;i++)
327 if(v->pcm[i])_ogg_free(v->pcm[i]);
329 if(v->pcmret)_ogg_free(v->pcmret);
332 /* free mode lookups; these are actually vorbis_look_mapping structs */
334 for(i=0;i<ci->modes;i++){
335 int mapnum=ci->mode_param[i]->mapping;
336 int maptype=ci->map_type[mapnum];
337 if(b && b->mode)_mapping_P[maptype]->free_look(b->mode[i]);
340 for(i=0;i<ci->books;i++)
341 if(b && b->fullbooks)vorbis_book_clear(b->fullbooks+i);
345 if(b->mode)_ogg_free(b->mode);
346 if(b->fullbooks)_ogg_free(b->fullbooks);
348 /* free header, header1, header2 */
349 if(b->header)_ogg_free(b->header);
350 if(b->header1)_ogg_free(b->header1);
351 if(b->header2)_ogg_free(b->header2);
355 memset(v,0,sizeof(*v));
359 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
361 vorbis_info *vi=v->vi;
362 backend_lookup_state *b=v->backend_state;
364 /* free header, header1, header2 */
365 if(b->header)_ogg_free(b->header);b->header=NULL;
366 if(b->header1)_ogg_free(b->header1);b->header1=NULL;
367 if(b->header2)_ogg_free(b->header2);b->header2=NULL;
369 /* Do we have enough storage space for the requested buffer? If not,
370 expand the PCM (and envelope) storage */
372 if(v->pcm_current+vals>=v->pcm_storage){
373 v->pcm_storage=v->pcm_current+vals*2;
375 for(i=0;i<vi->channels;i++){
376 v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
380 for(i=0;i<vi->channels;i++)
381 v->pcmret[i]=v->pcm[i]+v->pcm_current;
386 static void _preextrapolate_helper(vorbis_dsp_state *v){
389 float *lpc=alloca(order*sizeof(*lpc));
390 float *work=alloca(v->pcm_current*sizeof(*work));
394 if(v->pcm_current-v->centerW>order*2){ /* safety */
395 for(i=0;i<v->vi->channels;i++){
396 /* need to run the extrapolation in reverse! */
397 for(j=0;j<v->pcm_current;j++)
398 work[j]=v->pcm[i][v->pcm_current-j-1];
401 vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
403 /* run the predictor filter */
404 vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
406 work+v->pcm_current-v->centerW,
409 for(j=0;j<v->pcm_current;j++)
410 v->pcm[i][v->pcm_current-j-1]=work[j];
417 /* call with val<=0 to set eof */
419 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
420 vorbis_info *vi=v->vi;
421 codec_setup_info *ci=vi->codec_setup;
422 /*backend_lookup_state *b=v->backend_state;*/
427 float *lpc=alloca(order*sizeof(*lpc));
429 /* if it wasn't done earlier (very short sample) */
430 if(!v->preextrapolate)
431 _preextrapolate_helper(v);
433 /* We're encoding the end of the stream. Just make sure we have
434 [at least] a full block of zeroes at the end. */
435 /* actually, we don't want zeroes; that could drop a large
436 amplitude off a cliff, creating spread spectrum noise that will
437 suck to encode. Extrapolate for the sake of cleanliness. */
439 vorbis_analysis_buffer(v,ci->blocksizes[1]*2);
440 v->eofflag=v->pcm_current;
441 v->pcm_current+=ci->blocksizes[1]*2;
443 for(i=0;i<vi->channels;i++){
444 if(v->eofflag>order*2){
445 /* extrapolate with LPC to fill in */
448 /* make a predictor filter */
450 if(n>ci->blocksizes[1])n=ci->blocksizes[1];
451 vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
453 /* run the predictor filter */
454 vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
455 v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
457 /* not enough data to extrapolate (unlikely to happen due to
458 guarding the overlap, but bulletproof in case that
459 assumtion goes away). zeroes will do. */
460 memset(v->pcm[i]+v->eofflag,0,
461 (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
467 if(v->pcm_current+vals>v->pcm_storage)
470 v->pcm_current+=vals;
472 /* we may want to reverse extrapolate the beginning of a stream
473 too... in case we're beginning on a cliff! */
474 /* clumsy, but simple. It only runs once, so simple is good. */
475 if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
476 _preextrapolate_helper(v);
482 /* do the deltas, envelope shaping, pre-echo and determine the size of
483 the next block on which to continue analysis */
484 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
486 vorbis_info *vi=v->vi;
487 codec_setup_info *ci=vi->codec_setup;
488 backend_lookup_state *b=v->backend_state;
489 vorbis_look_psy_global *g=b->psy_g_look;
490 vorbis_info_psy_global *gi=&ci->psy_g_param;
491 long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
492 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
494 /* check to see if we're started... */
495 if(!v->preextrapolate)return(0);
497 /* check to see if we're done... */
498 if(v->eofflag==-1)return(0);
500 /* By our invariant, we have lW, W and centerW set. Search for
501 the next boundary so we can determine nW (the next window size)
502 which lets us compute the shape of the current block's window */
504 if(ci->blocksizes[0]<ci->blocksizes[1]){
505 long bp=_ve_envelope_search(v);
506 if(bp==-1)return(0); /* not enough data currently to search for a
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);
546 vbi->blocktype=BLOCKTYPE_TRANSITION;
548 vbi->blocktype=BLOCKTYPE_LONG;
550 if(_ve_envelope_mark(v))
551 vbi->blocktype=BLOCKTYPE_IMPULSE;
553 vbi->blocktype=BLOCKTYPE_PADDING;
557 vb->sequence=v->sequence++;
558 vb->granulepos=v->granulepos;
559 vb->pcmend=ci->blocksizes[v->W];
561 /* copy the vectors; this uses the local storage in vb */
563 /* this tracks 'strongest peak' for later psychoacoustics */
564 /* moved to the global psy state; clean this mess up */
565 if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
566 g->ampmax=_vp_ampmax_decay(g->ampmax,v);
567 vbi->ampmax=g->ampmax;
569 vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
570 vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
571 for(i=0;i<vi->channels;i++){
573 _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
574 memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
575 vb->pcm[i]=vbi->pcmdelay[i]+beginW;
577 /* before we added the delay
578 vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
579 memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
584 /* handle eof detection: eof==0 means that we've not yet received EOF
585 eof>0 marks the last 'real' sample in pcm[]
586 eof<0 'no more to do'; doesn't get here */
589 if(v->centerW>=v->eofflag){
596 /* advance storage vectors and clean up */
598 int new_centerNext=ci->blocksizes[1]/2+gi->delaycache;
599 int movementW=centerNext-new_centerNext;
603 _ve_envelope_shift(b->ve,movementW);
604 v->pcm_current-=movementW;
606 for(i=0;i<vi->channels;i++)
607 memmove(v->pcm[i],v->pcm[i]+movementW,
608 v->pcm_current*sizeof(*v->pcm[i]));
613 v->centerW=new_centerNext;
616 v->eofflag-=movementW;
617 /* do not add padding to end of stream! */
618 if(v->centerW>=v->eofflag){
619 v->granulepos+=movementW-(v->centerW-v->eofflag);
621 v->granulepos+=movementW;
624 v->granulepos+=movementW;
633 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
634 _vds_shared_init(v,vi,0);
643 /* Unlike in analysis, the window is only partially applied for each
644 block. The time domain envelope is not yet handled at the point of
645 calling (as it relies on the previous block). */
647 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
648 vorbis_info *vi=v->vi;
649 codec_setup_info *ci=vi->codec_setup;
651 /* Shift out any PCM that we returned previously */
652 /* centerW is currently the center of the last block added */
654 if(v->centerW>ci->blocksizes[1]/2 &&
655 /* Quick additional hack; to avoid *alot* of shifts, use an
656 oversized buffer. This increases memory usage, but doesn't make
657 much difference wrt L1/L2 cache pressure. */
658 v->pcm_returned>8192){
660 /* don't shift too much; we need to have a minimum PCM buffer of
663 int shiftPCM=v->centerW-ci->blocksizes[1]/2;
664 shiftPCM=(v->pcm_returned<shiftPCM?v->pcm_returned:shiftPCM);
666 v->pcm_current-=shiftPCM;
667 v->centerW-=shiftPCM;
668 v->pcm_returned-=shiftPCM;
672 for(i=0;i<vi->channels;i++)
673 memmove(v->pcm[i],v->pcm[i]+shiftPCM,
674 v->pcm_current*sizeof(*v->pcm[i]));
682 v->glue_bits+=vb->glue_bits;
683 v->time_bits+=vb->time_bits;
684 v->floor_bits+=vb->floor_bits;
685 v->res_bits+=vb->res_bits;
687 if(v->sequence+1 != vb->sequence)v->granulepos=-1; /* out of sequence;
690 v->sequence=vb->sequence;
693 int sizeW=ci->blocksizes[v->W];
694 int centerW=v->centerW+ci->blocksizes[v->lW]/4+sizeW/4;
695 int beginW=centerW-sizeW/2;
696 int endW=beginW+sizeW;
701 /* Do we have enough PCM/mult storage for the block? */
702 if(endW>v->pcm_storage){
703 /* expand the storage */
704 v->pcm_storage=endW+ci->blocksizes[1];
706 for(i=0;i<vi->channels;i++)
707 v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
710 /* overlap/add PCM */
715 endSl=ci->blocksizes[0]/2;
718 beginSl=ci->blocksizes[1]/4-ci->blocksizes[v->lW]/4;
719 endSl=beginSl+ci->blocksizes[v->lW]/2;
725 for(j=0;j<vi->channels;j++){
726 float *pcm=v->pcm[j]+beginW;
729 /* the overlap/add section */
730 for(i=beginSl;i<endSl;i++)
732 /* the remaining section */
738 /* deal with initial packet state; we do this using the explicit
739 pcm_returned==-1 flag otherwise we're sensitive to first block
740 being short or long */
742 if(v->pcm_returned==-1)
743 v->pcm_returned=centerW;
745 /* track the frame number... This is for convenience, but also
746 making sure our last packet doesn't end with added padding. If
747 the last packet is partial, the number of samples we'll have to
748 return will be past the vb->granulepos.
750 This is not foolproof! It will be confused if we begin
751 decoding at the last page after a seek or hole. In that case,
752 we don't have a starting point to judge where the last frame
753 is. For this reason, vorbisfile will always try to make sure
754 it reads the last two marked pages in proper sequence */
756 if(v->granulepos==-1)
757 if(vb->granulepos==-1){
760 v->granulepos=vb->granulepos;
763 v->granulepos+=(centerW-v->centerW);
764 if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
766 if(v->granulepos>vb->granulepos){
767 long extra=v->granulepos-vb->granulepos;
770 /* partial last frame. Strip the extra samples off */
772 }else if(vb->sequence == 1){
773 /* ^^^ argh, this can be 1 from seeking! */
776 /* partial first frame. Discard extra leading samples */
777 v->pcm_returned+=extra;
778 if(v->pcm_returned>centerW)v->pcm_returned=centerW;
782 }/* else{ Shouldn't happen *unless* the bitstream is out of
783 spec. Either way, believe the bitstream } */
784 v->granulepos=vb->granulepos;
788 /* Update, cleanup */
793 if(vb->eofflag)v->eofflag=1;
799 /* pcm==NULL indicates we just want the pending samples, no more */
800 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
801 vorbis_info *vi=v->vi;
802 if(v->pcm_returned>-1 && v->pcm_returned<v->centerW){
805 for(i=0;i<vi->channels;i++)
806 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
809 return(v->centerW-v->pcm_returned);
814 int vorbis_synthesis_read(vorbis_dsp_state *v,int bytes){
815 if(bytes && v->pcm_returned+bytes>v->centerW)return(OV_EINVAL);
816 v->pcm_returned+=bytes;