* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
- * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
- * by the Xiph.Org Foundation http://www.xiph.org/ *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2015 *
+ * by the Xiph.Org Foundation https://xiph.org/ *
* *
********************************************************************
function: PCM data vector blocking, windowing and dis/reassembly
- last mod: $Id$
Handle windowing, overlap-add, etc of the PCM vectors. This is made
more amusing by Vorbis' current two allowed block sizes.
-
+
********************************************************************/
#include <stdio.h>
#include "registry.h"
#include "misc.h"
-static int ilog2(unsigned int v){
- int ret=0;
- if(v)--v;
- while(v){
- ret++;
- v>>=1;
- }
- return(ret);
-}
-
/* pcm accumulator examples (not exhaustive):
<-------------- lW ---------------->
:.....''' |_____--- '''......| | \_______|
:.................|__________________|_______|__|______|
|<------ Sl ------>| > Sr < |endW
- |beginSl |endSl | |endSr
+ |beginSl |endSl | |endSr
|beginW |endlW |beginSr
- |< lW >|
+ |< lW >|
<--------------- W ---------------->
| | .. ______________ |
| | ' `/ | ---_ |
- |___.'___/`. | ---_____|
+ |___.'___/`. | ---_____|
|_______|__|_______|_________________|
| >|Sl|< |<------ Sr ----->|endW
| | |endSl |beginSr |endSr
- |beginW | |endlW
+ |beginW | |endlW
mult[0] |beginSl mult[n]
<-------------- lW ----------------->
- |<--W-->|
-: .............. ___ | |
-: .''' |`/ \ | |
-:.....''' |/`....\|...|
-:.........................|___|___|___|
- |Sl |Sr |endW
+ |<--W-->|
+: .............. ___ | |
+: .''' |`/ \ | |
+:.....''' |/`....\|...|
+:.........................|___|___|___|
+ |Sl |Sr |endW
| | |endSr
| |beginSr
| |endSl
_ogg_calloc(1,sizeof(oggpack_buffer));
}
oggpack_writeinit(vbi->packetblob[i]);
- }
+ }
}
return(0);
private_state *b=NULL;
int hs;
- if(ci==NULL) return 1;
- hs=ci->halfrate_flag;
+ if(ci==NULL||
+ ci->modes<=0||
+ ci->blocksizes[0]<64||
+ ci->blocksizes[1]<ci->blocksizes[0]){
+ return 1;
+ }
+ hs=ci->halfrate_flag;
memset(v,0,sizeof(*v));
b=v->backend_state=_ogg_calloc(1,sizeof(*b));
v->vi=vi;
- b->modebits=ilog2(ci->modes);
+ b->modebits=ov_ilog(ci->modes-1);
b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
mdct_init(b->transform[1][0],ci->blocksizes[1]>>hs);
/* Vorbis I uses only window type 0 */
- b->window[0]=ilog2(ci->blocksizes[0])-6;
- b->window[1]=ilog2(ci->blocksizes[1])-6;
+ /* note that the correct computation below is technically:
+ b->window[0]=ov_ilog(ci->blocksizes[0]-1)-6;
+ b->window[1]=ov_ilog(ci->blocksizes[1]-1)-6;
+ but since blocksizes are always powers of two,
+ the below is equivalent.
+ */
+ b->window[0]=ov_ilog(ci->blocksizes[0])-7;
+ b->window[1]=ov_ilog(ci->blocksizes[1])-7;
if(encp){ /* encode/decode differ here */
if(!ci->fullbooks){
ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
for(i=0;i<ci->books;i++){
+ if(ci->book_param[i]==NULL)
+ goto abort_books;
if(vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]))
- return -1;
+ goto abort_books;
/* decode codebooks are now standalone after init */
vorbis_staticbook_destroy(ci->book_param[i]);
ci->book_param[i]=NULL;
for(i=0;i<ci->residues;i++)
b->residue[i]=_residue_P[ci->residue_type[i]]->
- look(v,ci->residue_param[i]);
+ look(v,ci->residue_param[i]);
return 0;
+ abort_books:
+ for(i=0;i<ci->books;i++){
+ if(ci->book_param[i]!=NULL){
+ vorbis_staticbook_destroy(ci->book_param[i]);
+ ci->book_param[i]=NULL;
+ }
+ }
+ vorbis_dsp_clear(v);
+ return -1;
}
/* arbitrary settings and spec-mandated numbers get filled in here */
private_state *b=v->backend_state;
if(b){
-
+
if(b->ve){
_ve_envelope_clear(b->ve);
_ogg_free(b->ve);
drft_clear(&b->fft_look[1]);
}
-
+
if(v->pcm){
if(vi)
for(i=0;i<vi->channels;i++)
if(b->header2)_ogg_free(b->header2);
_ogg_free(b);
}
-
+
memset(v,0,sizeof(*v));
}
}
/* Do we have enough storage space for the requested buffer? If not,
expand the PCM (and envelope) storage */
-
+
if(v->pcm_current+vals>=v->pcm_storage){
v->pcm_storage=v->pcm_current+vals*2;
-
+
for(i=0;i<vi->channels;i++){
v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
}
for(i=0;i<vi->channels;i++)
v->pcmret[i]=v->pcm[i]+v->pcm_current;
-
+
return(v->pcmret);
}
/* need to run the extrapolation in reverse! */
for(j=0;j<v->pcm_current;j++)
work[j]=v->pcm[i][v->pcm_current-j-1];
-
+
/* prime as above */
vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
}else{
_analysis_output("predata",0,work,v->pcm_current-v->centerW,0,0,0);
}
-#endif
-
+#endif
+
/* run the predictor filter */
vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
order,
amplitude off a cliff, creating spread spectrum noise that will
suck to encode. Extrapolate for the sake of cleanliness. */
- vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
+ vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
v->eofflag=v->pcm_current;
v->pcm_current+=ci->blocksizes[1]*3;
/* we do an envelope search even on a single blocksize; we may still
be throwing more bits at impulses, and envelope search handles
marking impulses too. */
- {
+ {
long bp=_ve_envelope_search(v);
if(bp==-1){
}
-
+
/* fill in the block. Note that for a short window, lW and nW are *short*
regardless of actual settings in the stream */
}
}
-
+
vb->vd=v;
vb->sequence=v->sequence++;
vb->granulepos=v->granulepos;
vb->pcmend=ci->blocksizes[v->W];
-
+
/* copy the vectors; this uses the local storage in vb */
/* this tracks 'strongest peak' for later psychoacoustics */
if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
g->ampmax=_vp_ampmax_decay(g->ampmax,v);
vbi->ampmax=g->ampmax;
-
+
vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
for(i=0;i<vi->channels;i++){
_vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
vb->pcm[i]=vbi->pcmdelay[i]+beginW;
-
- /* before we added the delay
+
+ /* before we added the delay
vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
*/
-
+
}
-
+
/* handle eof detection: eof==0 means that we've not yet received EOF
eof>0 marks the last 'real' sample in pcm[]
eof<0 'no more to do'; doesn't get here */
_ve_envelope_shift(b->ve,movementW);
v->pcm_current-=movementW;
-
+
for(i=0;i<vi->channels;i++)
memmove(v->pcm[i],v->pcm[i]+movementW,
v->pcm_current*sizeof(*v->pcm[i]));
-
-
+
+
v->lW=v->W;
v->W=v->nW;
v->centerW=new_centerNext;
-
+
if(v->eofflag){
v->eofflag-=movementW;
if(v->eofflag<=0)v->eofflag=-1;
if(!vi)return -1;
ci=vi->codec_setup;
if(!ci)return -1;
- hs=ci->halfrate_flag;
+ hs=ci->halfrate_flag;
v->centerW=ci->blocksizes[1]>>(hs+1);
v->pcm_current=v->centerW>>hs;
-
+
v->pcm_returned=-1;
v->granulepos=-1;
v->sequence=-1;
vorbis_info *vi=v->vi;
codec_setup_info *ci=vi->codec_setup;
private_state *b=v->backend_state;
- int hs=ci->halfrate_flag;
+ int hs=ci->halfrate_flag;
int i,j;
if(!vb)return(OV_EINVAL);
if(v->pcm_current>v->pcm_returned && v->pcm_returned!=-1)return(OV_EINVAL);
-
+
v->lW=v->W;
v->W=vb->W;
v->nW=-1;
-
+
if((v->sequence==-1)||
(v->sequence+1 != vb->sequence)){
v->granulepos=-1; /* out of sequence; lose count */
}
v->sequence=vb->sequence;
-
- if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
+
+ if(vb->pcm){ /* no pcm to process if vorbis_synthesis_trackonly
was called on block */
int n=ci->blocksizes[v->W]>>(hs+1);
int n0=ci->blocksizes[0]>>(hs+1);
int thisCenter;
int prevCenter;
-
+
v->glue_bits+=vb->glue_bits;
v->time_bits+=vb->time_bits;
v->floor_bits+=vb->floor_bits;
v->res_bits+=vb->res_bits;
-
+
if(v->centerW){
thisCenter=n1;
prevCenter=0;
thisCenter=0;
prevCenter=n1;
}
-
+
/* v->pcm is now used like a two-stage double buffer. We don't want
to have to constantly shift *or* adjust memory usage. Don't
accept a new block until the old is shifted out */
-
+
for(j=0;j<vi->channels;j++){
/* the overlap/add section */
if(v->lW){
if(v->W){
/* large/large */
- float *w=_vorbis_window_get(b->window[1]-hs);
+ const float *w=_vorbis_window_get(b->window[1]-hs);
float *pcm=v->pcm[j]+prevCenter;
float *p=vb->pcm[j];
for(i=0;i<n1;i++)
pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
}else{
/* large/small */
- float *w=_vorbis_window_get(b->window[0]-hs);
+ const float *w=_vorbis_window_get(b->window[0]-hs);
float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
float *p=vb->pcm[j];
for(i=0;i<n0;i++)
}else{
if(v->W){
/* small/large */
- float *w=_vorbis_window_get(b->window[0]-hs);
+ const float *w=_vorbis_window_get(b->window[0]-hs);
float *pcm=v->pcm[j]+prevCenter;
float *p=vb->pcm[j]+n1/2-n0/2;
for(i=0;i<n0;i++)
pcm[i]=p[i];
}else{
/* small/small */
- float *w=_vorbis_window_get(b->window[0]-hs);
+ const float *w=_vorbis_window_get(b->window[0]-hs);
float *pcm=v->pcm[j]+prevCenter;
float *p=vb->pcm[j];
for(i=0;i<n0;i++)
pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
}
}
-
+
/* the copy section */
{
float *pcm=v->pcm[j]+thisCenter;
pcm[i]=p[i];
}
}
-
+
if(v->centerW)
v->centerW=0;
else
v->centerW=n1;
-
+
/* deal with initial packet state; we do this using the explicit
pcm_returned==-1 flag otherwise we're sensitive to first block
being short or long */
-
+
if(v->pcm_returned==-1){
v->pcm_returned=thisCenter;
v->pcm_current=thisCenter;
((ci->blocksizes[v->lW]/4+
ci->blocksizes[v->W]/4)>>hs);
}
-
+
}
/* track the frame number... This is for convenience, but also
making sure our last packet doesn't end with added padding. If
the last packet is partial, the number of samples we'll have to
return will be past the vb->granulepos.
-
+
This is not foolproof! It will be confused if we begin
decoding at the last page after a seek or hole. In that case,
we don't have a starting point to judge where the last frame
}else{
b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
}
-
+
if(v->granulepos==-1){
if(vb->granulepos!=-1){ /* only set if we have a position to set to */
if(b->sample_count>v->granulepos){
/* corner case; if this is both the first and last audio page,
then spec says the end is cut, not beginning */
+ long extra=b->sample_count-vb->granulepos;
+
+ /* we use ogg_int64_t for granule positions because a
+ uint64 isn't universally available. Unfortunately,
+ that means granposes can be 'negative' and result in
+ extra being negative */
+ if(extra<0)
+ extra=0;
+
if(vb->eofflag){
/* trim the end */
- /* no preceeding granulepos; assume we started at zero (we'd
+ /* no preceding granulepos; assume we started at zero (we'd
have to in a short single-page stream) */
/* granulepos could be -1 due to a seek, but that would result
in a long count, not short count */
-
- v->pcm_current-=(b->sample_count-v->granulepos)>>hs;
+
+ /* Guard against corrupt/malicious frames that set EOP and
+ a backdated granpos; don't rewind more samples than we
+ actually have */
+ if(extra > (v->pcm_current - v->pcm_returned)<<hs)
+ extra = (v->pcm_current - v->pcm_returned)<<hs;
+
+ v->pcm_current-=extra>>hs;
}else{
/* trim the beginning */
- v->pcm_returned+=(b->sample_count-v->granulepos)>>hs;
+ v->pcm_returned+=extra>>hs;
if(v->pcm_returned>v->pcm_current)
v->pcm_returned=v->pcm_current;
}
}else{
v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
-
+
if(v->granulepos>vb->granulepos){
long extra=v->granulepos-vb->granulepos;
if(extra)
if(vb->eofflag){
/* partial last frame. Strip the extra samples off */
+
+ /* Guard against corrupt/malicious frames that set EOP and
+ a backdated granpos; don't rewind more samples than we
+ actually have */
+ if(extra > (v->pcm_current - v->pcm_returned)<<hs)
+ extra = (v->pcm_current - v->pcm_returned)<<hs;
+
+ /* we use ogg_int64_t for granule positions because a
+ uint64 isn't universally available. Unfortunately,
+ that means granposes can be 'negative' and result in
+ extra being negative */
+ if(extra<0)
+ extra=0;
+
v->pcm_current-=extra>>hs;
} /* else {Shouldn't happen *unless* the bitstream is out of
spec. Either way, believe the bitstream } */
v->granulepos=vb->granulepos;
}
}
-
+
/* Update, cleanup */
-
+
if(vb->eofflag)v->eofflag=1;
return(0);
-
+
}
/* pcm==NULL indicates we just want the pending samples, no more */
int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
vorbis_info *vi=v->vi;
codec_setup_info *ci=vi->codec_setup;
- int hs=ci->halfrate_flag;
-
+ int hs=ci->halfrate_flag;
+
int n=ci->blocksizes[v->W]>>(hs+1);
int n0=ci->blocksizes[0]>>(hs+1);
int n1=ci->blocksizes[1]>>(hs+1);
v->pcm_returned-=n1;
v->centerW=0;
}
-
+
/* solidify buffer into contiguous space */
if((v->lW^v->W)==1){
/* long/short or short/long */
v->pcm_current+=n1-n0;
}
}
-
+
if(pcm){
int i;
for(i=0;i<vi->channels;i++)
}
-float *vorbis_window(vorbis_dsp_state *v,int W){
+const float *vorbis_window(vorbis_dsp_state *v,int W){
vorbis_info *vi=v->vi;
codec_setup_info *ci=vi->codec_setup;
- int hs=ci->halfrate_flag;
+ int hs=ci->halfrate_flag;
private_state *b=v->backend_state;
if(b->window[W]-1<0)return NULL;
return _vorbis_window_get(b->window[W]-hs);
}
-
projects / platform / upstream / libvorbis.git / blobdiff