1 /********************************************************************
3 * THIS FILE IS PART OF THE Ogg Vorbis SOFTWARE CODEC SOURCE CODE. *
4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
5 * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE. *
6 * PLEASE READ THESE TERMS DISTRIBUTING. *
8 * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-1999 *
9 * by 1999 Monty <monty@xiph.org> and The XIPHOPHORUS Company *
10 * http://www.xiph.org/ *
12 ********************************************************************
14 function: PCM data envelope analysis and manipulation
15 author: Monty <xiphmont@mit.edu>
16 modifications by: Monty
17 last modification date: Oct 06 1999
19 Vorbis manipulates the dynamic range of the incoming PCM data
20 envelope to minimise time-domain energy leakage from percussive and
21 plosive waveforms being quantized in the MDCT domain.
23 ********************************************************************/
34 void _ve_envelope_init(envelope_lookup *e,int samples_per){
37 e->winlen=samples_per*2;
38 e->window=malloc(e->winlen*sizeof(double));
40 /* We just use a straight sin^2(x) window for this */
41 for(i=0;i<e->winlen;i++){
42 double temp=sin((i+.5)/e->winlen*M_PI);
43 e->window[i]=temp*temp;
47 void _ve_envelope_clear(envelope_lookup *e){
48 if(e->window)free(e->window);
49 memset(e,0,sizeof(envelope_lookup));
52 /* initial and final blocks are special cases. Eg:
55 |_______|_`-.___|_______|_______|
59 |___.-'_|_______|_`-.___|_______|
63 |_______|___.-'_|_______|_`-.___|
67 |_______|_______|____.-'|_______|
69 as we go block by block, we watch the collective metrics span. If we
70 span the threshhold (assuming the threshhold is active), we use an
73 static int _ve_envelope_generate(double *mult,double *env,double *look,
78 for(j=0;j<n;j++)if(mult[j]!=1)break;
82 /* first multiplier special case */
84 for(p=0;p<step/2;p++)env[p]=m;
86 /* mid multipliers normal case */
87 for(j=1;p<n-step/2;j++){
91 for(i=0;i<step;i++,p++)env[p]=m;
93 for(i=0;i<step;i++,p++)env[p]=m*look[i]+mo*look[i+step];
96 /* last multiplier special case */
97 for(;p<n;p++)env[p]=m;
101 /* right now, we do things simple and dirty (read: our current preecho
102 is a joke). Should this prove inadequate, then we'll think of
103 something different. The details of the encoding format do not
104 depend on the exact behavior, only the format of the bits that come
107 Mark Taylor probably has much witter ways of doing this... Let's
108 see if simple delta analysis gives us acceptible results for now. */
110 static void _ve_deltas(double *deltas,double *pcm,int n,double *win,
115 for(i=0;i<winsize-1;i++,p++){
116 double temp=fabs(win[i]*pcm[p]-win[i+1]*pcm[p+1]);
117 if(deltas[j]<temp)deltas[j]=temp;
123 void _ve_envelope_multipliers(vorbis_dsp_state *v){
124 vorbis_info *vi=v->vi;
125 int step=vi->envelopesa;
128 /* we need a 1-1/4 envelope window overlap begin and 1/4 end */
129 int dtotal=(v->pcm_current-step/2)/vi->envelopesa;
130 int dcurr=v->envelope_current;
131 double *window=v->ve.window;
132 int winlen=v->ve.winlen;
136 for(ech=0;ech<vi->envelopech;ech++){
137 double *mult=v->multipliers[ech]+dcurr;
138 memset(mult,0,sizeof(double)*(dtotal-dcurr));
140 for(pch=0;pch<vi->channels;pch++){
142 /* does this channel contribute to the envelope analysis */
143 /*if(vi->envelopemap[pch]==ech){ not mapping yet */
146 /* we need a 1/4 envelope window overlap front and back */
147 double *pcm=v->pcm[pch]+dcurr*step-step/2;
148 _ve_deltas(mult,pcm,dtotal-dcurr,window,winlen);
153 v->envelope_current=dtotal;
158 /* This readies the multiplier vector for use/coding. Clamp/adjust
159 the multipliers to the allowed range and eliminate unneeded
162 void _ve_envelope_sparsify(vorbis_block *vb){
163 vorbis_info *vi=vb->vd->vi;
165 for(ch=0;ch<vi->envelopech;ch++){
167 double *mult=vb->mult[ch];
169 double first=mult[0];
174 /* are we going to multiply anything? */
177 if(mult[i]>=last*vi->preecho_thresh){
181 if(i<n-1 && mult[i+1]>=last*vi->preecho_thresh){
189 /* we need to adjust, so we might as well go nuts */
194 for(i=0;i<begin;i++)mult[i]=0;
198 if(mult[i]/last>clamp*vi->preecho_thresh){
199 last=mult[i]/vi->preecho_clamp;
201 mult[i]=floor(log(mult[i]/clamp/vi->preecho_clamp)/log(2))-1;
202 if(mult[i]>15)mult[i]=15;
208 memset(mult,0,sizeof(double)*n);
212 void _ve_envelope_apply(vorbis_block *vb,int multp){
213 vorbis_info *vi=vb->vd->vi;
214 double env[vb->multend*vi->envelopesa];
215 envelope_lookup *look=&vb->vd->ve;
218 for(i=0;i<vi->envelopech;i++){
219 double *mult=vb->mult[i];
222 /* fill in the multiplier placeholders */
224 for(j=0;j<vb->multend;j++){
231 /* compute the envelope curve */
232 if(_ve_envelope_generate(mult,env,look->window,vb->multend,
235 /* apply the envelope curve */
236 for(j=0;j<vi->channels;j++){
238 /* check to see if the generated envelope applies to this channel */
239 /*if(vi->envelopemap[j]==i){ not mapping yet */
243 for(k=0;k<vb->multend*vi->envelopesa;k++)
244 vb->pcm[j][k]*=env[k];
246 for(k=0;k<vb->multend*vi->envelopesa;k++)
247 vb->pcm[j][k]/=env[k];
254 int _ve_envelope_encode(vorbis_block *vb){
255 /* Not huffcoded yet. */
257 vorbis_info *vi=vb->vd->vi;
264 for(i=0;i<vi->envelopech;i++){
265 double *mult=vb->mult[i];
267 _oggpack_write(&vb->opb,(int)(mult[j]),4);
272 /* synthesis expands the buffers in vb if needed. We can assume we
273 have enough storage handed to us. */
274 int _ve_envelope_decode(vorbis_block *vb){
275 vorbis_info *vi=vb->vd->vi;
282 for(i=0;i<vi->envelopech;i++){
283 double *mult=vb->mult[i];
285 mult[j]=_oggpack_read(&vb->opb,4);