zenilib: zenilib/jni/external/libvorbis/lib/block.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
block.c
Go to the documentation of this file.
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 ********************************************************************
12
13 function: PCM data vector blocking, windowing and dis/reassembly
14 last mod: $Id: block.c 17561 2010-10-23 10:34:24Z xiphmont $
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
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
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
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 */
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
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
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 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 */
295 int 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
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;
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
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;
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
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;
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
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;
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 */
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;
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
685 int 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
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 }
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
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;
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 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 }
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 */
937 int 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
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 }
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. */
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;
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
1038 VORBIS_DLL 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 }
mdct.h
vorbis_dsp_state::pcm
float ** pcm
Definition: codec.h:63
vorbis_block::glue_bits
long glue_bits
Definition: codec.h:113
codec_setup_info::residue_param
vorbis_info_residue * residue_param[64]
Definition: codec_internal.h:119
vorbis_lpc_from_data
float vorbis_lpc_from_data(float *data, float *lpci, int n, int m)
Definition: lpc.c:61
_vorbis_block_ripcord
void _vorbis_block_ripcord(vorbis_block *vb)
Definition: block.c:137
PACKETBLOBS
#define PACKETBLOBS
Definition: codec_internal.h:29
private_state::psy_g_look
vorbis_look_psy_global * psy_g_look
Definition: codec_internal.h:72
s
GLdouble s
Definition: glew.h:1376
vorbis_dsp_state::lW
long lW
Definition: codec.h:72
vorbis_dsp_state::pcm_current
int pcm_current
Definition: codec.h:66
vorbis_block::opb
oggpack_buffer opb
Definition: codec.h:91
misc.h
vorbis_dsp_state::granulepos
ogg_int64_t granulepos
Definition: codec.h:77
vorbis_staticbook_destroy
void vorbis_staticbook_destroy(static_codebook *b)
Definition: sharedbook.c:261
g
GLboolean GLboolean g
Definition: glew.h:8736
NULL
#define NULL
Definition: ftobjs.h:61
_residue_P
const vorbis_func_residue *const _residue_P[]
Definition: registry.c:37
codec_setup_info::floor_param
vorbis_info_floor * floor_param[64]
Definition: codec_internal.h:117
codec_setup_info::book_param
static_codebook * book_param[256]
Definition: codec_internal.h:120
vorbis_lpc_predict
void vorbis_lpc_predict(float *coeff, float *prime, int m, float *data, long n)
Definition: lpc.c:133
private_state::header
unsigned char * header
Definition: codec_internal.h:78
_ve_envelope_shift
void _ve_envelope_shift(envelope_lookup *e, long shift)
Definition: envelope.c:356
codec_setup_info::books
int books
Definition: codec_internal.h:110
n
GLclampd n
Definition: glew.h:7287
private_state::modebits
int modebits
Definition: codec_internal.h:68
vorbis_block_init
int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb)
Definition: block.c:88
private_state::window
int window[2]
Definition: codec_internal.h:64
memmove
#define memmove
Definition: SDL_qsort.c:81
_vp_ampmax_decay
float _vp_ampmax_decay(float amp, vorbis_dsp_state *vd)
Definition: psy.c:830
mdct_init
void mdct_init(mdct_lookup *lookup, int n)
Definition: mdct.c:52
_vds_shared_init
static int _vds_shared_init(vorbis_dsp_state *v, vorbis_info *vi, int encp)
Definition: block.c:181
vorbis_block::vd
vorbis_dsp_state * vd
Definition: codec.h:102
private_state::psy
vorbis_look_psy * psy
Definition: codec_internal.h:71
j
int32_t j
Definition: e_log.c:102
OV_EINVAL
#define OV_EINVAL
Definition: codec.h:229
memset
#define memset
Definition: SDL_malloc.c:633
BLOCKTYPE_TRANSITION
#define BLOCKTYPE_TRANSITION
Definition: codec_internal.h:26
private_state::sample_count
ogg_int64_t sample_count
Definition: codec_internal.h:84
_ogg_free
#define _ogg_free
Definition: os_types.h:25
codec.h
vorbis_analysis_buffer
float ** vorbis_analysis_buffer(vorbis_dsp_state *v, int vals)
Definition: block.c:389
vorbis_look_psy_global
Definition: psy.h:86
codec_internal.h
vorbis_dsp_state::analysisp
int analysisp
Definition: codec.h:60
private_state::fft_look
drft_lookup fft_look[2]
Definition: codec_internal.h:66
vorbis_synthesis_blockin
int vorbis_synthesis_blockin(vorbis_dsp_state *v, vorbis_block *vb)
Definition: block.c:721
vorbis_block::W
long W
Definition: codec.h:94
vorbis_dsp_state::pcm_storage
int pcm_storage
Definition: codec.h:65
d
return Display return Display Bool Bool int d
Definition: SDL_x11sym.h:30
vorbis_block_internal::ampmax
float ampmax
Definition: codec_internal.h:33
_ve_envelope_mark
int _ve_envelope_mark(vorbis_dsp_state *v)
Definition: envelope.c:330
vorbis_block::lW
long lW
Definition: codec.h:93
_ve_envelope_clear
void _ve_envelope_clear(envelope_lookup *e)
Definition: envelope.c:76
drft_init
void drft_init(drft_lookup *l, int n)
Definition: smallft.c:1242
_ve_envelope_init
void _ve_envelope_init(envelope_lookup *e, vorbis_info *vi)
Definition: envelope.c:32
vorbis_synthesis_read
int vorbis_synthesis_read(vorbis_dsp_state *v, int samples)
Definition: block.c:952
vorbis_dsp_state::nW
long nW
Definition: codec.h:74
_vp_global_look
vorbis_look_psy_global * _vp_global_look(vorbis_info *vi)
Definition: psy.c:36
vorbis_synthesis_pcmout
int vorbis_synthesis_pcmout(vorbis_dsp_state *v, float ***pcm)
Definition: block.c:937
ogg.h
private_state::flr
vorbis_look_floor ** flr
Definition: codec_internal.h:69
_preextrapolate_helper
static void _preextrapolate_helper(vorbis_dsp_state *v)
Definition: block.c:416
ret
ret
Definition: glew_str_glx.c:2
vorbis_dsp_state::vi
vorbis_info * vi
Definition: codec.h:61
vorbis_book_init_decode
int vorbis_book_init_decode(codebook *dest, const static_codebook *source)
Definition: sharedbook.c:313
vorbis_dsp_state::preextrapolate
int preextrapolate
Definition: codec.h:69
private_state::transform
vorbis_look_transform ** transform[2]
Definition: codec_internal.h:65
vorbis_dsp_state::glue_bits
ogg_int64_t glue_bits
Definition: codec.h:80
lpc.h
vorbis_synthesis_init
int vorbis_synthesis_init(vorbis_dsp_state *v, vorbis_info *vi)
Definition: block.c:708
vorbis_block::reap
struct alloc_chain * reap
Definition: codec.h:110
_floor_P
const vorbis_func_floor *const _floor_P[]
Definition: registry.c:32
window.h
vorbis_info::codec_setup
void * codec_setup
Definition: codec.h:53
vorbis_info::channels
int channels
Definition: codec.h:30
vorbis_dsp_state::floor_bits
ogg_int64_t floor_bits
Definition: codec.h:82
codec_setup_info::psy_g_param
vorbis_info_psy_global psy_g_param
Definition: codec_internal.h:124
vorbis_synthesis_lapout
int vorbis_synthesis_lapout(vorbis_dsp_state *v, float ***pcm)
Definition: block.c:963
vorbis_block_internal::blocktype
int blocktype
Definition: codec_internal.h:34
vorbis_analysis_wrote
int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals)
Definition: block.c:460
vorbis_block::pcm
float ** pcm
Definition: codec.h:90
private_state::header2
unsigned char * header2
Definition: codec_internal.h:80
v
const GLdouble * v
Definition: glew.h:1377
vorbis_synthesis_restart
int vorbis_synthesis_restart(vorbis_dsp_state *v)
Definition: block.c:685
_vp_psy_clear
void _vp_psy_clear(vorbis_look_psy *p)
Definition: psy.c:361
codec_setup_info::residue_type
int residue_type[64]
Definition: codec_internal.h:118
private_state::bms
bitrate_manager_state bms
Definition: codec_internal.h:82
BLOCKTYPE_IMPULSE
#define BLOCKTYPE_IMPULSE
Definition: codec_internal.h:24
BLOCKTYPE_LONG
#define BLOCKTYPE_LONG
Definition: codec_internal.h:27
_vp_psy_init
void _vp_psy_init(vorbis_look_psy *p, vorbis_info_psy *vi, vorbis_info_psy_global *gi, int n, long rate)
Definition: psy.c:267
vorbis_window
float * vorbis_window(vorbis_dsp_state *v, int W)
Definition: block.c:1038
vorbis_dsp_clear
void vorbis_dsp_clear(vorbis_dsp_state *v)
Definition: block.c:315
vorbis_info_psy::blockflag
int blockflag
Definition: psy.h:37
codec_setup_info::psys
int psys
Definition: codec_internal.h:111
vorbis_analysis_init
int vorbis_analysis_init(vorbis_dsp_state *v, vorbis_info *vi)
Definition: block.c:295
codec_setup_info::blocksizes
long blocksizes[2]
Definition: codec_internal.h:99
vorbis_block_internal::packetblob
oggpack_buffer * packetblob[PACKETBLOBS]
Definition: codec_internal.h:36
p
GLfloat GLfloat p
Definition: glew.h:14938
codec_setup_info::modes
int modes
Definition: codec_internal.h:106
vorbis_dsp_state::centerW
long centerW
Definition: codec.h:75
vorbis_block_internal
Definition: codec_internal.h:31
VI_TRANSFORMB
#define VI_TRANSFORMB
Definition: registry.h:21
ilog2
static int ilog2(unsigned int v)
Definition: block.c:34
vorbis_block::pcmend
int pcmend
Definition: codec.h:96
vorbis_block::totaluse
long totaluse
Definition: codec.h:109
vorbis_block::floor_bits
long floor_bits
Definition: codec.h:115
vorbis_bitrate_init
void vorbis_bitrate_init(vorbis_info *vi, bitrate_manager_state *bm)
Definition: bitrate.c:29
BLOCKTYPE_PADDING
#define BLOCKTYPE_PADDING
Definition: codec_internal.h:25
oggpack_buffer
Definition: ogg.h:32
vorbis_block
Definition: codec.h:88
_ogg_realloc
#define _ogg_realloc
Definition: os_types.h:24
bp
static double bp[]
Definition: e_pow.c:72
vorbis_block::nW
long nW
Definition: codec.h:95
vorbis_look_psy_global::ampmax
float ampmax
Definition: psy.h:87
vorbis_block::localtop
long localtop
Definition: codec.h:107
codec_setup_info::halfrate_flag
int halfrate_flag
Definition: codec_internal.h:130
_vorbis_window_get
const float * _vorbis_window_get(int n)
Definition: window.c:2098
vorbis_book_init_encode
int vorbis_book_init_encode(codebook *dest, const static_codebook *source)
Definition: sharedbook.c:283
vi
XVisualInfo * vi
Definition: glewinfo_tail.c:221
alloc_chain::next
struct alloc_chain * next
Definition: codec.h:129
vorbis_block::time_bits
long time_bits
Definition: codec.h:114
vorbis_block::eofflag
int eofflag
Definition: codec.h:99
vorbis_bitrate_clear
void vorbis_bitrate_clear(bitrate_manager_state *bm)
Definition: bitrate.c:59
vorbis_block::localalloc
long localalloc
Definition: codec.h:108
private_state::residue
vorbis_look_residue ** residue
Definition: codec_internal.h:70
drft_clear
void drft_clear(drft_lookup *l)
Definition: smallft.c:1249
private_state::ve
envelope_lookup * ve
Definition: codec_internal.h:63
vorbis_info::rate
long rate
Definition: codec.h:31
memcpy
#define memcpy
Definition: SDL_malloc.c:634
vorbis_block::granulepos
ogg_int64_t granulepos
Definition: codec.h:100
vorbis_block_internal::pcmdelay
float ** pcmdelay
Definition: codec_internal.h:32
vorbis_dsp_state::W
long W
Definition: codec.h:73
oggpack_writeinit
void oggpack_writeinit(oggpack_buffer *b)
Definition: bitwise.c:40
alloc_chain::ptr
void * ptr
Definition: codec.h:128
_ogg_calloc
#define _ogg_calloc
Definition: os_types.h:23
codec_setup_info
Definition: codec_internal.h:94
String.h
vorbis_dsp_state::pcmret
float ** pcmret
Definition: codec.h:64
alloc_chain
Definition: codec.h:127
b
GLdouble GLdouble GLdouble b
Definition: glew.h:8383
mdct_clear
void mdct_clear(mdct_lookup *l)
Definition: mdct.c:339
order
GLuint GLdouble GLdouble GLint GLint order
Definition: glew.h:3337
vorbis_dsp_state::sequence
ogg_int64_t sequence
Definition: codec.h:78
w
GLint GLint GLint GLint GLint w
Definition: gl2ext.h:1215
codec_setup_info::fullbooks
codebook * fullbooks
Definition: codec_internal.h:121
_ve_envelope_search
long _ve_envelope_search(vorbis_dsp_state *v)
Definition: envelope.c:216
codec_setup_info::floor_type
int floor_type[64]
Definition: codec_internal.h:116
vorbis_block::res_bits
long res_bits
Definition: codec.h:116
vorbis_dsp_state::time_bits
ogg_int64_t time_bits
Definition: codec.h:81
WORD_ALIGN
#define WORD_ALIGN
Definition: block.c:85
vorbis_analysis_blockout
int vorbis_analysis_blockout(vorbis_dsp_state *v, vorbis_block *vb)
Definition: block.c:524
codec_setup_info::psy_param
vorbis_info_psy * psy_param[4]
Definition: codec_internal.h:123
vorbis_dsp_state::res_bits
ogg_int64_t res_bits
Definition: codec.h:83
vorbis_dsp_state::eofflag
int eofflag
Definition: codec.h:70
i
int i
Definition: pngrutil.c:1377
private_state::header1
unsigned char * header1
Definition: codec_internal.h:79
mdct_lookup
Definition: mdct.h:56
_vp_global_free
void _vp_global_free(vorbis_look_psy_global *look)
Definition: psy.c:48
oggpack_writeclear
void oggpack_writeclear(oggpack_buffer *b)
Definition: bitwise.c:246
private_state
Definition: codec_internal.h:61
vorbis_block::internal
void * internal
Definition: codec.h:118
vorbis_block::localstore
void * localstore
Definition: codec.h:106
vorbis_block::sequence
ogg_int64_t sequence
Definition: codec.h:101
vorbis_dsp_state::pcm_returned
int pcm_returned
Definition: codec.h:67
vorbis_dsp_state::backend_state
void * backend_state
Definition: codec.h:85
_vorbis_block_alloc
void * _vorbis_block_alloc(vorbis_block *vb, long bytes)
Definition: block.c:113
codec_setup_info::residues
int residues
Definition: codec_internal.h:109
registry.h
vorbis_block_clear
int vorbis_block_clear(vorbis_block *vb)
Definition: block.c:159
vorbis_info
Definition: codec.h:28
codec_setup_info::floors
int floors
Definition: codec_internal.h:108
_ogg_malloc
#define _ogg_malloc
Definition: os_types.h:22
vorbis_dsp_state
Definition: codec.h:59