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-2003 *
9 * by the XIPHOPHORUS Company http://www.xiph.org/ *
10 * *
11 ********************************************************************
12
13 function: PCM data vector blocking, windowing and dis/reassembly
14 last mod: $Id: block.c 9513 2005-06-26 18:36:49Z giles $
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 vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]);
239 /* decode codebooks are now standalone after init */
240 vorbis_staticbook_destroy(ci->book_param[i]);
241 ci->book_param[i]=NULL;
242 }
243 }
244 }
245
246 /* initialize the storage vectors. blocksize[1] is small for encode,
247 but the correct size for decode */
248 v->pcm_storage=ci->blocksizes[1];
249 v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
250 v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
251 {
252 int i;
253 for(i=0;i<vi->channels;i++)
254 v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
255 }
256
257 /* all 1 (large block) or 0 (small block) */
258 /* explicitly set for the sake of clarity */
259 v->lW=0; /* previous window size */
260 v->W=0; /* current window size */
261
262 /* all vector indexes */
263 v->centerW=ci->blocksizes[1]/2;
264
265 v->pcm_current=v->centerW;
266
267 /* initialize all the backend lookups */
268 b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
269 b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
270
271 for(i=0;i<ci->floors;i++)
272 b->flr[i]=_floor_P[ci->floor_type[i]]->
273 look(v,ci->floor_param[i]);
274
275 for(i=0;i<ci->residues;i++)
276 b->residue[i]=_residue_P[ci->residue_type[i]]->
277 look(v,ci->residue_param[i]);
278
279 return 0;
280 }
281
282 /* arbitrary settings and spec-mandated numbers get filled in here */
vorbis_analysis_init(vorbis_dsp_state * v,vorbis_info * vi)283 int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
284 private_state *b=NULL;
285
286 if(_vds_shared_init(v,vi,1))return 1;
287 b=v->backend_state;
288 b->psy_g_look=_vp_global_look(vi);
289
290 /* Initialize the envelope state storage */
291 b->ve=_ogg_calloc(1,sizeof(*b->ve));
292 _ve_envelope_init(b->ve,vi);
293
294 vorbis_bitrate_init(vi,&b->bms);
295
296 /* compressed audio packets start after the headers
297 with sequence number 3 */
298 v->sequence=3;
299
300 return(0);
301 }
302
vorbis_dsp_clear(vorbis_dsp_state * v)303 void vorbis_dsp_clear(vorbis_dsp_state *v){
304 int i;
305 if(v){
306 vorbis_info *vi=v->vi;
307 codec_setup_info *ci=(vi?vi->codec_setup:NULL);
308 private_state *b=v->backend_state;
309
310 if(b){
311
312 if(b->ve){
313 _ve_envelope_clear(b->ve);
314 _ogg_free(b->ve);
315 }
316
317 if(b->transform[0]){
318 mdct_clear(b->transform[0][0]);
319 _ogg_free(b->transform[0][0]);
320 _ogg_free(b->transform[0]);
321 }
322 if(b->transform[1]){
323 mdct_clear(b->transform[1][0]);
324 _ogg_free(b->transform[1][0]);
325 _ogg_free(b->transform[1]);
326 }
327
328 if(b->flr){
329 for(i=0;i<ci->floors;i++)
330 _floor_P[ci->floor_type[i]]->
331 free_look(b->flr[i]);
332 _ogg_free(b->flr);
333 }
334 if(b->residue){
335 for(i=0;i<ci->residues;i++)
336 _residue_P[ci->residue_type[i]]->
337 free_look(b->residue[i]);
338 _ogg_free(b->residue);
339 }
340 if(b->psy){
341 for(i=0;i<ci->psys;i++)
342 _vp_psy_clear(b->psy+i);
343 _ogg_free(b->psy);
344 }
345
346 if(b->psy_g_look)_vp_global_free(b->psy_g_look);
347 vorbis_bitrate_clear(&b->bms);
348
349 drft_clear(&b->fft_look[0]);
350 drft_clear(&b->fft_look[1]);
351
352 }
353
354 if(v->pcm){
355 for(i=0;i<vi->channels;i++)
356 if(v->pcm[i])_ogg_free(v->pcm[i]);
357 _ogg_free(v->pcm);
358 if(v->pcmret)_ogg_free(v->pcmret);
359 }
360
361 if(b){
362 /* free header, header1, header2 */
363 if(b->header)_ogg_free(b->header);
364 if(b->header1)_ogg_free(b->header1);
365 if(b->header2)_ogg_free(b->header2);
366 _ogg_free(b);
367 }
368
369 memset(v,0,sizeof(*v));
370 }
371 }
372
vorbis_analysis_buffer(vorbis_dsp_state * v,int vals)373 float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
374 int i;
375 vorbis_info *vi=v->vi;
376 private_state *b=v->backend_state;
377
378 /* free header, header1, header2 */
379 if(b->header)_ogg_free(b->header);b->header=NULL;
380 if(b->header1)_ogg_free(b->header1);b->header1=NULL;
381 if(b->header2)_ogg_free(b->header2);b->header2=NULL;
382
383 /* Do we have enough storage space for the requested buffer? If not,
384 expand the PCM (and envelope) storage */
385
386 if(v->pcm_current+vals>=v->pcm_storage){
387 v->pcm_storage=v->pcm_current+vals*2;
388
389 for(i=0;i<vi->channels;i++){
390 v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
391 }
392 }
393
394 for(i=0;i<vi->channels;i++)
395 v->pcmret[i]=v->pcm[i]+v->pcm_current;
396
397 return(v->pcmret);
398 }
399
_preextrapolate_helper(vorbis_dsp_state * v)400 static void _preextrapolate_helper(vorbis_dsp_state *v){
401 int i;
402 int order=32;
403 float *lpc=alloca(order*sizeof(*lpc));
404 float *work=alloca(v->pcm_current*sizeof(*work));
405 long j;
406 v->preextrapolate=1;
407
408 if(v->pcm_current-v->centerW>order*2){ /* safety */
409 for(i=0;i<v->vi->channels;i++){
410 /* need to run the extrapolation in reverse! */
411 for(j=0;j<v->pcm_current;j++)
412 work[j]=v->pcm[i][v->pcm_current-j-1];
413
414 /* prime as above */
415 vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
416
417 /* run the predictor filter */
418 vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
419 order,
420 work+v->pcm_current-v->centerW,
421 v->centerW);
422
423 for(j=0;j<v->pcm_current;j++)
424 v->pcm[i][v->pcm_current-j-1]=work[j];
425
426 }
427 }
428 }
429
430
431 /* call with val<=0 to set eof */
432
vorbis_analysis_wrote(vorbis_dsp_state * v,int vals)433 int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
434 vorbis_info *vi=v->vi;
435 codec_setup_info *ci=vi->codec_setup;
436
437 if(vals<=0){
438 int order=32;
439 int i;
440 float *lpc=alloca(order*sizeof(*lpc));
441
442 /* if it wasn't done earlier (very short sample) */
443 if(!v->preextrapolate)
444 _preextrapolate_helper(v);
445
446 /* We're encoding the end of the stream. Just make sure we have
447 [at least] a few full blocks of zeroes at the end. */
448 /* actually, we don't want zeroes; that could drop a large
449 amplitude off a cliff, creating spread spectrum noise that will
450 suck to encode. Extrapolate for the sake of cleanliness. */
451
452 vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
453 v->eofflag=v->pcm_current;
454 v->pcm_current+=ci->blocksizes[1]*3;
455
456 for(i=0;i<vi->channels;i++){
457 if(v->eofflag>order*2){
458 /* extrapolate with LPC to fill in */
459 long n;
460
461 /* make a predictor filter */
462 n=v->eofflag;
463 if(n>ci->blocksizes[1])n=ci->blocksizes[1];
464 vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
465
466 /* run the predictor filter */
467 vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
468 v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
469 }else{
470 /* not enough data to extrapolate (unlikely to happen due to
471 guarding the overlap, but bulletproof in case that
472 assumtion goes away). zeroes will do. */
473 memset(v->pcm[i]+v->eofflag,0,
474 (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
475
476 }
477 }
478 }else{
479
480 if(v->pcm_current+vals>v->pcm_storage)
481 return(OV_EINVAL);
482
483 v->pcm_current+=vals;
484
485 /* we may want to reverse extrapolate the beginning of a stream
486 too... in case we're beginning on a cliff! */
487 /* clumsy, but simple. It only runs once, so simple is good. */
488 if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
489 _preextrapolate_helper(v);
490
491 }
492 return(0);
493 }
494
495 /* do the deltas, envelope shaping, pre-echo and determine the size of
496 the next block on which to continue analysis */
vorbis_analysis_blockout(vorbis_dsp_state * v,vorbis_block * vb)497 int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
498 int i;
499 vorbis_info *vi=v->vi;
500 codec_setup_info *ci=vi->codec_setup;
501 private_state *b=v->backend_state;
502 vorbis_look_psy_global *g=b->psy_g_look;
503 long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
504 vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
505
506 /* check to see if we're started... */
507 if(!v->preextrapolate)return(0);
508
509 /* check to see if we're done... */
510 if(v->eofflag==-1)return(0);
511
512 /* By our invariant, we have lW, W and centerW set. Search for
513 the next boundary so we can determine nW (the next window size)
514 which lets us compute the shape of the current block's window */
515
516 /* we do an envelope search even on a single blocksize; we may still
517 be throwing more bits at impulses, and envelope search handles
518 marking impulses too. */
519 {
520 long bp=_ve_envelope_search(v);
521 if(bp==-1){
522
523 if(v->eofflag==0)return(0); /* not enough data currently to search for a
524 full long block */
525 v->nW=0;
526 }else{
527
528 if(ci->blocksizes[0]==ci->blocksizes[1])
529 v->nW=0;
530 else
531 v->nW=bp;
532 }
533 }
534
535 centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
536
537 {
538 /* center of next block + next block maximum right side. */
539
540 long blockbound=centerNext+ci->blocksizes[v->nW]/2;
541 if(v->pcm_current<blockbound)return(0); /* not enough data yet;
542 although this check is
543 less strict that the
544 _ve_envelope_search,
545 the search is not run
546 if we only use one
547 block size */
548
549
550 }
551
552 /* fill in the block. Note that for a short window, lW and nW are *short*
553 regardless of actual settings in the stream */
554
555 _vorbis_block_ripcord(vb);
556 vb->lW=v->lW;
557 vb->W=v->W;
558 vb->nW=v->nW;
559
560 if(v->W){
561 if(!v->lW || !v->nW){
562 vbi->blocktype=BLOCKTYPE_TRANSITION;
563 /*fprintf(stderr,"-");*/
564 }else{
565 vbi->blocktype=BLOCKTYPE_LONG;
566 /*fprintf(stderr,"_");*/
567 }
568 }else{
569 if(_ve_envelope_mark(v)){
570 vbi->blocktype=BLOCKTYPE_IMPULSE;
571 /*fprintf(stderr,"|");*/
572
573 }else{
574 vbi->blocktype=BLOCKTYPE_PADDING;
575 /*fprintf(stderr,".");*/
576
577 }
578 }
579
580 vb->vd=v;
581 vb->sequence=v->sequence++;
582 vb->granulepos=v->granulepos;
583 vb->pcmend=ci->blocksizes[v->W];
584
585 /* copy the vectors; this uses the local storage in vb */
586
587 /* this tracks 'strongest peak' for later psychoacoustics */
588 /* moved to the global psy state; clean this mess up */
589 if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
590 g->ampmax=_vp_ampmax_decay(g->ampmax,v);
591 vbi->ampmax=g->ampmax;
592
593 vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
594 vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
595 for(i=0;i<vi->channels;i++){
596 vbi->pcmdelay[i]=
597 _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
598 memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
599 vb->pcm[i]=vbi->pcmdelay[i]+beginW;
600
601 /* before we added the delay
602 vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
603 memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
604 */
605
606 }
607
608 /* handle eof detection: eof==0 means that we've not yet received EOF
609 eof>0 marks the last 'real' sample in pcm[]
610 eof<0 'no more to do'; doesn't get here */
611
612 if(v->eofflag){
613 if(v->centerW>=v->eofflag){
614 v->eofflag=-1;
615 vb->eofflag=1;
616 return(1);
617 }
618 }
619
620 /* advance storage vectors and clean up */
621 {
622 int new_centerNext=ci->blocksizes[1]/2;
623 int movementW=centerNext-new_centerNext;
624
625 if(movementW>0){
626
627 _ve_envelope_shift(b->ve,movementW);
628 v->pcm_current-=movementW;
629
630 for(i=0;i<vi->channels;i++)
631 memmove(v->pcm[i],v->pcm[i]+movementW,
632 v->pcm_current*sizeof(*v->pcm[i]));
633
634
635 v->lW=v->W;
636 v->W=v->nW;
637 v->centerW=new_centerNext;
638
639 if(v->eofflag){
640 v->eofflag-=movementW;
641 if(v->eofflag<=0)v->eofflag=-1;
642 /* do not add padding to end of stream! */
643 if(v->centerW>=v->eofflag){
644 v->granulepos+=movementW-(v->centerW-v->eofflag);
645 }else{
646 v->granulepos+=movementW;
647 }
648 }else{
649 v->granulepos+=movementW;
650 }
651 }
652 }
653
654 /* done */
655 return(1);
656 }
657
vorbis_synthesis_restart(vorbis_dsp_state * v)658 int vorbis_synthesis_restart(vorbis_dsp_state *v){
659 vorbis_info *vi=v->vi;
660 codec_setup_info *ci;
661 int hs;
662
663 if(!v->backend_state)return -1;
664 if(!vi)return -1;
665 ci=vi->codec_setup;
666 if(!ci)return -1;
667 hs=ci->halfrate_flag;
668
669 v->centerW=ci->blocksizes[1]>>(hs+1);
670 v->pcm_current=v->centerW>>hs;
671
672 v->pcm_returned=-1;
673 v->granulepos=-1;
674 v->sequence=-1;
675 v->eofflag=0;
676 ((private_state *)(v->backend_state))->sample_count=-1;
677
678 return(0);
679 }
680
vorbis_synthesis_init(vorbis_dsp_state * v,vorbis_info * vi)681 int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
682 if(_vds_shared_init(v,vi,0)) return 1;
683 vorbis_synthesis_restart(v);
684
685 return 0;
686 }
687
688 /* Unlike in analysis, the window is only partially applied for each
689 block. The time domain envelope is not yet handled at the point of
690 calling (as it relies on the previous block). */
691
vorbis_synthesis_blockin(vorbis_dsp_state * v,vorbis_block * vb)692 int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
693 vorbis_info *vi=v->vi;
694 codec_setup_info *ci=vi->codec_setup;
695 private_state *b=v->backend_state;
696 int hs=ci->halfrate_flag;
697 int i,j;
698
699 if(!vb)return(OV_EINVAL);
700 if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
701
702 v->lW=v->W;
703 v->W=vb->W;
704 v->nW=-1;
705
706 if((v->sequence==-1)||
707 (v->sequence+1 != vb->sequence)){
708 v->granulepos=-1; /* out of sequence; lose count */
709 b->sample_count=-1;
710 }
711
712 v->sequence=vb->sequence;
713
714 if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
715 was called on block */
716 int n=ci->blocksizes[v->W]>>(hs+1);
717 int n0=ci->blocksizes[0]>>(hs+1);
718 int n1=ci->blocksizes[1]>>(hs+1);
719
720 int thisCenter;
721 int prevCenter;
722
723 v->glue_bits+=vb->glue_bits;
724 v->time_bits+=vb->time_bits;
725 v->floor_bits+=vb->floor_bits;
726 v->res_bits+=vb->res_bits;
727
728 if(v->centerW){
729 thisCenter=n1;
730 prevCenter=0;
731 }else{
732 thisCenter=0;
733 prevCenter=n1;
734 }
735
736 /* v->pcm is now used like a two-stage double buffer. We don't want
737 to have to constantly shift *or* adjust memory usage. Don't
738 accept a new block until the old is shifted out */
739
740 for(j=0;j<vi->channels;j++){
741 /* the overlap/add section */
742 if(v->lW){
743 if(v->W){
744 /* large/large */
745 float *w=_vorbis_window_get(b->window[1]-hs);
746 float *pcm=v->pcm[j]+prevCenter;
747 float *p=vb->pcm[j];
748 for(i=0;i<n1;i++)
749 pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
750 }else{
751 /* large/small */
752 float *w=_vorbis_window_get(b->window[0]-hs);
753 float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
754 float *p=vb->pcm[j];
755 for(i=0;i<n0;i++)
756 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
757 }
758 }else{
759 if(v->W){
760 /* small/large */
761 float *w=_vorbis_window_get(b->window[0]-hs);
762 float *pcm=v->pcm[j]+prevCenter;
763 float *p=vb->pcm[j]+n1/2-n0/2;
764 for(i=0;i<n0;i++)
765 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
766 for(;i<n1/2+n0/2;i++)
767 pcm[i]=p[i];
768 }else{
769 /* small/small */
770 float *w=_vorbis_window_get(b->window[0]-hs);
771 float *pcm=v->pcm[j]+prevCenter;
772 float *p=vb->pcm[j];
773 for(i=0;i<n0;i++)
774 pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
775 }
776 }
777
778 /* the copy section */
779 {
780 float *pcm=v->pcm[j]+thisCenter;
781 float *p=vb->pcm[j]+n;
782 for(i=0;i<n;i++)
783 pcm[i]=p[i];
784 }
785 }
786
787 if(v->centerW)
788 v->centerW=0;
789 else
790 v->centerW=n1;
791
792 /* deal with initial packet state; we do this using the explicit
793 pcm_returned==-1 flag otherwise we're sensitive to first block
794 being short or long */
795
796 if(v->pcm_returned==-1){
797 v->pcm_returned=thisCenter;
798 v->pcm_current=thisCenter;
799 }else{
800 v->pcm_returned=prevCenter;
801 v->pcm_current=prevCenter+
802 ((ci->blocksizes[v->lW]/4+
803 ci->blocksizes[v->W]/4)>>hs);
804 }
805
806 }
807
808 /* track the frame number... This is for convenience, but also
809 making sure our last packet doesn't end with added padding. If
810 the last packet is partial, the number of samples we'll have to
811 return will be past the vb->granulepos.
812
813 This is not foolproof! It will be confused if we begin
814 decoding at the last page after a seek or hole. In that case,
815 we don't have a starting point to judge where the last frame
816 is. For this reason, vorbisfile will always try to make sure
817 it reads the last two marked pages in proper sequence */
818
819 if(b->sample_count==-1){
820 b->sample_count=0;
821 }else{
822 b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
823 }
824
825 if(v->granulepos==-1){
826 if(vb->granulepos!=-1){ /* only set if we have a position to set to */
827
828 v->granulepos=vb->granulepos;
829
830 /* is this a short page? */
831 if(b->sample_count>v->granulepos){
832 /* corner case; if this is both the first and last audio page,
833 then spec says the end is cut, not beginning */
834 if(vb->eofflag){
835 /* trim the end */
836 /* no preceeding granulepos; assume we started at zero (we'd
837 have to in a short single-page stream) */
838 /* granulepos could be -1 due to a seek, but that would result
839 in a long count, not short count */
840
841 v->pcm_current-=(b->sample_count-v->granulepos)>>hs;
842 }else{
843 /* trim the beginning */
844 v->pcm_returned+=(b->sample_count-v->granulepos)>>hs;
845 if(v->pcm_returned>v->pcm_current)
846 v->pcm_returned=v->pcm_current;
847 }
848
849 }
850
851 }
852 }else{
853 v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
854 if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
855
856 if(v->granulepos>vb->granulepos){
857 long extra=v->granulepos-vb->granulepos;
858
859 if(extra)
860 if(vb->eofflag){
861 /* partial last frame. Strip the extra samples off */
862 v->pcm_current-=extra>>hs;
863 } /* else {Shouldn't happen *unless* the bitstream is out of
864 spec. Either way, believe the bitstream } */
865 } /* else {Shouldn't happen *unless* the bitstream is out of
866 spec. Either way, believe the bitstream } */
867 v->granulepos=vb->granulepos;
868 }
869 }
870
871 /* Update, cleanup */
872
873 if(vb->eofflag)v->eofflag=1;
874 return(0);
875
876 }
877
878 /* pcm==NULL indicates we just want the pending samples, no more */
vorbis_synthesis_pcmout(vorbis_dsp_state * v,float *** pcm)879 int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
880 vorbis_info *vi=v->vi;
881
882 if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
883 if(pcm){
884 int i;
885 for(i=0;i<vi->channels;i++)
886 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
887 *pcm=v->pcmret;
888 }
889 return(v->pcm_current-v->pcm_returned);
890 }
891 return(0);
892 }
893
vorbis_synthesis_read(vorbis_dsp_state * v,int n)894 int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
895 if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
896 v->pcm_returned+=n;
897 return(0);
898 }
899
900 /* intended for use with a specific vorbisfile feature; we want access
901 to the [usually synthetic/postextrapolated] buffer and lapping at
902 the end of a decode cycle, specifically, a half-short-block worth.
903 This funtion works like pcmout above, except it will also expose
904 this implicit buffer data not normally decoded. */
vorbis_synthesis_lapout(vorbis_dsp_state * v,float *** pcm)905 int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
906 vorbis_info *vi=v->vi;
907 codec_setup_info *ci=vi->codec_setup;
908 int hs=ci->halfrate_flag;
909
910 int n=ci->blocksizes[v->W]>>(hs+1);
911 int n0=ci->blocksizes[0]>>(hs+1);
912 int n1=ci->blocksizes[1]>>(hs+1);
913 int i,j;
914
915 if(v->pcm_returned<0)return 0;
916
917 /* our returned data ends at pcm_returned; because the synthesis pcm
918 buffer is a two-fragment ring, that means our data block may be
919 fragmented by buffering, wrapping or a short block not filling
920 out a buffer. To simplify things, we unfragment if it's at all
921 possibly needed. Otherwise, we'd need to call lapout more than
922 once as well as hold additional dsp state. Opt for
923 simplicity. */
924
925 /* centerW was advanced by blockin; it would be the center of the
926 *next* block */
927 if(v->centerW==n1){
928 /* the data buffer wraps; swap the halves */
929 /* slow, sure, small */
930 for(j=0;j<vi->channels;j++){
931 float *p=v->pcm[j];
932 for(i=0;i<n1;i++){
933 float temp=p[i];
934 p[i]=p[i+n1];
935 p[i+n1]=temp;
936 }
937 }
938
939 v->pcm_current-=n1;
940 v->pcm_returned-=n1;
941 v->centerW=0;
942 }
943
944 /* solidify buffer into contiguous space */
945 if((v->lW^v->W)==1){
946 /* long/short or short/long */
947 for(j=0;j<vi->channels;j++){
948 float *s=v->pcm[j];
949 float *d=v->pcm[j]+(n1-n0)/2;
950 for(i=(n1+n0)/2-1;i>=0;--i)
951 d[i]=s[i];
952 }
953 v->pcm_returned+=(n1-n0)/2;
954 v->pcm_current+=(n1-n0)/2;
955 }else{
956 if(v->lW==0){
957 /* short/short */
958 for(j=0;j<vi->channels;j++){
959 float *s=v->pcm[j];
960 float *d=v->pcm[j]+n1-n0;
961 for(i=n0-1;i>=0;--i)
962 d[i]=s[i];
963 }
964 v->pcm_returned+=n1-n0;
965 v->pcm_current+=n1-n0;
966 }
967 }
968
969 if(pcm){
970 int i;
971 for(i=0;i<vi->channels;i++)
972 v->pcmret[i]=v->pcm[i]+v->pcm_returned;
973 *pcm=v->pcmret;
974 }
975
976 return(n1+n-v->pcm_returned);
977
978 }
979
vorbis_window(vorbis_dsp_state * v,int W)980 float *vorbis_window(vorbis_dsp_state *v,int W){
981 vorbis_info *vi=v->vi;
982 codec_setup_info *ci=vi->codec_setup;
983 int hs=ci->halfrate_flag;
984 private_state *b=v->backend_state;
985
986 if(b->window[W]-1<0)return NULL;
987 return _vorbis_window_get(b->window[W]-hs);
988 }
989
990