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-2015 *
9 * by the Xiph.Org Foundation https://xiph.org/ *
10 * *
11 ********************************************************************
12
13 function: PCM data vector blocking, windowing and dis/reassembly
14
15 Handle windowing, overlap-add, etc of the PCM vectors. This is made
16 more amusing by Vorbis' current two allowed block sizes.
17
18 ********************************************************************/
19
20#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23#include <ogg/ogg.h>
24#include "vorbis/codec.h"
25#include "codec_internal.h"
26
27#include "window.h"
28#include "mdct.h"
29#include "lpc.h"
30#include "registry.h"
31#include "misc.h"
32
33/* pcm accumulator examples (not exhaustive):
34
35 <-------------- lW ---------------->
36 <--------------- W ---------------->
37: .....|..... _______________ |
38: .''' | '''_--- | |\ |
39:.....''' |_____--- '''......| | \_______|
40:.................|__________________|_______|__|______|
41 |<------ Sl ------>| > Sr < |endW
42 |beginSl |endSl | |endSr
43 |beginW |endlW |beginSr
44
45
46 |< lW >|
47 <--------------- W ---------------->
48 | | .. ______________ |
49 | | ' `/ | ---_ |
50 |___.'___/`. | ---_____|
51 |_______|__|_______|_________________|
52 | >|Sl|< |<------ Sr ----->|endW
53 | | |endSl |beginSr |endSr
54 |beginW | |endlW
55 mult[0] |beginSl mult[n]
56
57 <-------------- lW ----------------->
58 |<--W-->|
59: .............. ___ | |
60: .''' |`/ \ | |
61:.....''' |/`....\|...|
62:.........................|___|___|___|
63 |Sl |Sr |endW
64 | | |endSr
65 | |beginSr
66 | |endSl
67 |beginSl
68 |beginW
69*/
70
71/* block abstraction setup *********************************************/
72
73#ifndef WORD_ALIGN
74#define WORD_ALIGN 8
75#endif
76
77int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
78 int i;
79 memset(vb,0,sizeof(*vb));
80 vb->vd=v;
81 vb->localalloc=0;
82 vb->localstore=NULL;
83 if(v->analysisp){
84 vorbis_block_internal *vbi=
85 vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
86 vbi->ampmax=-9999;
87
88 for(i=0;i<PACKETBLOBS;i++){
89 if(i==PACKETBLOBS/2){
90 vbi->packetblob[i]=&vb->opb;
91 }else{
92 vbi->packetblob[i]=
93 _ogg_calloc(1,sizeof(oggpack_buffer));
94 }
95 oggpack_writeinit(vbi->packetblob[i]);
96 }
97 }
98
99 return(0);
100}
101
102void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
103 bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
104 if(bytes+vb->localtop>vb->localalloc){
105 /* can't just _ogg_realloc... there are outstanding pointers */
106 if(vb->localstore){
107 struct alloc_chain *link=_ogg_malloc(sizeof(*link));
108 vb->totaluse+=vb->localtop;
109 link->next=vb->reap;
110 link->ptr=vb->localstore;
111 vb->reap=link;
112 }
113 /* highly conservative */
114 vb->localalloc=bytes;
115 vb->localstore=_ogg_malloc(vb->localalloc);
116 vb->localtop=0;
117 }
118 {
119 void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
120 vb->localtop+=bytes;
121 return ret;
122 }
123}
124
125/* reap the chain, pull the ripcord */
126void _vorbis_block_ripcord(vorbis_block *vb){
127 /* reap the chain */
128 struct alloc_chain *reap=vb->reap;
129 while(reap){
130 struct alloc_chain *next=reap->next;
131 _ogg_free(reap->ptr);
132 memset(reap,0,sizeof(*reap));
133 _ogg_free(reap);
134 reap=next;
135 }
136 /* consolidate storage */
137 if(vb->totaluse){
138 vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
139 vb->localalloc+=vb->totaluse;
140 vb->totaluse=0;
141 }
142
143 /* pull the ripcord */
144 vb->localtop=0;
145 vb->reap=NULL;
146}
147
148int vorbis_block_clear(vorbis_block *vb){
149 int i;
150 vorbis_block_internal *vbi=vb->internal;
151
152 _vorbis_block_ripcord(vb);
153 if(vb->localstore)_ogg_free(vb->localstore);
154
155 if(vbi){
156 for(i=0;i<PACKETBLOBS;i++){
157 oggpack_writeclear(vbi->packetblob[i]);
158 if(i!=PACKETBLOBS/2)_ogg_free(vbi->packetblob[i]);
159 }
160 _ogg_free(vbi);
161 }
162 memset(vb,0,sizeof(*vb));
163 return(0);
164}
165
166/* Analysis side code, but directly related to blocking. Thus it's
167 here and not in analysis.c (which is for analysis transforms only).
168 The init is here because some of it is shared */
169
170static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
171 int i;
172 codec_setup_info *ci=vi->codec_setup;
173 private_state *b=NULL;
174 int hs;
175
176 if(ci==NULL||
177 ci->modes<=0||
178 ci->blocksizes[0]<64||
179 ci->blocksizes[1]<ci->blocksizes[0]){
180 return 1;
181 }
182 hs=ci->halfrate_flag;
183
184 memset(v,0,sizeof(*v));
185 b=v->backend_state=_ogg_calloc(1,sizeof(*b));
186
187 v->vi=vi;
188 b->modebits=ov_ilog(ci->modes-1);
189
190 b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
191 b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
192
193 /* MDCT is tranform 0 */
194
195 b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
196 b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
197 mdct_init(b->transform[0][0],ci->blocksizes[0]>>hs);
198 mdct_init(b->transform[1][0],ci->blocksizes[1]>>hs);
199
200 /* Vorbis I uses only window type 0 */
201 /* note that the correct computation below is technically:
202 b->window[0]=ov_ilog(ci->blocksizes[0]-1)-6;
203 b->window[1]=ov_ilog(ci->blocksizes[1]-1)-6;
204 but since blocksizes are always powers of two,
205 the below is equivalent.
206 */
207 b->window[0]=ov_ilog(ci->blocksizes[0])-7;
208 b->window[1]=ov_ilog(ci->blocksizes[1])-7;
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 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 }
248
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 }
259
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 */
264
265 /* all vector indexes */
266 v->centerW=ci->blocksizes[1]/2;
267
268 v->pcm_current=v->centerW;
269
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));
273
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]);
277
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]);
281
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}
293
294/* arbitrary settings and spec-mandated numbers get filled in here */
295int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
296 private_state *b=NULL;
297
298 if(_vds_shared_init(v,vi,1))return 1;
299 b=v->backend_state;
300 b->psy_g_look=_vp_global_look(vi);
301
302 /* Initialize the envelope state storage */
303 b->ve=_ogg_calloc(1,sizeof(*b->ve));
304 _ve_envelope_init(b->ve,vi);
305
306 vorbis_bitrate_init(vi,&b->bms);
307
308 /* compressed audio packets start after the headers
309 with sequence number 3 */
310 v->sequence=3;
311
312 return(0);
313}
314
315void 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;
321
322 if(b){
323
324 if(b->ve){
325 _ve_envelope_clear(b->ve);
326 _ogg_free(b->ve);
327 }
328
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 }
339
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 }
360
361 if(b->psy_g_look)_vp_global_free(b->psy_g_look);
362 vorbis_bitrate_clear(&b->bms);
363
364 drft_clear(&b->fft_look[0]);
365 drft_clear(&b->fft_look[1]);
366
367 }
368
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 }
376
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 }
384
385 memset(v,0,sizeof(*v));
386 }
387}
388
389float **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;
393
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;
398
399 /* Do we have enough storage space for the requested buffer? If not,
400 expand the PCM (and envelope) storage */
401
402 if(v->pcm_current+vals>=v->pcm_storage){
403 v->pcm_storage=v->pcm_current+vals*2;
404
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 }
409
410 for(i=0;i<vi->channels;i++)
411 v->pcmret[i]=v->pcm[i]+v->pcm_current;
412
413 return(v->pcmret);
414}
415
416static 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;
423
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];
429
430 /* prime as above */
431 vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
432
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
443
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);
449
450 for(j=0;j<v->pcm_current;j++)
451 v->pcm[i][v->pcm_current-j-1]=work[j];
452
453 }
454 }
455}
456
457
458/* call with val<=0 to set eof */
459
460int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
461 vorbis_info *vi=v->vi;
462 codec_setup_info *ci=vi->codec_setup;
463
464 if(vals<=0){
465 int order=32;
466 int i;
467 float *lpc=alloca(order*sizeof(*lpc));
468
469 /* if it wasn't done earlier (very short sample) */
470 if(!v->preextrapolate)
471 _preextrapolate_helper(v);
472
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. */
478
479 vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
480 v->eofflag=v->pcm_current;
481 v->pcm_current+=ci->blocksizes[1]*3;
482
483 for(i=0;i<vi->channels;i++){
484 if(v->eofflag>order*2){
485 /* extrapolate with LPC to fill in */
486 long n;
487
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);
492
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]));
502
503 }
504 }
505 }else{
506
507 if(v->pcm_current+vals>v->pcm_storage)
508 return(OV_EINVAL);
509
510 v->pcm_current+=vals;
511
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);
517
518 }
519 return(0);
520}
521
522/* do the deltas, envelope shaping, pre-echo and determine the size of
523 the next block on which to continue analysis */
524int 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;
532
533 /* check to see if we're started... */
534 if(!v->preextrapolate)return(0);
535
536 /* check to see if we're done... */
537 if(v->eofflag==-1)return(0);
538
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 */
542
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){
549
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{
554
555 if(ci->blocksizes[0]==ci->blocksizes[1])
556 v->nW=0;
557 else
558 v->nW=bp;
559 }
560 }
561
562 centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
563
564 {
565 /* center of next block + next block maximum right side. */
566
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 */
575
576
577 }
578
579 /* fill in the block. Note that for a short window, lW and nW are *short*
580 regardless of actual settings in the stream */
581
582 _vorbis_block_ripcord(vb);
583 vb->lW=v->lW;
584 vb->W=v->W;
585 vb->nW=v->nW;
586
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,"|");*/
599
600 }else{
601 vbi->blocktype=BLOCKTYPE_PADDING;
602 /*fprintf(stderr,".");*/
603
604 }
605 }
606
607 vb->vd=v;
608 vb->sequence=v->sequence++;
609 vb->granulepos=v->granulepos;
610 vb->pcmend=ci->blocksizes[v->W];
611
612 /* copy the vectors; this uses the local storage in vb */
613
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;
619
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;
627
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 */
632
633 }
634
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 */
638
639 if(v->eofflag){
640 if(v->centerW>=v->eofflag){
641 v->eofflag=-1;
642 vb->eofflag=1;
643 return(1);
644 }
645 }
646
647 /* advance storage vectors and clean up */
648 {
649 int new_centerNext=ci->blocksizes[1]/2;
650 int movementW=centerNext-new_centerNext;
651
652 if(movementW>0){
653
654 _ve_envelope_shift(b->ve,movementW);
655 v->pcm_current-=movementW;
656
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]));
660
661
662 v->lW=v->W;
663 v->W=v->nW;
664 v->centerW=new_centerNext;
665
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 }
680
681 /* done */
682 return(1);
683}
684
685int vorbis_synthesis_restart(vorbis_dsp_state *v){
686 vorbis_info *vi=v->vi;
687 codec_setup_info *ci;
688 int hs;
689
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;
695
696 v->centerW=ci->blocksizes[1]>>(hs+1);
697 v->pcm_current=v->centerW>>hs;
698
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;
704
705 return(0);
706}
707
708int 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}
716
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). */
720
721int 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;
727
728 if(!vb)return(OV_EINVAL);
729 if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
730
731 v->lW=v->W;
732 v->W=vb->W;
733 v->nW=-1;
734
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 }
740
741 v->sequence=vb->sequence;
742
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);
748
749 int thisCenter;
750 int prevCenter;
751
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;
756
757 if(v->centerW){
758 thisCenter=n1;
759 prevCenter=0;
760 }else{
761 thisCenter=0;
762 prevCenter=n1;
763 }
764
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 */
768
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 const 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 const 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 const 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 const 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 }
806
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 }
815
816 if(v->centerW)
817 v->centerW=0;
818 else
819 v->centerW=n1;
820
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 */
824
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 }
834
835 }
836
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.
841
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 */
847
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 }
853
854 if(v->granulepos==-1){
855 if(vb->granulepos!=-1){ /* only set if we have a position to set to */
856
857 v->granulepos=vb->granulepos;
858
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;
864
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;
871
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 */
878
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;
884
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 }
892
893 }
894
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){
899
900 if(v->granulepos>vb->granulepos){
901 long extra=v->granulepos-vb->granulepos;
902
903 if(extra)
904 if(vb->eofflag){
905 /* partial last frame. Strip the extra samples off */
906
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;
912
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;
919
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 }
928
929 /* Update, cleanup */
930
931 if(vb->eofflag)v->eofflag=1;
932 return(0);
933
934}
935
936/* pcm==NULL indicates we just want the pending samples, no more */
937int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
938 vorbis_info *vi=v->vi;
939
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}
951
952int 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}
957
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. */
963int 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;
967
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;
972
973 if(v->pcm_returned<0)return 0;
974
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. */
982
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 }
996
997 v->pcm_current-=n1;
998 v->pcm_returned-=n1;
999 v->centerW=0;
1000 }
1001
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 }
1026
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 }
1033
1034 return(n1+n-v->pcm_returned);
1035
1036}
1037
1038const 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;
1043
1044 if(b->window[W]-1<0)return NULL;
1045 return _vorbis_window_get(b->window[W]-hs);
1046}
1047