|
881
|
1 // sndstretch.c
|
|
|
2 //
|
|
|
3 // sndstretch - algorithm for adjusting pitch and speed of s16le data
|
|
|
4 // Copyright (C) 2000 Florian Berger
|
|
|
5 // Email: florian.berger@jk.uni-linz.ac.at
|
|
|
6 //
|
|
|
7 // This program is free software; you can redistribute it and/or modify
|
|
|
8 // it under the terms of the GNU General Public License Version 2 as
|
|
|
9 // published by the Free Software Foundation;
|
|
|
10 //
|
|
|
11 // This program is distributed in the hope that it will be useful,
|
|
|
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
14 // GNU General Public License for more details.
|
|
|
15 //
|
|
|
16 // You should have received a copy of the GNU General Public License
|
|
|
17 // along with this program; if not, write to the Free Software
|
|
|
18 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
19 //
|
|
|
20 //
|
|
|
21
|
|
|
22 //#define DEBUG
|
|
|
23
|
|
|
24 #include<stdio.h>
|
|
|
25 #include<stdlib.h>
|
|
|
26 #include<math.h>
|
|
|
27 #include"sndstretch.h"
|
|
|
28
|
|
|
29
|
|
|
30 static double _1_div_e = 0.367879441; // 1/e
|
|
|
31 static double _1_m_1_div_e = 0.632120558; // 1-1/e
|
|
|
32
|
|
|
33 #define RESMAX 65536
|
|
|
34 #define RESMAXVC 32768
|
|
|
35 #define LOG2RESMAX 16
|
|
|
36 #define LOG2RESMAXVC 15
|
|
|
37 static int _1_div_e_i = 24109; // 1/e * 2^LOG2RESMAX
|
|
|
38 static int _1_m_1_div_e_i = 41427; // 1-1/e * 2^LOG2RESMAX
|
|
|
39 static int _1_div_e_i_vc = 12055; // 1/e * 2^LOG2RESMAXVC
|
|
|
40 static int _1_m_1_div_e_i_vc = 28333; // sqrt(1-1/e^2) * 2^LOG2RESMAXVC
|
|
|
41 //static int _1_div_e_i = 12055; // 1/e * 2^LOG2RESMAX
|
|
|
42 //static int _1_m_1_div_e_i = 20713; // 1-1/e * 2^LOG2RESMAX
|
|
|
43
|
|
|
44
|
|
|
45 void InitScaleJob( ScaleJob * job )
|
|
|
46 {
|
|
|
47 /* nothing to do */
|
|
|
48 }
|
|
|
49
|
|
|
50
|
|
|
51 void InitStretchJob( StretchJob * job )
|
|
|
52 {
|
|
|
53 job->is_initialized=0;
|
|
|
54 job->snr_rest=0.0;
|
|
|
55 }
|
|
|
56
|
|
|
57
|
|
|
58 void InitPitchSpeedJob( PitchSpeedJob * job )
|
|
|
59 {
|
|
|
60 job->ring_buff = (s16*)0; // init me = (s16*)0
|
|
|
61 job->ring_buff_old = (s16*)0; // init me = (s16*)0
|
|
|
62 job->buff_help = (s16*)0; // init me = (s16*)0
|
|
|
63 job->ring_size = 1; // init me = 1
|
|
|
64 job->ring_size_old = 0; // init me = 0
|
|
|
65 job->ring_pos_w = 0; // init me = 0
|
|
|
66 job->ring_pos_r = 0; // init me = 0
|
|
|
67 job->is_init = 0; // init me = 0
|
|
|
68 job->speed_act = 0; // init me = 0
|
|
|
69 job->pitch_act = 0; // init me = 0
|
|
|
70 job->fade_shift_act = 0;
|
|
|
71 InitStretchJob(&(job->stretch_job));
|
|
|
72 InitScaleJob(&(job->scale_job));
|
|
|
73 }
|
|
|
74
|
|
|
75
|
|
|
76
|
|
|
77 void CleanupPitchSpeedJob( PitchSpeedJob * job )
|
|
|
78 {
|
|
|
79 free(job->ring_buff);
|
|
|
80 free(job->ring_buff_old);
|
|
|
81 free(job->buff_help);
|
|
|
82 }
|
|
|
83
|
|
|
84
|
|
|
85
|
|
|
86 inline int ringpos( int pos, int size )
|
|
|
87 {
|
|
|
88 while ( pos >= size ) pos-=size;
|
|
|
89 while ( pos < 0 ) pos+=size;
|
|
|
90 return( pos );
|
|
|
91 }
|
|
|
92
|
|
|
93
|
|
|
94 void ringload( s16 * ringbuff, int ring_size, int pos, s16 *buffer, int size )
|
|
|
95 /* put <size> samples to ring with size <ring_size> on position <pos> */
|
|
|
96 {
|
|
|
97 int i,j;
|
|
|
98
|
|
|
99 j=0;
|
|
|
100 if( pos+size > ring_size ){
|
|
|
101 for( i=pos; i<ring_size; i++,j++ ) ringbuff[i]=buffer[j];
|
|
|
102 for( i=0; i<size-ring_size+pos; i++,j++ ) ringbuff[i]=buffer[j];
|
|
|
103 }else{
|
|
|
104 for( i=pos; i<size+pos; i++,j++ ) ringbuff[i]=buffer[j];
|
|
|
105 }
|
|
|
106 }
|
|
|
107
|
|
|
108
|
|
|
109 void ringcopy( s16 * src_ring, int src_size, int src_from, int src_to,
|
|
|
110 s16 * dest_ring, int dest_size, int dest_pos )
|
|
|
111 {
|
|
|
112 int is,id;
|
|
|
113
|
|
|
114 is=src_from; id=dest_pos;
|
|
|
115 while( is!=src_to ){
|
|
|
116 dest_ring[id]=src_ring[is];
|
|
|
117 is=ringpos(is+1,src_size);
|
|
|
118 id=ringpos(id+1,dest_size);
|
|
|
119 }
|
|
|
120 }
|
|
|
121
|
|
|
122
|
|
|
123 void ringload_IIR_1_div_e_echo_d( s16 * ringbuff, int ring_size, int pos, s16 *buffer, int size , int delay)
|
|
|
124 /* put <size> samples to ring with size <ring_size> on position <pos> */
|
|
|
125 {
|
|
|
126 int i,p1,p2;
|
|
|
127
|
|
|
128 p1=pos, p2=ringpos(p1-delay, ring_size);
|
|
|
129 for( i=0; i<size; i++ ){
|
|
|
130 ringbuff[p1] =(s16)( (double)buffer[i]*_1_m_1_div_e + (double)ringbuff[p2]*_1_div_e );
|
|
|
131 p1++; if(p1>=ring_size) p1-=ring_size;
|
|
|
132 p2++; if(p2>=ring_size) p2-=ring_size;
|
|
|
133 }
|
|
|
134 }
|
|
|
135
|
|
|
136
|
|
|
137 void ringload_IIR_1_div_e_echo_i( s16 * ringbuff, int ring_size, int pos, s16 *buffer, int size , int delay)
|
|
|
138 /* put <size> samples to ring with size <ring_size> on position <pos> */
|
|
|
139 {
|
|
|
140 int i,p1,p2;
|
|
|
141
|
|
|
142 p1=pos, p2=ringpos(p1-delay, ring_size);
|
|
|
143 for( i=0; i<size; i++ ){
|
|
|
144 ringbuff[p1] =(s16)( (
|
|
|
145 _1_m_1_div_e_i * buffer[i] +
|
|
|
146 _1_div_e_i * ringbuff[p2]
|
|
|
147 ) >> LOG2RESMAX );
|
|
|
148 p1++; if(p1>=ring_size) p1-=ring_size;
|
|
|
149 p2++; if(p2>=ring_size) p2-=ring_size;
|
|
|
150 }
|
|
|
151 }
|
|
|
152
|
|
|
153
|
|
|
154 void ringload_IIR_1_div_e_echo_i_vc( s16 * ringbuff, int ring_size, int pos, s16 *buffer, int size , int delay)
|
|
|
155 /* put <size> samples to ring with size <ring_size> on position <pos> */
|
|
|
156 {
|
|
|
157 int i,p1,p2;
|
|
|
158 int actval;
|
|
|
159
|
|
|
160 p1=pos, p2=ringpos(p1-delay, ring_size);
|
|
|
161 for( i=0; i<size; i++ ){
|
|
|
162 /* ringbuff[p1] =(s16)( (
|
|
|
163 _1_m_1_div_e_i_vc * buffer[i] +
|
|
|
164 _1_div_e_i_vc * ringbuff[p2]
|
|
|
165 ) >> LOG2RESMAXVC );*/
|
|
|
166 actval = _1_m_1_div_e_i_vc * buffer[i] +
|
|
|
167 _1_div_e_i_vc * ringbuff[p2];
|
|
|
168 /* prevent overflow */
|
|
|
169 if( actval > (int)0x3FFFFFFF ) actval=(int)0x3FFFFFFF;
|
|
|
170 if( actval < (int)0xC0000000 ) actval=(int)0xC0000000;
|
|
|
171 ringbuff[p1] = actval >> LOG2RESMAXVC;
|
|
|
172 p1++; if(p1>=ring_size) p1-=ring_size;
|
|
|
173 p2++; if(p2>=ring_size) p2-=ring_size;
|
|
|
174 }
|
|
|
175 }
|
|
|
176
|
|
|
177
|
|
|
178 /*void ringget ( s16 * ringbuff, int ring_size, int pos, s16 *buffer, int size )
|
|
|
179 {
|
|
|
180 int i;
|
|
|
181
|
|
|
182 if( pos+size > ring_size ){
|
|
|
183 for( i=pos; i<ring_size; i++ ) buffer[i]=ringbuff[i];
|
|
|
184 for( i=0; i<size-ring_size+pos; i++ ) buffer[i]=ringbuff[i];
|
|
|
185 }else{
|
|
|
186 for( i=pos; i<size+pos; i++ ) buffer[i]=ringbuff[i];
|
|
|
187 }
|
|
|
188 }
|
|
|
189 */
|
|
|
190
|
|
|
191 //int sndstretch( // not optimized
|
|
|
192 int sndstretch_not_optimized(
|
|
|
193 /* stretches the sound (not changing pitch !!!) */
|
|
|
194 /* returns number of output samples produced */
|
|
|
195 /* chnr simply gives multiples of chnr as snr_prod */
|
|
|
196 s16 * buffer, int buff_size, /* ring buffer */
|
|
|
197 int pos_init, /* only initial pos in ringbuffer */
|
|
|
198 int snr_i, int snr_o, /* enlarge - spec */
|
|
|
199 int chnr, /* # of channels */
|
|
|
200 s16 * outbuff, /* output */
|
|
|
201 int * out_prod, /* # of output-samples produced */
|
|
|
202 int snr_proc, /* # of in-samples to process */
|
|
|
203 int initialize /* bool */
|
|
|
204 )
|
|
|
205 {
|
|
|
206 static int is_initialized=0;
|
|
|
207 static int snr_o_prod;
|
|
|
208 static int snr_i_act;
|
|
|
209 static int snr_o_act;
|
|
|
210 /* static int snr_offs; */
|
|
|
211 static int pos_act;
|
|
|
212 static int dsnr;
|
|
|
213 /* static int p1,p2; */
|
|
|
214 static double snr_rest=0.0;
|
|
|
215
|
|
|
216 int snr;
|
|
|
217 double snr_d;
|
|
|
218
|
|
|
219 int i,p1,p2;
|
|
|
220 double fade_in, fade_out;
|
|
|
221 double outd;
|
|
|
222
|
|
|
223 /* s16 * outbuff; */
|
|
|
224
|
|
|
225 /* reset */
|
|
|
226 if( !is_initialized || initialize ||
|
|
|
227 snr_i!=snr_i_act || snr_o!=snr_o_act ){
|
|
|
228
|
|
|
229 snr_rest = 0.0;
|
|
|
230 snr_o_prod = 0;
|
|
|
231 snr_i_act = snr_i;
|
|
|
232 snr_o_act = snr_o;
|
|
|
233 dsnr = snr_o_act-snr_i_act;
|
|
|
234 pos_act = pos_init;
|
|
|
235
|
|
|
236 is_initialized = 1;
|
|
|
237
|
|
|
238 }
|
|
|
239
|
|
|
240 /* fprintf(stderr,"pos_act=%d\n",pos_act);
|
|
|
241 */
|
|
|
242 snr_d = (double)snr_proc*(double)snr_o_act/(double)snr_i_act
|
|
|
243 + snr_rest;
|
|
|
244 snr = (int) (snr_d) / 2 * 2;
|
|
|
245 snr_rest = snr_d - (double)snr;
|
|
|
246
|
|
|
247 /* fprintf(stderr,"snr=%d\n",snr);
|
|
|
248 */
|
|
|
249 /* outbuff=malloc(snr*sizeof(s16));
|
|
|
250 */
|
|
|
251 /* produce snr samples */
|
|
|
252 i=0;
|
|
|
253 do {
|
|
|
254 if( snr_o_prod == snr_o_act ) {
|
|
|
255 snr_o_prod=0;
|
|
|
256 /* fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!! dsnr = %d\n",dsnr);*/
|
|
|
257 pos_act = ringpos( pos_act-dsnr, buff_size );
|
|
|
258 }
|
|
|
259 for ( ; snr_o_prod < snr_o_act && i<snr ; snr_o_prod++,i++ ){
|
|
|
260 p1=pos_act;
|
|
|
261 p2=ringpos( p1-dsnr, buff_size );
|
|
|
262 // p3=ringpos( p2-dsnr, buff_size );
|
|
|
263 // p4=ringpos( p3-dsnr, buff_size );
|
|
|
264 // p2=ringpos( p1-abs(dsnr), buff_size );
|
|
|
265 // p3=ringpos( p2-abs(dsnr), buff_size );
|
|
|
266 // p4=ringpos( p3-abs(dsnr), buff_size );
|
|
|
267 fade_in = (double)snr_o_prod/(double)snr_o_act;
|
|
|
268 fade_out = 1.0-fade_in;
|
|
|
269 // fade1 = (dsnr>0)?fade_out:fade_in;
|
|
|
270 // fade2 = (dsnr>0)?fade_in:fade_out;
|
|
|
271 outd = (
|
|
|
272 (double)buffer[p1] * fade_out /* fade out */
|
|
|
273 + (double)buffer[p2] * fade_in /* fade in */
|
|
|
274 // +( 0.67 * (double)buffer[p1] /* fade out for lengthen */
|
|
|
275 // + 0.24 * (double)buffer[p2] /* fade out */
|
|
|
276 // + 0.09 * (double)buffer[p3]) * fade_out /* fade out */
|
|
|
277 // +( 0.67 * (double)buffer[p2] /* fade in */
|
|
|
278 // + 0.24 * (double)buffer[p3] /* fade in */
|
|
|
279 // + 0.09 * (double)buffer[p4]) * fade_in /* fade in */
|
|
|
280 );
|
|
|
281 outbuff[i] = outd+0.5;
|
|
|
282 pos_act=ringpos( pos_act+1, buff_size );
|
|
|
283 }
|
|
|
284 } while( i<snr );
|
|
|
285
|
|
|
286 /* fwrite( outbuff, sizeof(s16), snr, stdout );
|
|
|
287 */
|
|
|
288 /* free(outbuff);
|
|
|
289 */
|
|
|
290 *out_prod = snr;
|
|
|
291
|
|
|
292 /* fprintf(stderr,"snr = %d\n",snr);
|
|
|
293 */
|
|
|
294 return( *out_prod );
|
|
|
295 }
|
|
|
296
|
|
|
297
|
|
|
298 int sndstretch( // optimized
|
|
|
299 //int sndstretch_optimized( // optimized
|
|
|
300 /* stretches the sound (not changing pitch !!!) */
|
|
|
301 /* returns number of output samples produced */
|
|
|
302 /* chnr simply gives multiples of chnr as snr_prod */
|
|
|
303 s16 * buffer, int buff_size, /* ring buffer */
|
|
|
304 int pos_init, /* only initial pos in ringbuffer */
|
|
|
305 int snr_i, int snr_o, /* enlarge - spec */
|
|
|
306 int chnr, /* # of channels */
|
|
|
307 s16 * outbuff, /* output */
|
|
|
308 int * out_prod, /* # of output-samples produced */
|
|
|
309 int snr_proc, /* # of in-samples to process */
|
|
|
310 int initialize /* bool */
|
|
|
311 )
|
|
|
312 {
|
|
|
313 static int is_initialized=0;
|
|
|
314 static int snr_o_prod;
|
|
|
315 static int snr_i_act;
|
|
|
316 static int snr_o_act;
|
|
|
317 static int pos_act;
|
|
|
318 static int dsnr;
|
|
|
319 static double snr_rest=0.0;
|
|
|
320
|
|
|
321 static int _RESMAX_div_max, _RESMAX_mod_max;
|
|
|
322 static int fade_in_i, fade_out_i, fade_rest_i;
|
|
|
323
|
|
|
324 /* not necessarily static */
|
|
|
325 static int snr;
|
|
|
326 static double snr_d;
|
|
|
327 static int i,p2;
|
|
|
328
|
|
|
329 /* reset */
|
|
|
330 if( !is_initialized || initialize ||
|
|
|
331 snr_i!=snr_i_act || snr_o!=snr_o_act ){
|
|
|
332
|
|
|
333 snr_rest = 0.0;
|
|
|
334 snr_o_prod = 0;
|
|
|
335 snr_i_act = snr_i;
|
|
|
336 snr_o_act = snr_o;
|
|
|
337 dsnr = snr_o_act-snr_i_act;
|
|
|
338 pos_act = pos_init;
|
|
|
339
|
|
|
340 is_initialized = 1;
|
|
|
341
|
|
|
342 }
|
|
|
343
|
|
|
344 snr_d = (double)snr_proc*(double)snr_o_act/(double)snr_i_act
|
|
|
345 + snr_rest;
|
|
|
346 snr = (int) (snr_d) / 2 * 2;
|
|
|
347 snr_rest = snr_d - (double)snr;
|
|
|
348
|
|
|
349 /* produce snr samples */
|
|
|
350 i=0;
|
|
|
351 do {
|
|
|
352 if( snr_o_prod == snr_o_act ) {
|
|
|
353 snr_o_prod=0;
|
|
|
354 pos_act = ringpos( pos_act-dsnr, buff_size );
|
|
|
355 }
|
|
|
356 fade_in_i = RESMAX*((double)snr_o_prod/(double)snr_o_act);
|
|
|
357 fade_out_i = RESMAX-fade_in_i;
|
|
|
358 fade_rest_i= (RESMAX*snr_o_prod)%snr_o_act;
|
|
|
359 _RESMAX_div_max=RESMAX/snr_o_act;
|
|
|
360 _RESMAX_mod_max=RESMAX%snr_o_act;
|
|
|
361 p2=ringpos( pos_act-dsnr, buff_size );
|
|
|
362 for ( ; snr_o_prod < snr_o_act && i<snr ; snr_o_prod++,i++ ){
|
|
|
363 fade_in_i +=_RESMAX_div_max;
|
|
|
364 fade_out_i -=_RESMAX_div_max;
|
|
|
365 fade_rest_i+=_RESMAX_mod_max;
|
|
|
366 if(fade_rest_i>snr_o_act){
|
|
|
367 fade_rest_i-=snr_o_act;
|
|
|
368 fade_in_i++;
|
|
|
369 fade_out_i--;
|
|
|
370 }
|
|
|
371 outbuff[i] = (s16)( (
|
|
|
372 + (int)buffer[pos_act] * fade_out_i
|
|
|
373 + (int)buffer[p2] * fade_in_i
|
|
|
374 ) >> LOG2RESMAX );
|
|
|
375 pos_act++; if(pos_act>=buff_size) pos_act-=buff_size;
|
|
|
376 p2++; if(p2 >=buff_size) p2 -=buff_size;
|
|
|
377 }
|
|
|
378 } while( i<snr );
|
|
|
379
|
|
|
380 *out_prod = snr;
|
|
|
381
|
|
|
382 return( *out_prod );
|
|
|
383 }
|
|
|
384
|
|
|
385
|
|
|
386 int sndstretch_job( // optimized
|
|
|
387 //int sndstretch_optimized( // optimized
|
|
|
388 /* stretches the sound (not changing pitch !!!) */
|
|
|
389 /* returns number of output samples produced */
|
|
|
390 /* chnr simply gives multiples of chnr as snr_prod */
|
|
|
391 s16 * buffer, int buff_size, /* ring buffer */
|
|
|
392 int pos_init, /* only initial pos in ringbuffer */
|
|
|
393 int snr_i, int snr_o, /* enlarge - spec */
|
|
|
394 int chnr, /* # of channels */
|
|
|
395 s16 * outbuff, /* output */
|
|
|
396 int * out_prod, /* # of output-samples produced */
|
|
|
397 int snr_proc, /* # of in-samples to process */
|
|
|
398 int initialize, /* bool */
|
|
|
399 StretchJob * job
|
|
|
400 )
|
|
|
401 {
|
|
|
402 /* static int is_initialized=0;
|
|
|
403 static int snr_o_prod;
|
|
|
404 static int snr_i_act;
|
|
|
405 static int snr_o_act;
|
|
|
406 static int pos_act;
|
|
|
407 static int dsnr;
|
|
|
408 static double snr_rest=0.0;
|
|
|
409
|
|
|
410 static int _RESMAX_div_max, _RESMAX_mod_max;
|
|
|
411 static int fade_in_i, fade_out_i, fade_rest_i;*/
|
|
|
412
|
|
|
413 /* not necessarily static */
|
|
|
414 static int snr;
|
|
|
415 static double snr_d;
|
|
|
416 static int i,p2;
|
|
|
417
|
|
|
418 #define is_initialized (job->is_initialized )
|
|
|
419 #define snr_o_prod (job->snr_o_prod )
|
|
|
420 #define snr_i_act (job->snr_i_act )
|
|
|
421 #define snr_o_act (job->snr_o_act )
|
|
|
422 #define pos_act (job->pos_act )
|
|
|
423 #define dsnr (job->dsnr )
|
|
|
424 #define snr_rest (job->snr_rest )
|
|
|
425 #define _RESMAX_div_max (job->_RESMAX_div_max)
|
|
|
426 #define _RESMAX_mod_max (job->_RESMAX_mod_max)
|
|
|
427 #define fade_in_i (job->fade_in_i )
|
|
|
428 #define fade_out_i (job->fade_out_i )
|
|
|
429 #define fade_rest_i (job->fade_rest_i )
|
|
|
430
|
|
|
431 /* reset */
|
|
|
432 if( !is_initialized || initialize ||
|
|
|
433 snr_i!=snr_i_act || snr_o!=snr_o_act ){
|
|
|
434
|
|
|
435 snr_rest = 0.0;
|
|
|
436 snr_o_prod = 0;
|
|
|
437 snr_i_act = snr_i;
|
|
|
438 snr_o_act = snr_o;
|
|
|
439 dsnr = snr_o_act-snr_i_act;
|
|
|
440 pos_act = pos_init;
|
|
|
441
|
|
|
442 is_initialized = 1;
|
|
|
443
|
|
|
444 }
|
|
|
445
|
|
|
446 snr_d = (double)snr_proc*(double)snr_o_act/(double)snr_i_act
|
|
|
447 + snr_rest;
|
|
|
448 snr = (int) (snr_d) / 2 * 2;
|
|
|
449 snr_rest = snr_d - (double)snr;
|
|
|
450
|
|
|
451 /* produce snr samples */
|
|
|
452 i=0;
|
|
|
453 do {
|
|
|
454 if( snr_o_prod == snr_o_act ) {
|
|
|
455 snr_o_prod=0;
|
|
|
456 pos_act = ringpos( pos_act-dsnr, buff_size );
|
|
|
457 }
|
|
|
458 fade_in_i = RESMAX*((double)snr_o_prod/(double)snr_o_act);
|
|
|
459 fade_out_i = RESMAX-fade_in_i;
|
|
|
460 fade_rest_i= (RESMAX*snr_o_prod)%snr_o_act;
|
|
|
461 _RESMAX_div_max=RESMAX/snr_o_act;
|
|
|
462 _RESMAX_mod_max=RESMAX%snr_o_act;
|
|
|
463 p2=ringpos( pos_act-dsnr, buff_size );
|
|
|
464 for ( ; snr_o_prod < snr_o_act && i<snr ; snr_o_prod++,i++ ){
|
|
|
465 fade_in_i +=_RESMAX_div_max;
|
|
|
466 fade_out_i -=_RESMAX_div_max;
|
|
|
467 fade_rest_i+=_RESMAX_mod_max;
|
|
|
468 if(fade_rest_i>snr_o_act){
|
|
|
469 fade_rest_i-=snr_o_act;
|
|
|
470 fade_in_i++;
|
|
|
471 fade_out_i--;
|
|
|
472 }
|
|
|
473 outbuff[i] = (s16)( (
|
|
|
474 + (int)buffer[pos_act] * fade_out_i
|
|
|
475 + (int)buffer[p2] * fade_in_i
|
|
|
476 ) >> LOG2RESMAX );
|
|
|
477 pos_act++; if(pos_act>=buff_size) pos_act-=buff_size;
|
|
|
478 p2++; if(p2 >=buff_size) p2 -=buff_size;
|
|
|
479 }
|
|
|
480 } while( i<snr );
|
|
|
481
|
|
|
482 *out_prod = snr;
|
|
|
483
|
|
|
484 return( *out_prod );
|
|
|
485
|
|
|
486 #undef is_initialized
|
|
|
487 #undef snr_o_prod
|
|
|
488 #undef snr_i_act
|
|
|
489 #undef snr_o_act
|
|
|
490 #undef pos_act
|
|
|
491 #undef dsnr
|
|
|
492 #undef snr_rest
|
|
|
493 #undef _RESMAX_div_max
|
|
|
494 #undef _RESMAX_mod_max
|
|
|
495 #undef fade_in_i
|
|
|
496 #undef fade_out_i
|
|
|
497 #undef fade_rest_i
|
|
|
498 }
|
|
|
499
|
|
|
500
|
|
|
501 //int sndscale(
|
|
|
502 int sndscale_not_optimized(
|
|
|
503 /* rescales the sound (including pitch) */
|
|
|
504 /* returns number of output samples produced */
|
|
|
505 s16 * buffer, /* ring buffer */
|
|
|
506 int snr_i, int snr_o, /* enlarge - spec */
|
|
|
507 int chnr, /* # of channels */
|
|
|
508 s16 * outbuff, /* output */
|
|
|
509 int * out_prod, /* # of output-samples produced */
|
|
|
510 int snr_proc, /* # of in-samples to process */
|
|
|
511 /* must be manifold of channels */
|
|
|
512 int initialize /* bool */
|
|
|
513 )
|
|
|
514 {
|
|
|
515 static s16 last_samp[10]; /* 10 channels maximum ;) */
|
|
|
516 static double pos_d = 0.0;
|
|
|
517
|
|
|
518 int snr;
|
|
|
519 int pos1, pos2;
|
|
|
520 s16 samp1, samp2;
|
|
|
521 int index1, index2;
|
|
|
522 int ch;
|
|
|
523 double ds;
|
|
|
524 double ratio1, ratio2, outd;
|
|
|
525
|
|
|
526
|
|
|
527 if ( initialize ){
|
|
|
528 for( ch=0; ch<chnr; ch++ ){
|
|
|
529 last_samp[ch] = 0;
|
|
|
530 }
|
|
|
531 pos_d = 0.0;
|
|
|
532 }
|
|
|
533
|
|
|
534 ds = 1.0*(double)snr_i/(double)snr_o;
|
|
|
535
|
|
|
536 /* fprintf(stderr,"ds=%f\n",ds); */
|
|
|
537 /* fprintf(stderr,"pos_d =%f\n",pos_d);*/
|
|
|
538
|
|
|
539 /* produce proper amount of samples */
|
|
|
540 for( snr=0 ; pos_d < snr_proc/chnr-1 ; pos_d+=ds ){
|
|
|
541
|
|
|
542 pos1 = (int)floor(pos_d);
|
|
|
543 pos2 = pos1+1;
|
|
|
544 ratio1 = 1-pos_d+floor(pos_d);
|
|
|
545 ratio2 = pos_d-floor(pos_d);
|
|
|
546
|
|
|
547 for( ch=0; ch<chnr; ch++ ){
|
|
|
548
|
|
|
549 index1 = pos1*chnr+ch;
|
|
|
550 index2 = pos2*chnr+ch;
|
|
|
551
|
|
|
552 samp1 = (pos_d<0) ? last_samp[ch] : buffer[index1] ;
|
|
|
553 samp2 = buffer[index2];
|
|
|
554
|
|
|
555 outd = (double)samp1 * ratio1
|
|
|
556 + (double)samp2 * ratio2 ;
|
|
|
557
|
|
|
558 outbuff[snr+ch] = outd+0.5;
|
|
|
559
|
|
|
560 }
|
|
|
561
|
|
|
562 snr+=chnr;
|
|
|
563
|
|
|
564 }
|
|
|
565
|
|
|
566 pos_d -= (double)(snr_proc/chnr);
|
|
|
567
|
|
|
568 for( ch=0; ch<chnr; ch++ ){
|
|
|
569 last_samp[ch] = buffer[snr_proc-chnr+ch];
|
|
|
570 }
|
|
|
571
|
|
|
572 *out_prod = snr;
|
|
|
573
|
|
|
574 /* fprintf(stderr,"snr = %d\n",snr);*/
|
|
|
575
|
|
|
576 /* last_samp = buffer[snr_proc-1]; */
|
|
|
577
|
|
|
578 return( snr );
|
|
|
579 }
|
|
|
580
|
|
|
581
|
|
|
582
|
|
|
583 int sndscale( //optimized
|
|
|
584 //int sndscale2p_optimized(
|
|
|
585 /* rescales the sound (including pitch) */
|
|
|
586 /* returns number of output samples produced */
|
|
|
587 s16 * buffer, /* ring buffer */
|
|
|
588 int snr_i, int snr_o, /* enlarge - spec snr_o must not exceed RESMAX */
|
|
|
589 int chnr, /* # of channels */
|
|
|
590 s16 * outbuff, /* output */
|
|
|
591 int * out_prod, /* # of output-samples produced */
|
|
|
592 int snr_proc, /* # of in-samples to process */
|
|
|
593 /* must be manifold of channels */
|
|
|
594 int initialize /* bool */
|
|
|
595 )
|
|
|
596 {
|
|
|
597 static s16 last_samp[10]; /* 10 channels maximum ;) */
|
|
|
598 static int pos_rest;
|
|
|
599
|
|
|
600 static int snr;
|
|
|
601 static int pos1, pos2;
|
|
|
602 static int ch;
|
|
|
603 static int ratio1_i;
|
|
|
604 static int ds_li, ds_li_c, ds_rest;
|
|
|
605 static int snr_proc_m_chnr;
|
|
|
606
|
|
|
607
|
|
|
608 if ( initialize ){
|
|
|
609 for( ch=0; ch<chnr; ch++ ){
|
|
|
610 last_samp[ch] = 0;
|
|
|
611 }
|
|
|
612 pos1 = 0;
|
|
|
613 }
|
|
|
614
|
|
|
615 ds_li = snr_i/snr_o;
|
|
|
616 ds_li_c = ds_li*chnr;
|
|
|
617 ds_rest = snr_i%snr_o;
|
|
|
618
|
|
|
619 snr_proc_m_chnr = snr_proc-chnr;
|
|
|
620 for( snr=0 ; pos1 < snr_proc_m_chnr ; pos1+=ds_li_c ){
|
|
|
621
|
|
|
622 pos2 = pos1+chnr;
|
|
|
623 ratio1_i = snr_o-pos_rest;
|
|
|
624
|
|
|
625 if (pos1<0){
|
|
|
626 for( ch=0; ch<chnr; ch++ ){
|
|
|
627 outbuff[snr+ch] = (s16)
|
|
|
628 ( ( (int)last_samp[ch] * ratio1_i +
|
|
|
629 (int)buffer[pos2+ch] * pos_rest ) / snr_o ) ;
|
|
|
630 }
|
|
|
631 } else {
|
|
|
632 for( ch=0; ch<chnr; ch++ ){
|
|
|
633 outbuff[snr+ch] = (s16)
|
|
|
634 ( ( (int)buffer[pos1+ch] * ratio1_i +
|
|
|
635 (int)buffer[pos2+ch] * pos_rest ) / snr_o ) ;
|
|
|
636 }
|
|
|
637 }
|
|
|
638
|
|
|
639 snr+=chnr;
|
|
|
640
|
|
|
641 pos_rest+=ds_rest;
|
|
|
642 if( pos_rest>=snr_o ){ pos_rest-=snr_o; pos1+=chnr; }
|
|
|
643 }
|
|
|
644
|
|
|
645 pos1 -= snr_proc;
|
|
|
646
|
|
|
647 for( ch=0; ch<chnr; ch++ ){
|
|
|
648 last_samp[ch] = buffer[snr_proc-chnr+ch];
|
|
|
649 }
|
|
|
650
|
|
|
651 *out_prod = snr;
|
|
|
652
|
|
|
653 return( snr );
|
|
|
654 }
|
|
|
655
|
|
|
656
|
|
|
657
|
|
|
658 int sndscale_job( //optimized
|
|
|
659 //int sndscale2p_optimized(
|
|
|
660 /* rescales the sound (including pitch) */
|
|
|
661 /* returns number of output samples produced */
|
|
|
662 s16 * buffer, /* ring buffer */
|
|
|
663 int snr_i, int snr_o, /* enlarge - spec snr_o must not exceed RESMAX */
|
|
|
664 int chnr, /* # of channels */
|
|
|
665 s16 * outbuff, /* output */
|
|
|
666 int * out_prod, /* # of output-samples produced */
|
|
|
667 int snr_proc, /* # of in-samples to process */
|
|
|
668 /* must be manifold of channels */
|
|
|
669 int initialize, /* bool */
|
|
|
670 ScaleJob * job
|
|
|
671 )
|
|
|
672 {
|
|
|
673 /* static s16 * last_samp;
|
|
|
674 static int pos_rest;
|
|
|
675
|
|
|
676 static int snr;
|
|
|
677 static int pos1, pos2;
|
|
|
678 static int ch;
|
|
|
679 static int ratio1_i;
|
|
|
680 static int ds_li, ds_li_c, ds_rest;
|
|
|
681 static int snr_proc_m_chnr;*/
|
|
|
682
|
|
|
683 #define last_samp job->last_samp
|
|
|
684 #define pos_rest job->pos_rest
|
|
|
685 #define snr job->snr
|
|
|
686 #define pos1 job->pos1
|
|
|
687 #define pos2 job->pos2
|
|
|
688 #define ch job->ch
|
|
|
689 #define ratio1_i job->ratio1_i
|
|
|
690 #define ds_li job->ds_li
|
|
|
691 #define ds_li_c job->ds_li_c
|
|
|
692 #define ds_rest job->ds_rest
|
|
|
693 #define snr_proc_m_chnr job->snr_proc_m_chnr
|
|
|
694
|
|
|
695 if ( initialize ){
|
|
|
696 for( ch=0; ch<chnr; ch++ ){
|
|
|
697 last_samp[ch] = 0;
|
|
|
698 }
|
|
|
699 pos1 = 0;
|
|
|
700 }
|
|
|
701
|
|
|
702 ds_li = snr_i/snr_o;
|
|
|
703 ds_li_c = ds_li*chnr;
|
|
|
704 ds_rest = snr_i%snr_o;
|
|
|
705
|
|
|
706 snr_proc_m_chnr = snr_proc-chnr;
|
|
|
707 for( snr=0 ; pos1 < snr_proc_m_chnr ; pos1+=ds_li_c ){
|
|
|
708
|
|
|
709 pos2 = pos1+chnr;
|
|
|
710 ratio1_i = snr_o-pos_rest;
|
|
|
711
|
|
|
712 if (pos1<0){
|
|
|
713 for( ch=0; ch<chnr; ch++ ){
|
|
|
714 outbuff[snr+ch] = (s16)
|
|
|
715 ( ( (int)last_samp[ch] * ratio1_i +
|
|
|
716 (int)buffer[pos2+ch] * pos_rest ) / snr_o ) ;
|
|
|
717 }
|
|
|
718 } else {
|
|
|
719 for( ch=0; ch<chnr; ch++ ){
|
|
|
720 outbuff[snr+ch] = (s16)
|
|
|
721 ( ( (int)buffer[pos1+ch] * ratio1_i +
|
|
|
722 (int)buffer[pos2+ch] * pos_rest ) / snr_o ) ;
|
|
|
723 }
|
|
|
724 }
|
|
|
725
|
|
|
726 snr+=chnr;
|
|
|
727
|
|
|
728 pos_rest+=ds_rest;
|
|
|
729 if( pos_rest>=snr_o ){ pos_rest-=snr_o; pos1+=chnr; }
|
|
|
730 }
|
|
|
731
|
|
|
732 pos1 -= snr_proc;
|
|
|
733
|
|
|
734 for( ch=0; ch<chnr; ch++ ){
|
|
|
735 last_samp[ch] = buffer[snr_proc-chnr+ch];
|
|
|
736 }
|
|
|
737
|
|
|
738 *out_prod = snr;
|
|
|
739
|
|
|
740 return( snr );
|
|
|
741
|
|
|
742 #undef last_samp
|
|
|
743 #undef pos_rest
|
|
|
744 #undef snr
|
|
|
745 #undef pos1
|
|
|
746 #undef pos2
|
|
|
747 #undef ch
|
|
|
748 #undef ratio1_i
|
|
|
749 #undef ds_li
|
|
|
750 #undef ds_li_c
|
|
|
751 #undef ds_rest
|
|
|
752 #undef snr_proc_m_chnr
|
|
|
753 }
|
|
|
754
|
|
|
755
|
|
|
756
|
|
|
757 int snd_pitch_speed(
|
|
|
758 /* input */
|
|
|
759 s16 *buff_i, int channels, int snr_proc,
|
|
|
760 /* algorihm parameters */
|
|
|
761 int initialize, double pitch, double speed, int fade_shift,
|
|
|
762 /* output */
|
|
|
763 s16 * buff_o, int * snr_produced
|
|
|
764 )
|
|
|
765 {
|
|
|
766 static s16 * ring_buff = (s16*)0;
|
|
|
767 static s16 * ring_buff_old = (s16*)0;
|
|
|
768 static s16 * buff_help = (s16*)0;
|
|
|
769 static int ring_size = 1;
|
|
|
770 static int ring_size_old = 0;
|
|
|
771 static int ring_pos_w = 0;
|
|
|
772 static int ring_pos_r = 0;
|
|
|
773 static int snr_scale_i;
|
|
|
774 static int snr_scale_o;
|
|
|
775 static int snr_stretch_i;
|
|
|
776 static int snr_stretch_o;
|
|
|
777 static int snr_proc_scale;
|
|
|
778 static int snr_proc_stretch;
|
|
|
779 static int is_init = 0;
|
|
|
780 static int dsnr;
|
|
|
781 static double speed_act = 0;
|
|
|
782 static double pitch_act = 0;
|
|
|
783 static double fade_shift_act = 0;
|
|
|
784
|
|
|
785 int snr_prod;
|
|
|
786 double speed_eff;
|
|
|
787 double pitch_eff;
|
|
|
788 int scaling_first;
|
|
|
789 int snr_stretching_i_max;
|
|
|
790 int snr_stretching_o_max;
|
|
|
791
|
|
|
792 // int channels = 2;
|
|
|
793 int init_me = 0;
|
|
|
794
|
|
|
795 speed_eff = speed/pitch;
|
|
|
796 pitch_eff = pitch;
|
|
|
797
|
|
|
798 scaling_first=0;
|
|
|
799 // if( pitch > 1.0 ) scaling_first=0; else scaling_first=1;
|
|
|
800
|
|
|
801 if ( !is_init || initialize || speed!=speed_act || pitch!=pitch_act ||
|
|
|
802 fade_shift!=fade_shift_act ){
|
|
|
803
|
|
|
804 if( !is_init || initialize ) init_me=1; else init_me=0;
|
|
|
805
|
|
|
806 #ifdef DEBUG
|
|
|
807 fprintf(stderr,"snd_stretch_scale - init - pitch:%f, speed:%f\n",pitch,speed);
|
|
|
808 #endif
|
|
|
809
|
|
|
810 speed_act = speed;
|
|
|
811 pitch_act = pitch;
|
|
|
812 fade_shift_act = fade_shift;
|
|
|
813
|
|
|
814 // if (ring_buff!=0) free(ring_buff);
|
|
|
815 // if (buff_help!=0) free(buff_help);
|
|
|
816
|
|
|
817 if (initialize != -1){
|
|
|
818
|
|
|
819 dsnr = fade_shift;
|
|
|
820 // dsnr = 1764; // 25Hz
|
|
|
821 // dsnr = 1536; // 30Hz
|
|
|
822 // dsnr = 1102; // 40Hz
|
|
|
823 // dsnr = 882; // 50Hz
|
|
|
824
|
|
|
825 if( scaling_first ){
|
|
|
826 snr_stretching_i_max = ceil((double)snr_proc/pitch_act);
|
|
|
827 snr_stretching_i_max += channels-1;
|
|
|
828 snr_stretching_i_max /= channels;
|
|
|
829 snr_stretching_i_max *= channels;
|
|
|
830 } else {
|
|
|
831 snr_stretching_i_max = (snr_proc+channels-1)/channels*channels;
|
|
|
832 }
|
|
|
833
|
|
|
834 snr_stretching_o_max =
|
|
|
835 ceil((double)snr_stretching_i_max / speed_eff);
|
|
|
836 snr_stretching_o_max =
|
|
|
837 (snr_stretching_o_max+channels-1)/channels*channels;
|
|
|
838
|
|
|
839 ring_size = snr_stretching_o_max /* for reading */
|
|
|
840 + dsnr*channels /* for grabbing back */
|
|
|
841 + dsnr*channels /* for readpos catching */
|
|
|
842 /* up with writepos */
|
|
|
843 + 2*dsnr*channels ; /* for 2 pre - echos */
|
|
|
844 // ring_size = snr_stretching_o_max+3*dsnr*channels;
|
|
|
845
|
|
|
846 if( ring_size <= ring_size_old ){
|
|
|
847 ring_size = ring_size_old;
|
|
|
848 #ifdef DEBUG
|
|
|
849 fprintf(stderr," ring_size = %d \n",ring_size);
|
|
|
850 #endif
|
|
|
851 } else {
|
|
|
852 /* if (ring_buff!=0) free(ring_buff);
|
|
|
853 if (buff_help!=0) free(buff_help);
|
|
|
854 ring_buff = calloc( ring_size, sizeof(s16) );
|
|
|
855 buff_help = calloc( 65536, sizeof(s16) );
|
|
|
856 ring_pos_r = 0;*/
|
|
|
857 if (buff_help!=0) free(buff_help);
|
|
|
858 ring_buff_old = ring_buff;
|
|
|
859 ring_buff = calloc( ring_size, sizeof(s16) );
|
|
|
860 buff_help = calloc( 65536, sizeof(s16) );
|
|
|
861 if (ring_buff_old!=0) ringcopy( ring_buff, ring_size, ring_pos_r, ring_pos_w, ring_buff_old, ring_size_old, ring_pos_r );
|
|
|
862 if (ring_buff_old!=0) free(ring_buff_old);
|
|
|
863 // ring_pos_w=ringpos(ring_pos_w+ring_size_old,ring_size);
|
|
|
864 #ifdef DEBUG
|
|
|
865 fprintf(stderr," %d s16-samples reserved\n",ring_size);
|
|
|
866 #endif
|
|
|
867 }
|
|
|
868
|
|
|
869 ring_pos_w =
|
|
|
870 ringpos( ring_pos_r + /* base */
|
|
|
871 dsnr*channels /* for grabing back */
|
|
|
872 // dsnr*2 /* for grabing back */ // why *2
|
|
|
873 , ring_size );
|
|
|
874 #ifdef DEBUG
|
|
|
875 fprintf(stderr," ring_pos_w = %d\n",ring_pos_w);
|
|
|
876 #endif
|
|
|
877 ring_pos_w = (ring_pos_w+(channels-1))/channels*channels;
|
|
|
878
|
|
|
879 ring_size_old = ring_size;
|
|
|
880
|
|
|
881 is_init = 1;
|
|
|
882
|
|
|
883 } else { /* initialize == -1 */
|
|
|
884 if (ring_buff!=0) free(ring_buff);
|
|
|
885 if (buff_help!=0) free(buff_help);
|
|
|
886 /* buffers are released -> leave the function */
|
|
|
887 return 0; /* !!! sloppy */
|
|
|
888 }
|
|
|
889
|
|
|
890 }
|
|
|
891
|
|
|
892 if ( fabs(speed_eff-1.0)>0.001 ){ /*
|
|
|
893 0.001 ?!
|
|
|
894 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
895 this should be examined to the limits
|
|
|
896 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
897 */
|
|
|
898 snr_stretch_i = (double)dsnr/(1.0/speed_eff-1.0);
|
|
|
899 snr_stretch_o = fabs(snr_stretch_i + dsnr);
|
|
|
900 snr_stretch_i = abs(snr_stretch_i);
|
|
|
901 // fprintf(stderr,"snd_stretch_scale - snr_str_i=%d\n",snr_stretch_i);
|
|
|
902 // fprintf(stderr,"snd_stretch_scale - snr_str_o=%d\n",snr_stretch_o);
|
|
|
903 } else {
|
|
|
904 snr_stretch_i = 10;
|
|
|
905 snr_stretch_o = 10;
|
|
|
906 }
|
|
|
907
|
|
|
908 if ( pitch_eff!=1.0 ){
|
|
|
909 snr_scale_i = (double)dsnr/(1.0/pitch_eff-1.0);
|
|
|
910 snr_scale_o = fabs(snr_scale_i + dsnr);
|
|
|
911 snr_scale_i = abs(snr_scale_i);
|
|
|
912 if( 1 /* optimized version doesnt support all scaling */ ){
|
|
|
913 if( snr_scale_o > 65536 ){
|
|
|
914 snr_scale_i = (int)((double)snr_scale_i*((double)65536/(double)snr_scale_o)+0.5);
|
|
|
915 snr_scale_o = 65536;
|
|
|
916 // make sure that snr_o for sndscale wont exceed 2^16
|
|
|
917 }
|
|
|
918 }
|
|
|
919 // fprintf(stderr,"snd_stretch_scale - snr_sc_i=%d\n",snr_stretch_i);
|
|
|
920 // fprintf(stderr,"snd_stretch_scale - snr_sc_o=%d\n",snr_stretch_o);
|
|
|
921 } else {
|
|
|
922 // fprintf(stderr,"snd_stretch_scale - snr_scale_i=snr_scale_o=10\n");
|
|
|
923 snr_scale_i = 65536;
|
|
|
924 snr_scale_o = 65536;
|
|
|
925 }
|
|
|
926
|
|
|
927 if( 0/*scaling_first*/ ){
|
|
|
928
|
|
|
929 snr_proc_scale = snr_proc;
|
|
|
930 sndscale ( buff_i,
|
|
|
931 snr_scale_i, snr_scale_o, channels,
|
|
|
932 buff_help, &snr_prod, snr_proc_scale, init_me );
|
|
|
933 /* buff_o, &snr_prod, snr_proc_scale, 0 ); */
|
|
|
934
|
|
|
935 if( speed_eff!=1.0 ){ /* add echo only when really stretching */
|
|
|
936 ringload_IIR_1_div_e_echo_i( ring_buff, ring_size, ring_pos_w, buff_help, snr_prod, dsnr*channels );
|
|
|
937 } else {
|
|
|
938 ringload( ring_buff, ring_size, ring_pos_w, buff_help, snr_prod );
|
|
|
939 }
|
|
|
940 ring_pos_w = ringpos( ring_pos_w+snr_prod, ring_size );
|
|
|
941
|
|
|
942 snr_proc_stretch = snr_prod;
|
|
|
943 sndstretch ( ring_buff, ring_size, ring_pos_r,
|
|
|
944 snr_stretch_i*channels, snr_stretch_o*channels, channels,
|
|
|
945 buff_o, &snr_prod, snr_proc_stretch, init_me );
|
|
|
946
|
|
|
947 ring_pos_r = ringpos( ring_pos_r+snr_prod, ring_size );
|
|
|
948
|
|
|
949 } else {
|
|
|
950
|
|
|
951 // fprintf(stderr,"sndstretch: ring_pos_r = %d\n",ring_pos_r);
|
|
|
952 // fprintf(stderr,"sndstretch: ring_pos_w = %d\n\n",ring_pos_w);
|
|
|
953 snr_prod = snr_proc;
|
|
|
954 if( speed_eff!=1.0 ){ /* add echo only when really stretching */
|
|
|
955 ringload_IIR_1_div_e_echo_i( ring_buff, ring_size, ring_pos_w, buff_i, snr_proc, dsnr*channels );
|
|
|
956 } else {
|
|
|
957 ringload( ring_buff, ring_size, ring_pos_w, buff_i, snr_proc );
|
|
|
958 }
|
|
|
959 ring_pos_w = ringpos( ring_pos_w+snr_proc, ring_size );
|
|
|
960
|
|
|
961 snr_proc_stretch = snr_proc;
|
|
|
962 sndstretch ( ring_buff, ring_size, ring_pos_r,
|
|
|
963 snr_stretch_i*channels, snr_stretch_o*channels, channels,
|
|
|
964 buff_help, &snr_prod, snr_proc_stretch, init_me );
|
|
|
965
|
|
|
966 ring_pos_r = ringpos( ring_pos_r+snr_prod, ring_size );
|
|
|
967
|
|
|
968 snr_proc_scale = snr_prod;
|
|
|
969 // fprintf(stderr,"snr_scale_i, snr_scale_o = %d,%d\n",snr_scale_i, snr_scale_o);
|
|
|
970 sndscale ( buff_help,
|
|
|
971 snr_scale_i, snr_scale_o, channels,
|
|
|
972 buff_o, &snr_prod, snr_proc_scale, init_me );
|
|
|
973
|
|
|
974 }
|
|
|
975
|
|
|
976 *snr_produced = snr_prod;
|
|
|
977
|
|
|
978 return snr_prod;
|
|
|
979 }
|
|
|
980
|
|
|
981
|
|
|
982 int snd_pitch_speed_job(
|
|
|
983 /* input */
|
|
|
984 s16 *buff_i, int channels, int snr_proc,
|
|
|
985 /* algorihm parameters */
|
|
|
986 int initialize, double pitch, double speed, int fade_shift,
|
|
|
987 /* output */
|
|
|
988 s16 * buff_o, int * snr_produced, PitchSpeedJob * job,
|
|
|
989 int vol_corr
|
|
|
990 )
|
|
|
991 {
|
|
|
992 /* static s16 * ring_buff = (s16*)0;
|
|
|
993 static s16 * ring_buff_old = (s16*)0;
|
|
|
994 static s16 * buff_help = (s16*)0;
|
|
|
995 static int ring_size = 1;
|
|
|
996 static int ring_size_old = 0;
|
|
|
997 static int ring_pos_w = 0;
|
|
|
998 static int ring_pos_r = 0;
|
|
|
999 static int snr_scale_i;
|
|
|
1000 static int snr_scale_o;
|
|
|
1001 static int snr_stretch_i;
|
|
|
1002 static int snr_stretch_o;
|
|
|
1003 static int snr_proc_scale;
|
|
|
1004 static int snr_proc_stretch;
|
|
|
1005 static int is_init = 0;
|
|
|
1006 static int dsnr;
|
|
|
1007 static double speed_act = 0;
|
|
|
1008 static double pitch_act = 0;*/
|
|
|
1009
|
|
|
1010 int snr_prod;
|
|
|
1011 double speed_eff;
|
|
|
1012 double pitch_eff;
|
|
|
1013 int scaling_first;
|
|
|
1014 int snr_stretching_i_max;
|
|
|
1015 int snr_stretching_o_max;
|
|
|
1016
|
|
|
1017 // int channels = 2;
|
|
|
1018 int init_me = 0;
|
|
|
1019
|
|
|
1020 #define ring_buff job->ring_buff
|
|
|
1021 #define ring_buff_old job->ring_buff_old
|
|
|
1022 #define buff_help job->buff_help
|
|
|
1023 #define ring_size job->ring_size
|
|
|
1024 #define ring_size_old job->ring_size_old
|
|
|
1025 #define ring_pos_w job->ring_pos_w
|
|
|
1026 #define ring_pos_r job->ring_pos_r
|
|
|
1027 #define snr_scale_i job->snr_scale_i
|
|
|
1028 #define snr_scale_o job->snr_scale_o
|
|
|
1029 #define snr_stretch_i job->snr_stretch_i
|
|
|
1030 #define snr_stretch_o job->snr_stretch_o
|
|
|
1031 #define snr_proc_scale job->snr_proc_scale
|
|
|
1032 #define snr_proc_stretch job->snr_proc_stretch
|
|
|
1033 #define is_init job->is_init
|
|
|
1034 #define dsnr job->dsnr
|
|
|
1035 #define speed_act job->speed_act
|
|
|
1036 #define pitch_act job->pitch_act
|
|
|
1037 #define fade_shift_act job->fade_shift_act
|
|
|
1038
|
|
|
1039 speed_eff = speed/pitch;
|
|
|
1040 pitch_eff = pitch;
|
|
|
1041
|
|
|
1042 scaling_first=0;
|
|
|
1043 // if( pitch > 1.0 ) scaling_first=0; else scaling_first=1;
|
|
|
1044
|
|
|
1045 if ( !is_init || initialize || speed!=speed_act || pitch!=pitch_act ||
|
|
|
1046 fade_shift != fade_shift_act ){
|
|
|
1047
|
|
|
1048 if( !is_init || initialize ) init_me=1; else init_me=0;
|
|
|
1049
|
|
|
1050 #ifdef DEBUG
|
|
|
1051 fprintf(stderr,"snd_stretch_scale - init - pitch:%f, speed:%f\n",pitch,speed);
|
|
|
1052 #endif
|
|
|
1053
|
|
|
1054 speed_act = speed;
|
|
|
1055 pitch_act = pitch;
|
|
|
1056 if ( fade_shift != fade_shift_act ){
|
|
|
1057 fprintf(stderr,"changed fade_shift_act\n");
|
|
|
1058 }
|
|
|
1059 fade_shift_act = fade_shift;
|
|
|
1060
|
|
|
1061 // if (ring_buff!=0) free(ring_buff);
|
|
|
1062 // if (buff_help!=0) free(buff_help);
|
|
|
1063
|
|
|
1064 if (initialize != -1){
|
|
|
1065
|
|
|
1066 dsnr = fade_shift;
|
|
|
1067 // dsnr = 1764; // 25Hz
|
|
|
1068 // dsnr = 1536; // 30Hz
|
|
|
1069 // dsnr = 1102; // 40Hz
|
|
|
1070 // dsnr = 882; // 50Hz
|
|
|
1071
|
|
|
1072 if( scaling_first ){
|
|
|
1073 snr_stretching_i_max = ceil((double)snr_proc/pitch_act);
|
|
|
1074 snr_stretching_i_max += channels-1;
|
|
|
1075 snr_stretching_i_max /= channels;
|
|
|
1076 snr_stretching_i_max *= channels;
|
|
|
1077 } else {
|
|
|
1078 snr_stretching_i_max = (snr_proc+channels-1)/channels*channels;
|
|
|
1079 }
|
|
|
1080
|
|
|
1081 snr_stretching_o_max =
|
|
|
1082 ceil((double)snr_stretching_i_max / speed_eff);
|
|
|
1083 snr_stretching_o_max =
|
|
|
1084 (snr_stretching_o_max+channels-1)/channels*channels;
|
|
|
1085
|
|
|
1086 ring_size = snr_stretching_o_max /* for reading */
|
|
|
1087 + dsnr*channels /* for grabbing back */
|
|
|
1088 + dsnr*channels /* for readpos catching */
|
|
|
1089 /* up with writepos */
|
|
|
1090 + 2*dsnr*channels ; /* for 2 pre - echos */
|
|
|
1091 // ring_size = snr_stretching_o_max+3*dsnr*channels;
|
|
|
1092
|
|
|
1093 if( ring_size <= ring_size_old ){
|
|
|
1094 ring_size = ring_size_old;
|
|
|
1095 #ifdef DEBUG
|
|
|
1096 fprintf(stderr," ring_size = %d \n",ring_size);
|
|
|
1097 #endif
|
|
|
1098 } else {
|
|
|
1099 /* if (ring_buff!=0) free(ring_buff);
|
|
|
1100 if (buff_help!=0) free(buff_help);
|
|
|
1101 ring_buff = calloc( ring_size, sizeof(s16) );
|
|
|
1102 buff_help = calloc( 65536, sizeof(s16) );
|
|
|
1103 ring_pos_r = 0;*/
|
|
|
1104 if (buff_help!=0) free(buff_help);
|
|
|
1105 ring_buff_old = ring_buff;
|
|
|
1106 ring_buff = calloc( ring_size, sizeof(s16) );
|
|
|
1107 buff_help = calloc( 65536, sizeof(s16) );
|
|
|
1108 if (ring_buff_old!=0) ringcopy( ring_buff, ring_size, ring_pos_r, ring_pos_w, ring_buff_old, ring_size_old, ring_pos_r );
|
|
|
1109 if (ring_buff_old!=0) free(ring_buff_old);
|
|
|
1110 // ring_pos_w=ringpos(ring_pos_w+ring_size_old,ring_size);
|
|
|
1111 #ifdef DEBUG
|
|
|
1112 fprintf(stderr," %d s16-samples reserved\n",ring_size);
|
|
|
1113 #endif
|
|
|
1114 }
|
|
|
1115
|
|
|
1116 ring_pos_w =
|
|
|
1117 ringpos( ring_pos_r + /* base */
|
|
|
1118 dsnr*channels /* for grabing back */
|
|
|
1119 // dsnr*2 /* for grabing back */ // why *2
|
|
|
1120 , ring_size );
|
|
|
1121 #ifdef DEBUG
|
|
|
1122 fprintf(stderr," ring_pos_w = %d\n",ring_pos_w);
|
|
|
1123 #endif
|
|
|
1124 ring_pos_w = (ring_pos_w+(channels-1))/channels*channels;
|
|
|
1125
|
|
|
1126 ring_size_old = ring_size;
|
|
|
1127
|
|
|
1128 is_init = 1;
|
|
|
1129
|
|
|
1130 } else { /* initialize == -1 */
|
|
|
1131 if (ring_buff!=0) free(ring_buff);
|
|
|
1132 if (buff_help!=0) free(buff_help);
|
|
|
1133 /* buffers are released -> leave the function */
|
|
|
1134 return 0; /* !!! sloppy */
|
|
|
1135 }
|
|
|
1136
|
|
|
1137 }
|
|
|
1138
|
|
|
1139 if ( fabs(speed_eff-1.0)>0.001 ){ /*
|
|
|
1140 0.001 ?!
|
|
|
1141 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
1142 this should be examined to the limits
|
|
|
1143 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
1144 */
|
|
|
1145 snr_stretch_i = (double)dsnr/(1.0/speed_eff-1.0);
|
|
|
1146 snr_stretch_o = fabs(snr_stretch_i + dsnr);
|
|
|
1147 snr_stretch_i = abs(snr_stretch_i);
|
|
|
1148 // fprintf(stderr,"snd_stretch_scale - snr_str_i=%d\n",snr_stretch_i);
|
|
|
1149 // fprintf(stderr,"snd_stretch_scale - snr_str_o=%d\n",snr_stretch_o);
|
|
|
1150 } else {
|
|
|
1151 snr_stretch_i = 10;
|
|
|
1152 snr_stretch_o = 10;
|
|
|
1153 }
|
|
|
1154
|
|
|
1155 if ( pitch_eff!=1.0 ){
|
|
|
1156 snr_scale_i = (double)dsnr/(1.0/pitch_eff-1.0);
|
|
|
1157 snr_scale_o = fabs(snr_scale_i + dsnr);
|
|
|
1158 snr_scale_i = abs(snr_scale_i);
|
|
|
1159 if( 1 /* optimized version doesnt support all scaling */ ){
|
|
|
1160 if( snr_scale_o > 65536 ){
|
|
|
1161 snr_scale_i = (int)((double)snr_scale_i*((double)65536/(double)snr_scale_o)+0.5);
|
|
|
1162 snr_scale_o = 65536;
|
|
|
1163 // make sure that snr_o for sndscale wont exceed 2^16
|
|
|
1164 }
|
|
|
1165 }
|
|
|
1166 // fprintf(stderr,"snd_stretch_scale - snr_sc_i=%d\n",snr_stretch_i);
|
|
|
1167 // fprintf(stderr,"snd_stretch_scale - snr_sc_o=%d\n",snr_stretch_o);
|
|
|
1168 } else {
|
|
|
1169 // fprintf(stderr,"snd_stretch_scale - snr_scale_i=snr_scale_o=10\n");
|
|
|
1170 snr_scale_i = 65536;
|
|
|
1171 snr_scale_o = 65536;
|
|
|
1172 }
|
|
|
1173
|
|
|
1174 if( 0/*scaling_first*/ ){
|
|
|
1175
|
|
|
1176 snr_proc_scale = snr_proc;
|
|
|
1177 sndscale_job ( buff_i,
|
|
|
1178 snr_scale_i, snr_scale_o, channels,
|
|
|
1179 buff_help, &snr_prod, snr_proc_scale, init_me,
|
|
|
1180 &(job->scale_job) );
|
|
|
1181 /* buff_o, &snr_prod, snr_proc_scale, 0 ); */
|
|
|
1182
|
|
|
1183 if( speed_eff!=1.0 ){ /* add echo only when really stretching */
|
|
|
1184 if( !vol_corr ){
|
|
|
1185 ringload_IIR_1_div_e_echo_i( ring_buff, ring_size, ring_pos_w, buff_help, snr_prod, dsnr*channels );
|
|
|
1186 } else {
|
|
|
1187 ringload_IIR_1_div_e_echo_i_vc( ring_buff, ring_size, ring_pos_w, buff_help, snr_prod, dsnr*channels );
|
|
|
1188 }
|
|
|
1189 } else {
|
|
|
1190 ringload( ring_buff, ring_size, ring_pos_w, buff_help, snr_prod );
|
|
|
1191 }
|
|
|
1192 ring_pos_w = ringpos( ring_pos_w+snr_prod, ring_size );
|
|
|
1193
|
|
|
1194 snr_proc_stretch = snr_prod;
|
|
|
1195 sndstretch_job ( ring_buff, ring_size, ring_pos_r,
|
|
|
1196 snr_stretch_i*channels, snr_stretch_o*channels, channels,
|
|
|
1197 buff_o, &snr_prod, snr_proc_stretch, init_me,
|
|
|
1198 &(job->stretch_job)
|
|
|
1199 );
|
|
|
1200
|
|
|
1201 ring_pos_r = ringpos( ring_pos_r+snr_prod, ring_size );
|
|
|
1202
|
|
|
1203 } else {
|
|
|
1204
|
|
|
1205 // fprintf(stderr,"sndstretch: ring_pos_r = %d\n",ring_pos_r);
|
|
|
1206 // fprintf(stderr,"sndstretch: ring_pos_w = %d\n\n",ring_pos_w);
|
|
|
1207 snr_prod = snr_proc;
|
|
|
1208 if( speed_eff!=1.0 ){ /* add echo only when really stretching */
|
|
|
1209 if( !vol_corr ){
|
|
|
1210 ringload_IIR_1_div_e_echo_i( ring_buff, ring_size, ring_pos_w, buff_i, snr_proc, dsnr*channels );
|
|
|
1211 }else{
|
|
|
1212 ringload_IIR_1_div_e_echo_i_vc( ring_buff, ring_size, ring_pos_w, buff_i, snr_proc, dsnr*channels );
|
|
|
1213 }
|
|
|
1214 } else {
|
|
|
1215 ringload( ring_buff, ring_size, ring_pos_w, buff_i, snr_proc );
|
|
|
1216 }
|
|
|
1217 ring_pos_w = ringpos( ring_pos_w+snr_proc, ring_size );
|
|
|
1218
|
|
|
1219 snr_proc_stretch = snr_proc;
|
|
|
1220 sndstretch_job ( ring_buff, ring_size, ring_pos_r,
|
|
|
1221 snr_stretch_i*channels, snr_stretch_o*channels, channels,
|
|
|
1222 buff_help, &snr_prod, snr_proc_stretch, init_me,
|
|
|
1223 &(job->stretch_job)
|
|
|
1224 );
|
|
|
1225
|
|
|
1226 ring_pos_r = ringpos( ring_pos_r+snr_prod, ring_size );
|
|
|
1227
|
|
|
1228 snr_proc_scale = snr_prod;
|
|
|
1229 // fprintf(stderr,"snr_scale_i, snr_scale_o = %d,%d\n",snr_scale_i, snr_scale_o);
|
|
|
1230 sndscale_job ( buff_help,
|
|
|
1231 snr_scale_i, snr_scale_o, channels,
|
|
|
1232 buff_o, &snr_prod, snr_proc_scale, init_me,
|
|
|
1233 &(job->scale_job)
|
|
|
1234 );
|
|
|
1235
|
|
|
1236 }
|
|
|
1237
|
|
|
1238 *snr_produced = snr_prod;
|
|
|
1239
|
|
|
1240 return snr_prod;
|
|
|
1241 #undef ring_buff
|
|
|
1242 #undef ring_buff_old
|
|
|
1243 #undef buff_help
|
|
|
1244 #undef ring_size
|
|
|
1245 #undef ring_size_old
|
|
|
1246 #undef ring_pos_w
|
|
|
1247 #undef ring_pos_r
|
|
|
1248 #undef snr_scale_i
|
|
|
1249 #undef snr_scale_o
|
|
|
1250 #undef snr_stretch_i
|
|
|
1251 #undef snr_stretch_o
|
|
|
1252 #undef snr_proc_scale
|
|
|
1253 #undef snr_proc_stretch
|
|
|
1254 #undef is_init
|
|
|
1255 #undef dsnr
|
|
|
1256 #undef speed_act
|
|
|
1257 #undef pitch_act
|
|
|
1258 #undef fade_shift_act
|
|
|
1259 }
|
|
|
1260
|
|
|
1261
|
|
|
1262 int snd_stretch_scale(s16 *buff_i, s16 * buff_o,
|
|
|
1263 double pitch, double speed, int channels,
|
|
|
1264 int snr_proc, int * snr_produced, int initialize
|
|
|
1265 )
|
|
|
1266 {
|
|
|
1267 return snd_pitch_speed(
|
|
|
1268 /* input */
|
|
|
1269 buff_i, channels, snr_proc,
|
|
|
1270 /* algorihm parameters */
|
|
|
1271 initialize, pitch, speed, 1764,
|
|
|
1272 /* output */
|
|
|
1273 buff_o, snr_produced
|
|
|
1274 );
|
|
|
1275 }
|
|
|
1276
|
|
|
1277
|
|
|
1278 int snd_stretch_scale_job(s16 *buff_i, s16 * buff_o,
|
|
|
1279 double pitch, double speed, int channels,
|
|
|
1280 int snr_proc, int * snr_produced, int initialize,
|
|
|
1281 PitchSpeedJob * job, int init_job)
|
|
|
1282 /* init_job should be set to one the first time the routine is called with
|
|
|
1283 the actual job (e.g. for creating a new job) */
|
|
|
1284 {
|
|
|
1285 if(init_job){
|
|
|
1286 InitPitchSpeedJob(job);
|
|
|
1287 }
|
|
|
1288 return snd_pitch_speed_job(
|
|
|
1289 /* input */
|
|
|
1290 buff_i, channels, snr_proc,
|
|
|
1291 /* algorihm parameters */
|
|
|
1292 initialize, pitch, speed, 1764 ,
|
|
|
1293 /* output */
|
|
|
1294 buff_o, snr_produced,
|
|
|
1295 /* job data */
|
|
|
1296 job, 0
|
|
|
1297 );
|
|
|
1298 }
|
