doom3-gpl
Doom 3 GPL source release
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros 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-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,v 1.75 2003/09/02 04:39:26 xiphmont Exp $
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 
89  memset(vb,0,sizeof(*vb));
90  vb->vd=v;
91  vb->localalloc=0;
92  vb->localstore=NULL;
93  if(v->analysisp){
96  oggpack_writeinit(&vb->opb);
97  vbi->ampmax=-9999;
98  }
99 
100  return(0);
101 }
102 
103 void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
104  bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
105  if(bytes+vb->localtop>vb->localalloc){
106  /* can't just _ogg_realloc... there are outstanding pointers */
107  if(vb->localstore){
108  struct alloc_chain *link=_ogg_malloc(sizeof(*link));
109  vb->totaluse+=vb->localtop;
110  link->next=vb->reap;
111  link->ptr=vb->localstore;
112  vb->reap=link;
113  }
114  /* highly conservative */
115  vb->localalloc=bytes;
117  vb->localtop=0;
118  }
119  {
120  void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
121  vb->localtop+=bytes;
122  return ret;
123  }
124 }
125 
126 /* reap the chain, pull the ripcord */
128  /* reap the chain */
129  struct alloc_chain *reap=vb->reap;
130  while(reap){
131  struct alloc_chain *next=reap->next;
132  _ogg_free(reap->ptr);
133  memset(reap,0,sizeof(*reap));
134  _ogg_free(reap);
135  reap=next;
136  }
137  /* consolidate storage */
138  if(vb->totaluse){
140  vb->localalloc+=vb->totaluse;
141  vb->totaluse=0;
142  }
143 
144  /* pull the ripcord */
145  vb->localtop=0;
146  vb->reap=NULL;
147 }
148 
150  if(vb->vd)
151  if(vb->vd->analysisp)
152  oggpack_writeclear(&vb->opb);
154  if(vb->localstore)_ogg_free(vb->localstore);
155 
156  if(vb->internal)
157  _ogg_free(vb->internal);
158 
159  memset(vb,0,sizeof(*vb));
160  return(0);
161 }
162 
163 /* Analysis side code, but directly related to blocking. Thus it's
164  here and not in analysis.c (which is for analysis transforms only).
165  The init is here because some of it is shared */
166 
167 static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
168  int i;
171  int hs;
172 
173  if(ci==NULL) return 1;
174  hs=ci->halfrate_flag;
175 
176  memset(v,0,sizeof(*v));
177  b=v->backend_state=_ogg_calloc(1,sizeof(*b));
178 
179  v->vi=vi;
180  b->modebits=ilog2(ci->modes);
181 
182  b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
183  b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
184 
185  /* MDCT is tranform 0 */
186 
187  b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
188  b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
189  mdct_init(b->transform[0][0],ci->blocksizes[0]>>hs);
190  mdct_init(b->transform[1][0],ci->blocksizes[1]>>hs);
191 
192  /* Vorbis I uses only window type 0 */
193  b->window[0]=ilog2(ci->blocksizes[0])-6;
194  b->window[1]=ilog2(ci->blocksizes[1])-6;
195 
196  if(encp){ /* encode/decode differ here */
197 
198  /* analysis always needs an fft */
199  drft_init(&b->fft_look[0],ci->blocksizes[0]);
200  drft_init(&b->fft_look[1],ci->blocksizes[1]);
201 
202  /* finish the codebooks */
203  if(!ci->fullbooks){
204  ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
205  for(i=0;i<ci->books;i++)
207  }
208 
209  b->psy=_ogg_calloc(ci->psys,sizeof(*b->psy));
210  for(i=0;i<ci->psys;i++){
211  _vp_psy_init(b->psy+i,
212  ci->psy_param[i],
213  &ci->psy_g_param,
214  ci->blocksizes[ci->psy_param[i]->blockflag]/2,
215  vi->rate);
216  }
217 
218  v->analysisp=1;
219  }else{
220  /* finish the codebooks */
221  if(!ci->fullbooks){
222  ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
223  for(i=0;i<ci->books;i++){
225  /* decode codebooks are now standalone after init */
227  ci->book_param[i]=NULL;
228  }
229  }
230  }
231 
232  /* initialize the storage vectors. blocksize[1] is small for encode,
233  but the correct size for decode */
234  v->pcm_storage=ci->blocksizes[1];
235  v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
236  v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
237  {
238  int i;
239  for(i=0;i<vi->channels;i++)
240  v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
241  }
242 
243  /* all 1 (large block) or 0 (small block) */
244  /* explicitly set for the sake of clarity */
245  v->lW=0; /* previous window size */
246  v->W=0; /* current window size */
247 
248  /* all vector indexes */
249  v->centerW=ci->blocksizes[1]/2;
250 
251  v->pcm_current=v->centerW;
252 
253  /* initialize all the backend lookups */
254  b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
255  b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
256 
257  for(i=0;i<ci->floors;i++)
258  b->flr[i]=_floor_P[ci->floor_type[i]]->
259  look(v,ci->floor_param[i]);
260 
261  for(i=0;i<ci->residues;i++)
262  b->residue[i]=_residue_P[ci->residue_type[i]]->
263  look(v,ci->residue_param[i]);
264 
265  return 0;
266 }
267 
268 /* arbitrary settings and spec-mandated numbers get filled in here */
270  private_state *b=NULL;
271 
272  if(_vds_shared_init(v,vi,1))return 1;
273  b=v->backend_state;
275 
276  /* Initialize the envelope state storage */
277  b->ve=_ogg_calloc(1,sizeof(*b->ve));
278  _ve_envelope_init(b->ve,vi);
279 
280  vorbis_bitrate_init(vi,&b->bms);
281 
282  return(0);
283 }
284 
286  int i;
287  if(v){
288  vorbis_info *vi=v->vi;
289  codec_setup_info *ci=(vi?vi->codec_setup:NULL);
291 
292  if(b){
293 
294  if(b->ve){
296  _ogg_free(b->ve);
297  }
298 
299  if(b->transform[0]){
300  mdct_clear(b->transform[0][0]);
301  _ogg_free(b->transform[0][0]);
302  _ogg_free(b->transform[0]);
303  }
304  if(b->transform[1]){
305  mdct_clear(b->transform[1][0]);
306  _ogg_free(b->transform[1][0]);
307  _ogg_free(b->transform[1]);
308  }
309 
310  if(b->flr){
311  for(i=0;i<ci->floors;i++)
312  _floor_P[ci->floor_type[i]]->
313  free_look(b->flr[i]);
314  _ogg_free(b->flr);
315  }
316  if(b->residue){
317  for(i=0;i<ci->residues;i++)
318  _residue_P[ci->residue_type[i]]->
319  free_look(b->residue[i]);
320  _ogg_free(b->residue);
321  }
322  if(b->psy){
323  for(i=0;i<ci->psys;i++)
324  _vp_psy_clear(b->psy+i);
325  _ogg_free(b->psy);
326  }
327 
330 
331  drft_clear(&b->fft_look[0]);
332  drft_clear(&b->fft_look[1]);
333 
334  }
335 
336  if(v->pcm){
337  for(i=0;i<vi->channels;i++)
338  if(v->pcm[i])_ogg_free(v->pcm[i]);
339  _ogg_free(v->pcm);
340  if(v->pcmret)_ogg_free(v->pcmret);
341  }
342 
343  if(b){
344  /* free header, header1, header2 */
345  if(b->header)_ogg_free(b->header);
346  if(b->header1)_ogg_free(b->header1);
347  if(b->header2)_ogg_free(b->header2);
348  _ogg_free(b);
349  }
350 
351  memset(v,0,sizeof(*v));
352  }
353 }
354 
356  int i;
357  vorbis_info *vi=v->vi;
359 
360  /* free header, header1, header2 */
361  if(b->header)_ogg_free(b->header);b->header=NULL;
362  if(b->header1)_ogg_free(b->header1);b->header1=NULL;
363  if(b->header2)_ogg_free(b->header2);b->header2=NULL;
364 
365  /* Do we have enough storage space for the requested buffer? If not,
366  expand the PCM (and envelope) storage */
367 
368  if(v->pcm_current+vals>=v->pcm_storage){
369  v->pcm_storage=v->pcm_current+vals*2;
370 
371  for(i=0;i<vi->channels;i++){
372  v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
373  }
374  }
375 
376  for(i=0;i<vi->channels;i++)
377  v->pcmret[i]=v->pcm[i]+v->pcm_current;
378 
379  return(v->pcmret);
380 }
381 
382 static void _preextrapolate_helper(vorbis_dsp_state *v){
383  int i;
384  int order=32;
385  float *lpc=alloca(order*sizeof(*lpc));
386  float *work=alloca(v->pcm_current*sizeof(*work));
387  long j;
388  v->preextrapolate=1;
389 
390  if(v->pcm_current-v->centerW>order*2){ /* safety */
391  for(i=0;i<v->vi->channels;i++){
392  /* need to run the extrapolation in reverse! */
393  for(j=0;j<v->pcm_current;j++)
394  work[j]=v->pcm[i][v->pcm_current-j-1];
395 
396  /* prime as above */
397  vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
398 
399  /* run the predictor filter */
400  vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
401  order,
402  work+v->pcm_current-v->centerW,
403  v->centerW);
404 
405  for(j=0;j<v->pcm_current;j++)
406  v->pcm[i][v->pcm_current-j-1]=work[j];
407 
408  }
409  }
410 }
411 
412 
413 /* call with val<=0 to set eof */
414 
416  vorbis_info *vi=v->vi;
418 
419  if(vals<=0){
420  int order=32;
421  int i;
422  float *lpc=alloca(order*sizeof(*lpc));
423 
424  /* if it wasn't done earlier (very short sample) */
425  if(!v->preextrapolate)
426  _preextrapolate_helper(v);
427 
428  /* We're encoding the end of the stream. Just make sure we have
429  [at least] a few full blocks of zeroes at the end. */
430  /* actually, we don't want zeroes; that could drop a large
431  amplitude off a cliff, creating spread spectrum noise that will
432  suck to encode. Extrapolate for the sake of cleanliness. */
433 
434  vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
435  v->eofflag=v->pcm_current;
436  v->pcm_current+=ci->blocksizes[1]*3;
437 
438  for(i=0;i<vi->channels;i++){
439  if(v->eofflag>order*2){
440  /* extrapolate with LPC to fill in */
441  long n;
442 
443  /* make a predictor filter */
444  n=v->eofflag;
445  if(n>ci->blocksizes[1])n=ci->blocksizes[1];
446  vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
447 
448  /* run the predictor filter */
449  vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
450  v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
451  }else{
452  /* not enough data to extrapolate (unlikely to happen due to
453  guarding the overlap, but bulletproof in case that
454  assumtion goes away). zeroes will do. */
455  memset(v->pcm[i]+v->eofflag,0,
456  (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
457 
458  }
459  }
460  }else{
461 
462  if(v->pcm_current+vals>v->pcm_storage)
463  return(OV_EINVAL);
464 
465  v->pcm_current+=vals;
466 
467  /* we may want to reverse extrapolate the beginning of a stream
468  too... in case we're beginning on a cliff! */
469  /* clumsy, but simple. It only runs once, so simple is good. */
470  if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
471  _preextrapolate_helper(v);
472 
473  }
474  return(0);
475 }
476 
477 /* do the deltas, envelope shaping, pre-echo and determine the size of
478  the next block on which to continue analysis */
480  int i;
481  vorbis_info *vi=v->vi;
485  long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
487 
488  /* check to see if we're started... */
489  if(!v->preextrapolate)return(0);
490 
491  /* check to see if we're done... */
492  if(v->eofflag==-1)return(0);
493 
494  /* By our invariant, we have lW, W and centerW set. Search for
495  the next boundary so we can determine nW (the next window size)
496  which lets us compute the shape of the current block's window */
497 
498  /* we do an envelope search even on a single blocksize; we may still
499  be throwing more bits at impulses, and envelope search handles
500  marking impulses too. */
501  {
502  long bp=_ve_envelope_search(v);
503  if(bp==-1){
504 
505  if(v->eofflag==0)return(0); /* not enough data currently to search for a
506  full long block */
507  v->nW=0;
508  }else{
509 
510  if(ci->blocksizes[0]==ci->blocksizes[1])
511  v->nW=0;
512  else
513  v->nW=bp;
514  }
515  }
516 
517  centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
518 
519  {
520  /* center of next block + next block maximum right side. */
521 
522  long blockbound=centerNext+ci->blocksizes[v->nW]/2;
523  if(v->pcm_current<blockbound)return(0); /* not enough data yet;
524  although this check is
525  less strict that the
526  _ve_envelope_search,
527  the search is not run
528  if we only use one
529  block size */
530 
531 
532  }
533 
534  /* fill in the block. Note that for a short window, lW and nW are *short*
535  regardless of actual settings in the stream */
536 
538  vb->lW=v->lW;
539  vb->W=v->W;
540  vb->nW=v->nW;
541 
542  if(v->W){
543  if(!v->lW || !v->nW){
545  /*fprintf(stderr,"-");*/
546  }else{
548  /*fprintf(stderr,"_");*/
549  }
550  }else{
551  if(_ve_envelope_mark(v)){
553  /*fprintf(stderr,"|");*/
554 
555  }else{
557  /*fprintf(stderr,".");*/
558 
559  }
560  }
561 
562  vb->vd=v;
563  vb->sequence=v->sequence++;
564  vb->granulepos=v->granulepos;
565  vb->pcmend=ci->blocksizes[v->W];
566 
567  /* copy the vectors; this uses the local storage in vb */
568 
569  /* this tracks 'strongest peak' for later psychoacoustics */
570  /* moved to the global psy state; clean this mess up */
571  if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
572  g->ampmax=_vp_ampmax_decay(g->ampmax,v);
573  vbi->ampmax=g->ampmax;
574 
575  vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
576  vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
577  for(i=0;i<vi->channels;i++){
578  vbi->pcmdelay[i]=
579  _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
580  memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
581  vb->pcm[i]=vbi->pcmdelay[i]+beginW;
582 
583  /* before we added the delay
584  vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
585  memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
586  */
587 
588  }
589 
590  /* handle eof detection: eof==0 means that we've not yet received EOF
591  eof>0 marks the last 'real' sample in pcm[]
592  eof<0 'no more to do'; doesn't get here */
593 
594  if(v->eofflag){
595  if(v->centerW>=v->eofflag){
596  v->eofflag=-1;
597  vb->eofflag=1;
598  return(1);
599  }
600  }
601 
602  /* advance storage vectors and clean up */
603  {
604  int new_centerNext=ci->blocksizes[1]/2;
605  int movementW=centerNext-new_centerNext;
606 
607  if(movementW>0){
608 
609  _ve_envelope_shift(b->ve,movementW);
610  v->pcm_current-=movementW;
611 
612  for(i=0;i<vi->channels;i++)
613  memmove(v->pcm[i],v->pcm[i]+movementW,
614  v->pcm_current*sizeof(*v->pcm[i]));
615 
616 
617  v->lW=v->W;
618  v->W=v->nW;
619  v->centerW=new_centerNext;
620 
621  if(v->eofflag){
622  v->eofflag-=movementW;
623  if(v->eofflag<=0)v->eofflag=-1;
624  /* do not add padding to end of stream! */
625  if(v->centerW>=v->eofflag){
626  v->granulepos+=movementW-(v->centerW-v->eofflag);
627  }else{
628  v->granulepos+=movementW;
629  }
630  }else{
631  v->granulepos+=movementW;
632  }
633  }
634  }
635 
636  /* done */
637  return(1);
638 }
639 
641  vorbis_info *vi=v->vi;
642  codec_setup_info *ci;
643  int hs;
644 
645  if(!v->backend_state)return -1;
646  if(!vi)return -1;
647  ci=vi->codec_setup;
648  if(!ci)return -1;
649  hs=ci->halfrate_flag;
650 
651  v->centerW=ci->blocksizes[1]>>(hs+1);
652  v->pcm_current=v->centerW>>hs;
653 
654  v->pcm_returned=-1;
655  v->granulepos=-1;
656  v->sequence=-1;
657  v->eofflag=0;
658  ((private_state *)(v->backend_state))->sample_count=-1;
659 
660  return(0);
661 }
662 
664  if(_vds_shared_init(v,vi,0)) return 1;
666 
667  return 0;
668 }
669 
670 /* Unlike in analysis, the window is only partially applied for each
671  block. The time domain envelope is not yet handled at the point of
672  calling (as it relies on the previous block). */
673 
675  vorbis_info *vi=v->vi;
678  int hs=ci->halfrate_flag;
679  int i,j;
680 
681  if(!vb)return(OV_EINVAL);
682  if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
683 
684  v->lW=v->W;
685  v->W=vb->W;
686  v->nW=-1;
687 
688  if((v->sequence==-1)||
689  (v->sequence+1 != vb->sequence)){
690  v->granulepos=-1; /* out of sequence; lose count */
691  b->sample_count=-1;
692  }
693 
694  v->sequence=vb->sequence;
695 
696  if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
697  was called on block */
698  int n=ci->blocksizes[v->W]>>(hs+1);
699  int n0=ci->blocksizes[0]>>(hs+1);
700  int n1=ci->blocksizes[1]>>(hs+1);
701 
702  int thisCenter;
703  int prevCenter;
704 
705  v->glue_bits+=vb->glue_bits;
706  v->time_bits+=vb->time_bits;
707  v->floor_bits+=vb->floor_bits;
708  v->res_bits+=vb->res_bits;
709 
710  if(v->centerW){
711  thisCenter=n1;
712  prevCenter=0;
713  }else{
714  thisCenter=0;
715  prevCenter=n1;
716  }
717 
718  /* v->pcm is now used like a two-stage double buffer. We don't want
719  to have to constantly shift *or* adjust memory usage. Don't
720  accept a new block until the old is shifted out */
721 
722  for(j=0;j<vi->channels;j++){
723  /* the overlap/add section */
724  if(v->lW){
725  if(v->W){
726  /* large/large */
727  float *w=_vorbis_window_get(b->window[1]-hs);
728  float *pcm=v->pcm[j]+prevCenter;
729  float *p=vb->pcm[j];
730  for(i=0;i<n1;i++)
731  pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
732  }else{
733  /* large/small */
734  float *w=_vorbis_window_get(b->window[0]-hs);
735  float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
736  float *p=vb->pcm[j];
737  for(i=0;i<n0;i++)
738  pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
739  }
740  }else{
741  if(v->W){
742  /* small/large */
743  float *w=_vorbis_window_get(b->window[0]-hs);
744  float *pcm=v->pcm[j]+prevCenter;
745  float *p=vb->pcm[j]+n1/2-n0/2;
746  for(i=0;i<n0;i++)
747  pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
748  for(;i<n1/2+n0/2;i++)
749  pcm[i]=p[i];
750  }else{
751  /* small/small */
752  float *w=_vorbis_window_get(b->window[0]-hs);
753  float *pcm=v->pcm[j]+prevCenter;
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  }
759 
760  /* the copy section */
761  {
762  float *pcm=v->pcm[j]+thisCenter;
763  float *p=vb->pcm[j]+n;
764  for(i=0;i<n;i++)
765  pcm[i]=p[i];
766  }
767  }
768 
769  if(v->centerW)
770  v->centerW=0;
771  else
772  v->centerW=n1;
773 
774  /* deal with initial packet state; we do this using the explicit
775  pcm_returned==-1 flag otherwise we're sensitive to first block
776  being short or long */
777 
778  if(v->pcm_returned==-1){
779  v->pcm_returned=thisCenter;
780  v->pcm_current=thisCenter;
781  }else{
782  v->pcm_returned=prevCenter;
783  v->pcm_current=prevCenter+
784  ((ci->blocksizes[v->lW]/4+
785  ci->blocksizes[v->W]/4)>>hs);
786  }
787 
788  }
789 
790  /* track the frame number... This is for convenience, but also
791  making sure our last packet doesn't end with added padding. If
792  the last packet is partial, the number of samples we'll have to
793  return will be past the vb->granulepos.
794 
795  This is not foolproof! It will be confused if we begin
796  decoding at the last page after a seek or hole. In that case,
797  we don't have a starting point to judge where the last frame
798  is. For this reason, vorbisfile will always try to make sure
799  it reads the last two marked pages in proper sequence */
800 
801  if(b->sample_count==-1){
802  b->sample_count=0;
803  }else{
804  b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
805  }
806 
807  if(v->granulepos==-1){
808  if(vb->granulepos!=-1){ /* only set if we have a position to set to */
809 
810  v->granulepos=vb->granulepos;
811 
812  /* is this a short page? */
813  if(b->sample_count>v->granulepos){
814  /* corner case; if this is both the first and last audio page,
815  then spec says the end is cut, not beginning */
816  if(vb->eofflag){
817  /* trim the end */
818  /* no preceeding granulepos; assume we started at zero (we'd
819  have to in a short single-page stream) */
820  /* granulepos could be -1 due to a seek, but that would result
821  in a long count, not short count */
822 
823  v->pcm_current-=(b->sample_count-v->granulepos)>>hs;
824  }else{
825  /* trim the beginning */
826  v->pcm_returned+=(b->sample_count-v->granulepos)>>hs;
827  if(v->pcm_returned>v->pcm_current)
829  }
830 
831  }
832 
833  }
834  }else{
835  v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
836  if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
837 
838  if(v->granulepos>vb->granulepos){
839  long extra=v->granulepos-vb->granulepos;
840 
841  if(extra)
842  if(vb->eofflag){
843  /* partial last frame. Strip the extra samples off */
844  v->pcm_current-=extra>>hs;
845  } /* else {Shouldn't happen *unless* the bitstream is out of
846  spec. Either way, believe the bitstream } */
847  } /* else {Shouldn't happen *unless* the bitstream is out of
848  spec. Either way, believe the bitstream } */
849  v->granulepos=vb->granulepos;
850  }
851  }
852 
853  /* Update, cleanup */
854 
855  if(vb->eofflag)v->eofflag=1;
856  return(0);
857 
858 }
859 
860 /* pcm==NULL indicates we just want the pending samples, no more */
862  vorbis_info *vi=v->vi;
863 
864  if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
865  if(pcm){
866  int i;
867  for(i=0;i<vi->channels;i++)
868  v->pcmret[i]=v->pcm[i]+v->pcm_returned;
869  *pcm=v->pcmret;
870  }
871  return(v->pcm_current-v->pcm_returned);
872  }
873  return(0);
874 }
875 
877  if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
878  v->pcm_returned+=n;
879  return(0);
880 }
881 
882 /* intended for use with a specific vorbisfile feature; we want access
883  to the [usually synthetic/postextrapolated] buffer and lapping at
884  the end of a decode cycle, specifically, a half-short-block worth.
885  This funtion works like pcmout above, except it will also expose
886  this implicit buffer data not normally decoded. */
888  vorbis_info *vi=v->vi;
890  int hs=ci->halfrate_flag;
891 
892  int n=ci->blocksizes[v->W]>>(hs+1);
893  int n0=ci->blocksizes[0]>>(hs+1);
894  int n1=ci->blocksizes[1]>>(hs+1);
895  int i,j;
896 
897  if(v->pcm_returned<0)return 0;
898 
899  /* our returned data ends at pcm_returned; because the synthesis pcm
900  buffer is a two-fragment ring, that means our data block may be
901  fragmented by buffering, wrapping or a short block not filling
902  out a buffer. To simplify things, we unfragment if it's at all
903  possibly needed. Otherwise, we'd need to call lapout more than
904  once as well as hold additional dsp state. Opt for
905  simplicity. */
906 
907  /* centerW was advanced by blockin; it would be the center of the
908  *next* block */
909  if(v->centerW==n1){
910  /* the data buffer wraps; swap the halves */
911  /* slow, sure, small */
912  for(j=0;j<vi->channels;j++){
913  float *p=v->pcm[j];
914  for(i=0;i<n1;i++){
915  float temp=p[i];
916  p[i]=p[i+n1];
917  p[i+n1]=temp;
918  }
919  }
920 
921  v->pcm_current-=n1;
922  v->pcm_returned-=n1;
923  v->centerW=0;
924  }
925 
926  /* solidify buffer into contiguous space */
927  if((v->lW^v->W)==1){
928  /* long/short or short/long */
929  for(j=0;j<vi->channels;j++){
930  float *s=v->pcm[j];
931  float *d=v->pcm[j]+(n1-n0)/2;
932  for(i=(n1+n0)/2-1;i>=0;--i)
933  d[i]=s[i];
934  }
935  v->pcm_returned+=(n1-n0)/2;
936  v->pcm_current+=(n1-n0)/2;
937  }else{
938  if(v->lW==0){
939  /* short/short */
940  for(j=0;j<vi->channels;j++){
941  float *s=v->pcm[j];
942  float *d=v->pcm[j]+n1-n0;
943  for(i=n0-1;i>=0;--i)
944  d[i]=s[i];
945  }
946  v->pcm_returned+=n1-n0;
947  v->pcm_current+=n1-n0;
948  }
949  }
950 
951  if(pcm){
952  int i;
953  for(i=0;i<vi->channels;i++)
954  v->pcmret[i]=v->pcm[i]+v->pcm_returned;
955  *pcm=v->pcmret;
956  }
957 
958  return(n1+n-v->pcm_returned);
959 
960 }
961 
963  vorbis_info *vi=v->vi;
965  int hs=ci->halfrate_flag;
967 
968  if(b->window[W]-1<0)return NULL;
969  return _vorbis_window_get(b->window[W]-hs);
970 }
971 
float ** pcm
Definition: codec.h:63
GLubyte g
Definition: glext.h:4662
long glue_bits
Definition: codec.h:113
vorbis_info_residue * residue_param[64]
float vorbis_lpc_from_data(float *data, float *lpci, int n, int m)
Definition: lpc.c:61
void _vorbis_block_ripcord(vorbis_block *vb)
Definition: block.c:127
vorbis_look_psy_global * psy_g_look
int pcm_current
Definition: codec.h:66
oggpack_buffer opb
Definition: codec.h:91
ogg_int64_t granulepos
Definition: codec.h:77
void vorbis_staticbook_destroy(static_codebook *b)
Definition: sharedbook.c:271
const GLdouble * v
Definition: glext.h:2936
vorbis_info_floor * floor_param[64]
static_codebook * book_param[256]
void vorbis_lpc_predict(float *coeff, float *prime, int m, float *data, long n)
Definition: lpc.c:117
unsigned char * header
void _ve_envelope_shift(envelope_lookup *e, long shift)
Definition: envelope.c:357
GLenum GLsizei n
Definition: glext.h:3705
float _vp_ampmax_decay(float amp, vorbis_dsp_state *vd)
Definition: psy.c:859
void mdct_init(mdct_lookup *lookup, int n)
Definition: mdct.c:52
vorbis_dsp_state * vd
Definition: codec.h:102
vorbis_look_psy * psy
#define BLOCKTYPE_TRANSITION
ogg_int64_t sample_count
#define _ogg_free
Definition: os_types.h:41
void vorbis_dsp_clear(vorbis_dsp_state *v)
Definition: block.c:285
int analysisp
Definition: codec.h:60
float * _vorbis_window_get(int n)
Definition: windowvb.c:2098
drft_lookup fft_look[2]
long W
Definition: codec.h:94
int pcm_storage
Definition: codec.h:65
int _ve_envelope_mark(vorbis_dsp_state *v)
Definition: envelope.c:331
GLdouble s
Definition: glext.h:2935
long lW
Definition: codec.h:93
void _ve_envelope_clear(envelope_lookup *e)
Definition: envelope.c:76
void drft_init(drft_lookup *l, int n)
Definition: smallft.c:1241
void _ve_envelope_init(envelope_lookup *e, vorbis_info *vi)
Definition: envelope.c:32
int i
Definition: process.py:33
vorbis_look_psy_global * _vp_global_look(vorbis_info *vi)
Definition: psy.c:35
vorbis_look_floor ** flr
int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals)
Definition: block.c:415
vorbis_info * vi
Definition: codec.h:61
int vorbis_book_init_decode(codebook *dest, const static_codebook *source)
Definition: sharedbook.c:318
int preextrapolate
Definition: codec.h:69
vorbis_look_transform ** transform[2]
ogg_int64_t glue_bits
Definition: codec.h:80
struct alloc_chain * reap
Definition: codec.h:110
void * codec_setup
Definition: codec.h:53
int channels
Definition: codec.h:30
int vorbis_synthesis_blockin(vorbis_dsp_state *v, vorbis_block *vb)
Definition: block.c:674
ogg_int64_t floor_bits
Definition: codec.h:82
vorbis_info_psy_global psy_g_param
int vorbis_synthesis_pcmout(vorbis_dsp_state *v, float ***pcm)
Definition: block.c:861
GLdouble GLdouble GLint GLint order
Definition: qgl.h:339
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:3454
int vorbis_analysis_blockout(vorbis_dsp_state *v, vorbis_block *vb)
Definition: block.c:479
float ** pcm
Definition: codec.h:90
unsigned char * header2
void _vp_psy_clear(vorbis_look_psy *p)
Definition: psy.c:350
bitrate_manager_state bms
#define BLOCKTYPE_IMPULSE
#define BLOCKTYPE_LONG
int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb)
Definition: block.c:88
void _vp_psy_init(vorbis_look_psy *p, vorbis_info_psy *vi, vorbis_info_psy_global *gi, int n, long rate)
Definition: psy.c:266
float * vorbis_window(vorbis_dsp_state *v, int W)
Definition: block.c:962
int blockflag
Definition: psy.h:37
#define NULL
Definition: Lib.h:88
vorbis_func_floor * _floor_P[]
Definition: registry.c:32
int vorbis_synthesis_lapout(vorbis_dsp_state *v, float ***pcm)
Definition: block.c:887
int vorbis_synthesis_init(vorbis_dsp_state *v, vorbis_info *vi)
Definition: block.c:663
long centerW
Definition: codec.h:75
vorbis_func_residue * _residue_P[]
Definition: registry.c:37
#define VI_TRANSFORMB
Definition: registry.h:21
int pcmend
Definition: codec.h:96
int vorbis_synthesis_read(vorbis_dsp_state *v, int n)
Definition: block.c:876
long totaluse
Definition: codec.h:109
long floor_bits
Definition: codec.h:115
void vorbis_bitrate_init(vorbis_info *vi, bitrate_manager_state *bm)
Definition: bitrate.c:79
#define BLOCKTYPE_PADDING
int vorbis_analysis_init(vorbis_dsp_state *v, vorbis_info *vi)
Definition: block.c:269
#define OV_EINVAL
Definition: codec.h:226
#define _ogg_realloc
Definition: os_types.h:40
int vorbis_block_clear(vorbis_block *vb)
Definition: block.c:149
long nW
Definition: codec.h:95
GLubyte GLubyte b
Definition: glext.h:4662
long localtop
Definition: codec.h:107
int vorbis_book_init_encode(codebook *dest, const static_codebook *source)
Definition: sharedbook.c:291
struct alloc_chain * next
Definition: codec.h:129
long time_bits
Definition: codec.h:114
int eofflag
Definition: codec.h:99
void vorbis_bitrate_clear(bitrate_manager_state *bm)
Definition: bitrate.c:146
long localalloc
Definition: codec.h:108
vorbis_look_residue ** residue
void drft_clear(drft_lookup *l)
Definition: smallft.c:1248
envelope_lookup * ve
long rate
Definition: codec.h:31
ogg_int64_t granulepos
Definition: codec.h:100
void oggpack_writeinit(oggpack_buffer *b)
Definition: bitwise.c:39
void * ptr
Definition: codec.h:128
#define _ogg_calloc
Definition: os_types.h:39
float ** pcmret
Definition: codec.h:64
void mdct_clear(mdct_lookup *l)
Definition: mdct.c:339
ogg_int64_t sequence
Definition: codec.h:78
codebook * fullbooks
long _ve_envelope_search(vorbis_dsp_state *v)
Definition: envelope.c:217
long res_bits
Definition: codec.h:116
ogg_int64_t time_bits
Definition: codec.h:81
#define WORD_ALIGN
Definition: block.c:85
vorbis_info_psy * psy_param[4]
ogg_int64_t res_bits
Definition: codec.h:83
GLint j
Definition: qgl.h:264
float ** vorbis_analysis_buffer(vorbis_dsp_state *v, int vals)
Definition: block.c:355
unsigned char * header1
void _vp_global_free(vorbis_look_psy_global *look)
Definition: psy.c:47
void oggpack_writeclear(oggpack_buffer *b)
Definition: bitwise.c:205
GLfloat GLfloat p
Definition: glext.h:4674
int vorbis_synthesis_restart(vorbis_dsp_state *v)
Definition: block.c:640
void * internal
Definition: codec.h:118
void * localstore
Definition: codec.h:106
ogg_int64_t sequence
Definition: codec.h:101
int pcm_returned
Definition: codec.h:67
void * backend_state
Definition: codec.h:85
void * _vorbis_block_alloc(vorbis_block *vb, long bytes)
Definition: block.c:103
#define _ogg_malloc
Definition: os_types.h:38