dbf-halloween2015
view libs/vorbis/block.c @ 4:4316c0c879e9
fixed RUN script for macosx
| author | John Tsiombikas <nuclear@member.fsf.org> |
|---|---|
| date | Sun, 01 Nov 2015 06:18:18 +0200 |
| parents | |
| children |
line source
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 ********************************************************************
13 function: PCM data vector blocking, windowing and dis/reassembly
14 last mod: $Id: block.c 17561 2010-10-23 10:34:24Z xiphmont $
16 Handle windowing, overlap-add, etc of the PCM vectors. This is made
17 more amusing by Vorbis' current two allowed block sizes.
19 ********************************************************************/
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"
28 #include "window.h"
29 #include "mdct.h"
30 #include "lpc.h"
31 #include "registry.h"
32 #include "misc.h"
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 }
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
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]
68 <-------------- lW ----------------->
69 |<--W-->|
70 : .............. ___ | |
71 : .''' |`/ \ | |
72 :.....''' |/`....\|...|
73 :.........................|___|___|___|
74 |Sl |Sr |endW
75 | | |endSr
76 | |beginSr
77 | |endSl
78 |beginSl
79 |beginW
80 */
82 /* block abstraction setup *********************************************/
84 #ifndef WORD_ALIGN
85 #define WORD_ALIGN 8
86 #endif
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;
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 }
110 return(0);
111 }
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 }
136 /* reap the chain, pull the ripcord */
137 void _vorbis_block_ripcord(vorbis_block *vb){
138 /* reap the chain */
139 struct alloc_chain *reap=vb->reap;
140 while(reap){
141 struct alloc_chain *next=reap->next;
142 _ogg_free(reap->ptr);
143 memset(reap,0,sizeof(*reap));
144 _ogg_free(reap);
145 reap=next;
146 }
147 /* consolidate storage */
148 if(vb->totaluse){
149 vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
150 vb->localalloc+=vb->totaluse;
151 vb->totaluse=0;
152 }
154 /* pull the ripcord */
155 vb->localtop=0;
156 vb->reap=NULL;
157 }
159 int vorbis_block_clear(vorbis_block *vb){
160 int i;
161 vorbis_block_internal *vbi=vb->internal;
163 _vorbis_block_ripcord(vb);
164 if(vb->localstore)_ogg_free(vb->localstore);
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 }
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){
182 int i;
183 codec_setup_info *ci=vi->codec_setup;
184 private_state *b=NULL;
185 int hs;
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));
193 v->vi=vi;
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 */
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 }
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 }
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 }
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));
254 {
255 int i;
256 for(i=0;i<vi->channels;i++)
257 v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
258 }
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]);
282 return 0;
283 abort_books:
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;
288 }
289 }
290 vorbis_dsp_clear(v);
291 return -1;
292 }
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;
299 b=v->backend_state;
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 */
310 v->sequence=3;
312 return(0);
313 }
315 void vorbis_dsp_clear(vorbis_dsp_state *v){
316 int i;
317 if(v){
318 vorbis_info *vi=v->vi;
319 codec_setup_info *ci=(vi?vi->codec_setup:NULL);
320 private_state *b=v->backend_state;
322 if(b){
324 if(b->ve){
325 _ve_envelope_clear(b->ve);
326 _ogg_free(b->ve);
327 }
329 if(b->transform[0]){
330 mdct_clear(b->transform[0][0]);
331 _ogg_free(b->transform[0][0]);
332 _ogg_free(b->transform[0]);
333 }
334 if(b->transform[1]){
335 mdct_clear(b->transform[1][0]);
336 _ogg_free(b->transform[1][0]);
337 _ogg_free(b->transform[1]);
338 }
340 if(b->flr){
341 if(ci)
342 for(i=0;i<ci->floors;i++)
343 _floor_P[ci->floor_type[i]]->
344 free_look(b->flr[i]);
345 _ogg_free(b->flr);
346 }
347 if(b->residue){
348 if(ci)
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);
353 }
354 if(b->psy){
355 if(ci)
356 for(i=0;i<ci->psys;i++)
357 _vp_psy_clear(b->psy+i);
358 _ogg_free(b->psy);
359 }
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]);
367 }
369 if(v->pcm){
370 if(vi)
371 for(i=0;i<vi->channels;i++)
372 if(v->pcm[i])_ogg_free(v->pcm[i]);
373 _ogg_free(v->pcm);
374 if(v->pcmret)_ogg_free(v->pcmret);
375 }
377 if(b){
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);
382 _ogg_free(b);
383 }
385 memset(v,0,sizeof(*v));
386 }
387 }
389 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
390 int i;
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]));
407 }
408 }
410 for(i=0;i<vi->channels;i++)
411 v->pcmret[i]=v->pcm[i]+v->pcm_current;
413 return(v->pcmret);
414 }
416 static void _preextrapolate_helper(vorbis_dsp_state *v){
417 int i;
418 int order=16;
419 float *lpc=alloca(order*sizeof(*lpc));
420 float *work=alloca(v->pcm_current*sizeof(*work));
421 long j;
422 v->preextrapolate=1;
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];
430 /* prime as above */
431 vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
433 #if 0
434 if(v->vi->channels==2){
435 if(i==0)
436 _analysis_output("predataL",0,work,v->pcm_current-v->centerW,0,0,0);
437 else
438 _analysis_output("predataR",0,work,v->pcm_current-v->centerW,0,0,0);
439 }else{
440 _analysis_output("predata",0,work,v->pcm_current-v->centerW,0,0,0);
441 }
442 #endif
444 /* run the predictor filter */
445 vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
446 order,
447 work+v->pcm_current-v->centerW,
448 v->centerW);
450 for(j=0;j<v->pcm_current;j++)
451 v->pcm[i][v->pcm_current-j-1]=work[j];
453 }
454 }
455 }
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;
464 if(vals<=0){
465 int order=32;
466 int i;
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 */
486 long n;
488 /* make a predictor filter */
489 n=v->eofflag;
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);
496 }else{
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]));
503 }
504 }
505 }else{
507 if(v->pcm_current+vals>v->pcm_storage)
508 return(OV_EINVAL);
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);
518 }
519 return(0);
520 }
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){
525 int i;
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. */
546 {
547 long bp=_ve_envelope_search(v);
548 if(bp==-1){
550 if(v->eofflag==0)return(0); /* not enough data currently to search for a
551 full long block */
552 v->nW=0;
553 }else{
555 if(ci->blocksizes[0]==ci->blocksizes[1])
556 v->nW=0;
557 else
558 v->nW=bp;
559 }
560 }
562 centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
564 {
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
570 less strict that the
571 _ve_envelope_search,
572 the search is not run
573 if we only use one
574 block size */
577 }
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);
583 vb->lW=v->lW;
584 vb->W=v->W;
585 vb->nW=v->nW;
587 if(v->W){
588 if(!v->lW || !v->nW){
589 vbi->blocktype=BLOCKTYPE_TRANSITION;
590 /*fprintf(stderr,"-");*/
591 }else{
592 vbi->blocktype=BLOCKTYPE_LONG;
593 /*fprintf(stderr,"_");*/
594 }
595 }else{
596 if(_ve_envelope_mark(v)){
597 vbi->blocktype=BLOCKTYPE_IMPULSE;
598 /*fprintf(stderr,"|");*/
600 }else{
601 vbi->blocktype=BLOCKTYPE_PADDING;
602 /*fprintf(stderr,".");*/
604 }
605 }
607 vb->vd=v;
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++){
623 vbi->pcmdelay[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]));
631 */
633 }
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 */
639 if(v->eofflag){
640 if(v->centerW>=v->eofflag){
641 v->eofflag=-1;
642 vb->eofflag=1;
643 return(1);
644 }
645 }
647 /* advance storage vectors and clean up */
648 {
649 int new_centerNext=ci->blocksizes[1]/2;
650 int movementW=centerNext-new_centerNext;
652 if(movementW>0){
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]));
662 v->lW=v->W;
663 v->W=v->nW;
664 v->centerW=new_centerNext;
666 if(v->eofflag){
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);
672 }else{
673 v->granulepos+=movementW;
674 }
675 }else{
676 v->granulepos+=movementW;
677 }
678 }
679 }
681 /* done */
682 return(1);
683 }
685 int vorbis_synthesis_restart(vorbis_dsp_state *v){
686 vorbis_info *vi=v->vi;
687 codec_setup_info *ci;
688 int hs;
690 if(!v->backend_state)return -1;
691 if(!vi)return -1;
692 ci=vi->codec_setup;
693 if(!ci)return -1;
694 hs=ci->halfrate_flag;
696 v->centerW=ci->blocksizes[1]>>(hs+1);
697 v->pcm_current=v->centerW>>hs;
699 v->pcm_returned=-1;
700 v->granulepos=-1;
701 v->sequence=-1;
702 v->eofflag=0;
703 ((private_state *)(v->backend_state))->sample_count=-1;
705 return(0);
706 }
708 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
709 if(_vds_shared_init(v,vi,0)){
710 vorbis_dsp_clear(v);
711 return 1;
712 }
713 vorbis_synthesis_restart(v);
714 return 0;
715 }
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;
726 int i,j;
728 if(!vb)return(OV_EINVAL);
729 if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
731 v->lW=v->W;
732 v->W=vb->W;
733 v->nW=-1;
735 if((v->sequence==-1)||
736 (v->sequence+1 != vb->sequence)){
737 v->granulepos=-1; /* out of sequence; lose count */
738 b->sample_count=-1;
739 }
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);
749 int thisCenter;
750 int prevCenter;
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;
757 if(v->centerW){
758 thisCenter=n1;
759 prevCenter=0;
760 }else{
761 thisCenter=0;
762 prevCenter=n1;
763 }
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 */
771 if(v->lW){
772 if(v->W){
773 /* large/large */
774 float *w=_vorbis_window_get(b->window[1]-hs);
775 float *pcm=v->pcm[j]+prevCenter;
776 float *p=vb->pcm[j];
777 for(i=0;i<n1;i++)
778 pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
779 }else{
780 /* large/small */
781 float *w=_vorbis_window_get(b->window[0]-hs);
782 float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
783 float *p=vb->pcm[j];
784 for(i=0;i<n0;i++)
785 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
786 }
787 }else{
788 if(v->W){
789 /* small/large */
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;
793 for(i=0;i<n0;i++)
794 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
795 for(;i<n1/2+n0/2;i++)
796 pcm[i]=p[i];
797 }else{
798 /* small/small */
799 float *w=_vorbis_window_get(b->window[0]-hs);
800 float *pcm=v->pcm[j]+prevCenter;
801 float *p=vb->pcm[j];
802 for(i=0;i<n0;i++)
803 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
804 }
805 }
807 /* the copy section */
808 {
809 float *pcm=v->pcm[j]+thisCenter;
810 float *p=vb->pcm[j]+n;
811 for(i=0;i<n;i++)
812 pcm[i]=p[i];
813 }
814 }
816 if(v->centerW)
817 v->centerW=0;
818 else
819 v->centerW=n1;
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;
828 }else{
829 v->pcm_returned=prevCenter;
830 v->pcm_current=prevCenter+
831 ((ci->blocksizes[v->lW]/4+
832 ci->blocksizes[v->W]/4)>>hs);
833 }
835 }
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){
849 b->sample_count=0;
850 }else{
851 b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
852 }
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 */
863 long extra=b->sample_count-vb->granulepos;
865 /* we use ogg_int64_t for granule positions because a
866 uint64 isn't universally available. Unfortunately,
867 that means granposes can be 'negative' and result in
868 extra being negative */
869 if(extra<0)
870 extra=0;
872 if(vb->eofflag){
873 /* trim the end */
874 /* no preceding granulepos; assume we started at zero (we'd
875 have to in a short single-page stream) */
876 /* granulepos could be -1 due to a seek, but that would result
877 in a long count, not short count */
879 /* Guard against corrupt/malicious frames that set EOP and
880 a backdated granpos; don't rewind more samples than we
881 actually have */
882 if(extra > (v->pcm_current - v->pcm_returned)<<hs)
883 extra = (v->pcm_current - v->pcm_returned)<<hs;
885 v->pcm_current-=extra>>hs;
886 }else{
887 /* trim the beginning */
888 v->pcm_returned+=extra>>hs;
889 if(v->pcm_returned>v->pcm_current)
890 v->pcm_returned=v->pcm_current;
891 }
893 }
895 }
896 }else{
897 v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
898 if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
900 if(v->granulepos>vb->granulepos){
901 long extra=v->granulepos-vb->granulepos;
903 if(extra)
904 if(vb->eofflag){
905 /* partial last frame. Strip the extra samples off */
907 /* Guard against corrupt/malicious frames that set EOP and
908 a backdated granpos; don't rewind more samples than we
909 actually have */
910 if(extra > (v->pcm_current - v->pcm_returned)<<hs)
911 extra = (v->pcm_current - v->pcm_returned)<<hs;
913 /* we use ogg_int64_t for granule positions because a
914 uint64 isn't universally available. Unfortunately,
915 that means granposes can be 'negative' and result in
916 extra being negative */
917 if(extra<0)
918 extra=0;
920 v->pcm_current-=extra>>hs;
921 } /* else {Shouldn't happen *unless* the bitstream is out of
922 spec. Either way, believe the bitstream } */
923 } /* else {Shouldn't happen *unless* the bitstream is out of
924 spec. Either way, believe the bitstream } */
925 v->granulepos=vb->granulepos;
926 }
927 }
929 /* Update, cleanup */
931 if(vb->eofflag)v->eofflag=1;
932 return(0);
934 }
936 /* pcm==NULL indicates we just want the pending samples, no more */
937 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
938 vorbis_info *vi=v->vi;
940 if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
941 if(pcm){
942 int i;
943 for(i=0;i<vi->channels;i++)
944 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
945 *pcm=v->pcmret;
946 }
947 return(v->pcm_current-v->pcm_returned);
948 }
949 return(0);
950 }
952 int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
953 if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
954 v->pcm_returned+=n;
955 return(0);
956 }
958 /* intended for use with a specific vorbisfile feature; we want access
959 to the [usually synthetic/postextrapolated] buffer and lapping at
960 the end of a decode cycle, specifically, a half-short-block worth.
961 This funtion works like pcmout above, except it will also expose
962 this implicit buffer data not normally decoded. */
963 int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
964 vorbis_info *vi=v->vi;
965 codec_setup_info *ci=vi->codec_setup;
966 int hs=ci->halfrate_flag;
968 int n=ci->blocksizes[v->W]>>(hs+1);
969 int n0=ci->blocksizes[0]>>(hs+1);
970 int n1=ci->blocksizes[1]>>(hs+1);
971 int i,j;
973 if(v->pcm_returned<0)return 0;
975 /* our returned data ends at pcm_returned; because the synthesis pcm
976 buffer is a two-fragment ring, that means our data block may be
977 fragmented by buffering, wrapping or a short block not filling
978 out a buffer. To simplify things, we unfragment if it's at all
979 possibly needed. Otherwise, we'd need to call lapout more than
980 once as well as hold additional dsp state. Opt for
981 simplicity. */
983 /* centerW was advanced by blockin; it would be the center of the
984 *next* block */
985 if(v->centerW==n1){
986 /* the data buffer wraps; swap the halves */
987 /* slow, sure, small */
988 for(j=0;j<vi->channels;j++){
989 float *p=v->pcm[j];
990 for(i=0;i<n1;i++){
991 float temp=p[i];
992 p[i]=p[i+n1];
993 p[i+n1]=temp;
994 }
995 }
997 v->pcm_current-=n1;
998 v->pcm_returned-=n1;
999 v->centerW=0;
1000 }
1002 /* solidify buffer into contiguous space */
1003 if((v->lW^v->W)==1){
1004 /* long/short or short/long */
1005 for(j=0;j<vi->channels;j++){
1006 float *s=v->pcm[j];
1007 float *d=v->pcm[j]+(n1-n0)/2;
1008 for(i=(n1+n0)/2-1;i>=0;--i)
1009 d[i]=s[i];
1010 }
1011 v->pcm_returned+=(n1-n0)/2;
1012 v->pcm_current+=(n1-n0)/2;
1013 }else{
1014 if(v->lW==0){
1015 /* short/short */
1016 for(j=0;j<vi->channels;j++){
1017 float *s=v->pcm[j];
1018 float *d=v->pcm[j]+n1-n0;
1019 for(i=n0-1;i>=0;--i)
1020 d[i]=s[i];
1021 }
1022 v->pcm_returned+=n1-n0;
1023 v->pcm_current+=n1-n0;
1024 }
1025 }
1027 if(pcm){
1028 int i;
1029 for(i=0;i<vi->channels;i++)
1030 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
1031 *pcm=v->pcmret;
1032 }
1034 return(n1+n-v->pcm_returned);
1036 }
1038 float *vorbis_window(vorbis_dsp_state *v,int W){
1039 vorbis_info *vi=v->vi;
1040 codec_setup_info *ci=vi->codec_setup;
1041 int hs=ci->halfrate_flag;
1042 private_state *b=v->backend_state;
1044 if(b->window[W]-1<0)return NULL;
1045 return _vorbis_window_get(b->window[W]-hs);
1046 }