1
2 /* audioopmodule - Module to detect peak values in arrays */
3
4 #include "Python.h"
5
6 #if SIZEOF_INT == 4
7 typedef int Py_Int32;
8 typedef unsigned int Py_UInt32;
9 #else
10 #if SIZEOF_LONG == 4
11 typedef long Py_Int32;
12 typedef unsigned long Py_UInt32;
13 #else
14 #error "No 4-byte integral type"
15 #endif
16 #endif
17
18 typedef short PyInt16;
19
20 #if defined(__CHAR_UNSIGNED__)
21 #if defined(signed)
22 /* This module currently does not work on systems where only unsigned
23 characters are available. Take it out of Setup. Sorry. */
24 #endif
25 #endif
26
27 static const int maxvals[] = {0, 0x7F, 0x7FFF, 0x7FFFFF, 0x7FFFFFFF};
28 /* -1 trick is needed on Windows to support -0x80000000 without a warning */
29 static const int minvals[] = {0, -0x80, -0x8000, -0x800000, -0x7FFFFFFF-1};
30 static const unsigned int masks[] = {0, 0xFF, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF};
31
32 static int
fbound(double val,double minval,double maxval)33 fbound(double val, double minval, double maxval)
34 {
35 if (val > maxval) {
36 val = maxval;
37 }
38 else if (val < minval + 1.0) {
39 val = minval;
40 }
41
42 /* Round towards minus infinity (-inf) */
43 val = floor(val);
44
45 /* Cast double to integer: round towards zero */
46 return (int)val;
47 }
48
49
50 /* Code shamelessly stolen from sox, 12.17.7, g711.c
51 ** (c) Craig Reese, Joe Campbell and Jeff Poskanzer 1989 */
52
53 /* From g711.c:
54 *
55 * December 30, 1994:
56 * Functions linear2alaw, linear2ulaw have been updated to correctly
57 * convert unquantized 16 bit values.
58 * Tables for direct u- to A-law and A- to u-law conversions have been
59 * corrected.
60 * Borge Lindberg, Center for PersonKommunikation, Aalborg University.
61 * bli@cpk.auc.dk
62 *
63 */
64 #define BIAS 0x84 /* define the add-in bias for 16 bit samples */
65 #define CLIP 32635
66 #define SIGN_BIT (0x80) /* Sign bit for an A-law byte. */
67 #define QUANT_MASK (0xf) /* Quantization field mask. */
68 #define SEG_SHIFT (4) /* Left shift for segment number. */
69 #define SEG_MASK (0x70) /* Segment field mask. */
70
71 static PyInt16 seg_aend[8] = {0x1F, 0x3F, 0x7F, 0xFF,
72 0x1FF, 0x3FF, 0x7FF, 0xFFF};
73 static PyInt16 seg_uend[8] = {0x3F, 0x7F, 0xFF, 0x1FF,
74 0x3FF, 0x7FF, 0xFFF, 0x1FFF};
75
76 static PyInt16
search(PyInt16 val,PyInt16 * table,int size)77 search(PyInt16 val, PyInt16 *table, int size)
78 {
79 int i;
80
81 for (i = 0; i < size; i++) {
82 if (val <= *table++)
83 return (i);
84 }
85 return (size);
86 }
87 #define st_ulaw2linear16(uc) (_st_ulaw2linear16[uc])
88 #define st_alaw2linear16(uc) (_st_alaw2linear16[uc])
89
90 static PyInt16 _st_ulaw2linear16[256] = {
91 -32124, -31100, -30076, -29052, -28028, -27004, -25980,
92 -24956, -23932, -22908, -21884, -20860, -19836, -18812,
93 -17788, -16764, -15996, -15484, -14972, -14460, -13948,
94 -13436, -12924, -12412, -11900, -11388, -10876, -10364,
95 -9852, -9340, -8828, -8316, -7932, -7676, -7420,
96 -7164, -6908, -6652, -6396, -6140, -5884, -5628,
97 -5372, -5116, -4860, -4604, -4348, -4092, -3900,
98 -3772, -3644, -3516, -3388, -3260, -3132, -3004,
99 -2876, -2748, -2620, -2492, -2364, -2236, -2108,
100 -1980, -1884, -1820, -1756, -1692, -1628, -1564,
101 -1500, -1436, -1372, -1308, -1244, -1180, -1116,
102 -1052, -988, -924, -876, -844, -812, -780,
103 -748, -716, -684, -652, -620, -588, -556,
104 -524, -492, -460, -428, -396, -372, -356,
105 -340, -324, -308, -292, -276, -260, -244,
106 -228, -212, -196, -180, -164, -148, -132,
107 -120, -112, -104, -96, -88, -80, -72,
108 -64, -56, -48, -40, -32, -24, -16,
109 -8, 0, 32124, 31100, 30076, 29052, 28028,
110 27004, 25980, 24956, 23932, 22908, 21884, 20860,
111 19836, 18812, 17788, 16764, 15996, 15484, 14972,
112 14460, 13948, 13436, 12924, 12412, 11900, 11388,
113 10876, 10364, 9852, 9340, 8828, 8316, 7932,
114 7676, 7420, 7164, 6908, 6652, 6396, 6140,
115 5884, 5628, 5372, 5116, 4860, 4604, 4348,
116 4092, 3900, 3772, 3644, 3516, 3388, 3260,
117 3132, 3004, 2876, 2748, 2620, 2492, 2364,
118 2236, 2108, 1980, 1884, 1820, 1756, 1692,
119 1628, 1564, 1500, 1436, 1372, 1308, 1244,
120 1180, 1116, 1052, 988, 924, 876, 844,
121 812, 780, 748, 716, 684, 652, 620,
122 588, 556, 524, 492, 460, 428, 396,
123 372, 356, 340, 324, 308, 292, 276,
124 260, 244, 228, 212, 196, 180, 164,
125 148, 132, 120, 112, 104, 96, 88,
126 80, 72, 64, 56, 48, 40, 32,
127 24, 16, 8, 0
128 };
129
130 /*
131 * linear2ulaw() accepts a 14-bit signed integer and encodes it as u-law data
132 * stored in an unsigned char. This function should only be called with
133 * the data shifted such that it only contains information in the lower
134 * 14-bits.
135 *
136 * In order to simplify the encoding process, the original linear magnitude
137 * is biased by adding 33 which shifts the encoding range from (0 - 8158) to
138 * (33 - 8191). The result can be seen in the following encoding table:
139 *
140 * Biased Linear Input Code Compressed Code
141 * ------------------------ ---------------
142 * 00000001wxyza 000wxyz
143 * 0000001wxyzab 001wxyz
144 * 000001wxyzabc 010wxyz
145 * 00001wxyzabcd 011wxyz
146 * 0001wxyzabcde 100wxyz
147 * 001wxyzabcdef 101wxyz
148 * 01wxyzabcdefg 110wxyz
149 * 1wxyzabcdefgh 111wxyz
150 *
151 * Each biased linear code has a leading 1 which identifies the segment
152 * number. The value of the segment number is equal to 7 minus the number
153 * of leading 0's. The quantization interval is directly available as the
154 * four bits wxyz. * The trailing bits (a - h) are ignored.
155 *
156 * Ordinarily the complement of the resulting code word is used for
157 * transmission, and so the code word is complemented before it is returned.
158 *
159 * For further information see John C. Bellamy's Digital Telephony, 1982,
160 * John Wiley & Sons, pps 98-111 and 472-476.
161 */
162 static unsigned char
st_14linear2ulaw(PyInt16 pcm_val)163 st_14linear2ulaw(PyInt16 pcm_val) /* 2's complement (14-bit range) */
164 {
165 PyInt16 mask;
166 PyInt16 seg;
167 unsigned char uval;
168
169 /* The original sox code does this in the calling function, not here */
170 pcm_val = pcm_val >> 2;
171
172 /* u-law inverts all bits */
173 /* Get the sign and the magnitude of the value. */
174 if (pcm_val < 0) {
175 pcm_val = -pcm_val;
176 mask = 0x7F;
177 } else {
178 mask = 0xFF;
179 }
180 if ( pcm_val > CLIP ) pcm_val = CLIP; /* clip the magnitude */
181 pcm_val += (BIAS >> 2);
182
183 /* Convert the scaled magnitude to segment number. */
184 seg = search(pcm_val, seg_uend, 8);
185
186 /*
187 * Combine the sign, segment, quantization bits;
188 * and complement the code word.
189 */
190 if (seg >= 8) /* out of range, return maximum value. */
191 return (unsigned char) (0x7F ^ mask);
192 else {
193 uval = (unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
194 return (uval ^ mask);
195 }
196
197 }
198
199 static PyInt16 _st_alaw2linear16[256] = {
200 -5504, -5248, -6016, -5760, -4480, -4224, -4992,
201 -4736, -7552, -7296, -8064, -7808, -6528, -6272,
202 -7040, -6784, -2752, -2624, -3008, -2880, -2240,
203 -2112, -2496, -2368, -3776, -3648, -4032, -3904,
204 -3264, -3136, -3520, -3392, -22016, -20992, -24064,
205 -23040, -17920, -16896, -19968, -18944, -30208, -29184,
206 -32256, -31232, -26112, -25088, -28160, -27136, -11008,
207 -10496, -12032, -11520, -8960, -8448, -9984, -9472,
208 -15104, -14592, -16128, -15616, -13056, -12544, -14080,
209 -13568, -344, -328, -376, -360, -280, -264,
210 -312, -296, -472, -456, -504, -488, -408,
211 -392, -440, -424, -88, -72, -120, -104,
212 -24, -8, -56, -40, -216, -200, -248,
213 -232, -152, -136, -184, -168, -1376, -1312,
214 -1504, -1440, -1120, -1056, -1248, -1184, -1888,
215 -1824, -2016, -1952, -1632, -1568, -1760, -1696,
216 -688, -656, -752, -720, -560, -528, -624,
217 -592, -944, -912, -1008, -976, -816, -784,
218 -880, -848, 5504, 5248, 6016, 5760, 4480,
219 4224, 4992, 4736, 7552, 7296, 8064, 7808,
220 6528, 6272, 7040, 6784, 2752, 2624, 3008,
221 2880, 2240, 2112, 2496, 2368, 3776, 3648,
222 4032, 3904, 3264, 3136, 3520, 3392, 22016,
223 20992, 24064, 23040, 17920, 16896, 19968, 18944,
224 30208, 29184, 32256, 31232, 26112, 25088, 28160,
225 27136, 11008, 10496, 12032, 11520, 8960, 8448,
226 9984, 9472, 15104, 14592, 16128, 15616, 13056,
227 12544, 14080, 13568, 344, 328, 376, 360,
228 280, 264, 312, 296, 472, 456, 504,
229 488, 408, 392, 440, 424, 88, 72,
230 120, 104, 24, 8, 56, 40, 216,
231 200, 248, 232, 152, 136, 184, 168,
232 1376, 1312, 1504, 1440, 1120, 1056, 1248,
233 1184, 1888, 1824, 2016, 1952, 1632, 1568,
234 1760, 1696, 688, 656, 752, 720, 560,
235 528, 624, 592, 944, 912, 1008, 976,
236 816, 784, 880, 848
237 };
238
239 /*
240 * linear2alaw() accepts a 13-bit signed integer and encodes it as A-law data
241 * stored in an unsigned char. This function should only be called with
242 * the data shifted such that it only contains information in the lower
243 * 13-bits.
244 *
245 * Linear Input Code Compressed Code
246 * ------------------------ ---------------
247 * 0000000wxyza 000wxyz
248 * 0000001wxyza 001wxyz
249 * 000001wxyzab 010wxyz
250 * 00001wxyzabc 011wxyz
251 * 0001wxyzabcd 100wxyz
252 * 001wxyzabcde 101wxyz
253 * 01wxyzabcdef 110wxyz
254 * 1wxyzabcdefg 111wxyz
255 *
256 * For further information see John C. Bellamy's Digital Telephony, 1982,
257 * John Wiley & Sons, pps 98-111 and 472-476.
258 */
259 static unsigned char
st_linear2alaw(PyInt16 pcm_val)260 st_linear2alaw(PyInt16 pcm_val) /* 2's complement (13-bit range) */
261 {
262 PyInt16 mask;
263 short seg;
264 unsigned char aval;
265
266 /* The original sox code does this in the calling function, not here */
267 pcm_val = pcm_val >> 3;
268
269 /* A-law using even bit inversion */
270 if (pcm_val >= 0) {
271 mask = 0xD5; /* sign (7th) bit = 1 */
272 } else {
273 mask = 0x55; /* sign bit = 0 */
274 pcm_val = -pcm_val - 1;
275 }
276
277 /* Convert the scaled magnitude to segment number. */
278 seg = search(pcm_val, seg_aend, 8);
279
280 /* Combine the sign, segment, and quantization bits. */
281
282 if (seg >= 8) /* out of range, return maximum value. */
283 return (unsigned char) (0x7F ^ mask);
284 else {
285 aval = (unsigned char) seg << SEG_SHIFT;
286 if (seg < 2)
287 aval |= (pcm_val >> 1) & QUANT_MASK;
288 else
289 aval |= (pcm_val >> seg) & QUANT_MASK;
290 return (aval ^ mask);
291 }
292 }
293 /* End of code taken from sox */
294
295 /* Intel ADPCM step variation table */
296 static int indexTable[16] = {
297 -1, -1, -1, -1, 2, 4, 6, 8,
298 -1, -1, -1, -1, 2, 4, 6, 8,
299 };
300
301 static int stepsizeTable[89] = {
302 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
303 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
304 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
305 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
306 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
307 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
308 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
309 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
310 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
311 };
312
313 #define CHARP(cp, i) ((signed char *)(cp+i))
314 #define SHORTP(cp, i) ((short *)(cp+i))
315 #define LONGP(cp, i) ((Py_Int32 *)(cp+i))
316
317
318
319 static PyObject *AudioopError;
320
321 static int
audioop_check_size(int size)322 audioop_check_size(int size)
323 {
324 if (size != 1 && size != 2 && size != 4) {
325 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");
326 return 0;
327 }
328 else
329 return 1;
330 }
331
332 static int
audioop_check_parameters(int len,int size)333 audioop_check_parameters(int len, int size)
334 {
335 if (!audioop_check_size(size))
336 return 0;
337 if (len % size != 0) {
338 PyErr_SetString(AudioopError, "not a whole number of frames");
339 return 0;
340 }
341 return 1;
342 }
343
344 static PyObject *
audioop_getsample(PyObject * self,PyObject * args)345 audioop_getsample(PyObject *self, PyObject *args)
346 {
347 signed char *cp;
348 int len, size, val = 0;
349 int i;
350
351 if ( !PyArg_ParseTuple(args, "s#ii:getsample", &cp, &len, &size, &i) )
352 return 0;
353 if (!audioop_check_parameters(len, size))
354 return NULL;
355 if ( i < 0 || i >= len/size ) {
356 PyErr_SetString(AudioopError, "Index out of range");
357 return 0;
358 }
359 if ( size == 1 ) val = (int)*CHARP(cp, i);
360 else if ( size == 2 ) val = (int)*SHORTP(cp, i*2);
361 else if ( size == 4 ) val = (int)*LONGP(cp, i*4);
362 return PyInt_FromLong(val);
363 }
364
365 static PyObject *
audioop_max(PyObject * self,PyObject * args)366 audioop_max(PyObject *self, PyObject *args)
367 {
368 signed char *cp;
369 int len, size, val = 0;
370 int i;
371 unsigned int absval, max = 0;
372
373 if ( !PyArg_ParseTuple(args, "s#i:max", &cp, &len, &size) )
374 return 0;
375 if (!audioop_check_parameters(len, size))
376 return NULL;
377 for ( i=0; i<len; i+= size) {
378 if ( size == 1 ) val = (int)*CHARP(cp, i);
379 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
380 else if ( size == 4 ) val = (int)*LONGP(cp, i);
381 if (val < 0) absval = (-val);
382 else absval = val;
383 if (absval > max) max = absval;
384 }
385 if (max <= INT_MAX)
386 return PyInt_FromLong(max);
387 else
388 return PyLong_FromUnsignedLong(max);
389 }
390
391 static PyObject *
audioop_minmax(PyObject * self,PyObject * args)392 audioop_minmax(PyObject *self, PyObject *args)
393 {
394 signed char *cp;
395 int len, size, val = 0;
396 int i;
397 /* -1 trick below is needed on Windows to support -0x80000000 without
398 a warning */
399 int min = 0x7fffffff, max = -0x7FFFFFFF-1;
400
401 if (!PyArg_ParseTuple(args, "s#i:minmax", &cp, &len, &size))
402 return NULL;
403 if (!audioop_check_parameters(len, size))
404 return NULL;
405 for (i = 0; i < len; i += size) {
406 if (size == 1) val = (int) *CHARP(cp, i);
407 else if (size == 2) val = (int) *SHORTP(cp, i);
408 else if (size == 4) val = (int) *LONGP(cp, i);
409 if (val > max) max = val;
410 if (val < min) min = val;
411 }
412 return Py_BuildValue("(ii)", min, max);
413 }
414
415 static PyObject *
audioop_avg(PyObject * self,PyObject * args)416 audioop_avg(PyObject *self, PyObject *args)
417 {
418 signed char *cp;
419 int len, size, val = 0;
420 int i;
421 double avg = 0.0;
422
423 if ( !PyArg_ParseTuple(args, "s#i:avg", &cp, &len, &size) )
424 return 0;
425 if (!audioop_check_parameters(len, size))
426 return NULL;
427 for ( i=0; i<len; i+= size) {
428 if ( size == 1 ) val = (int)*CHARP(cp, i);
429 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
430 else if ( size == 4 ) val = (int)*LONGP(cp, i);
431 avg += val;
432 }
433 if ( len == 0 )
434 val = 0;
435 else
436 val = (int)floor(avg / (double)(len/size));
437 return PyInt_FromLong(val);
438 }
439
440 static PyObject *
audioop_rms(PyObject * self,PyObject * args)441 audioop_rms(PyObject *self, PyObject *args)
442 {
443 signed char *cp;
444 int len, size, val = 0;
445 int i;
446 unsigned int res;
447 double sum_squares = 0.0;
448
449 if ( !PyArg_ParseTuple(args, "s#i:rms", &cp, &len, &size) )
450 return 0;
451 if (!audioop_check_parameters(len, size))
452 return NULL;
453 for ( i=0; i<len; i+= size) {
454 if ( size == 1 ) val = (int)*CHARP(cp, i);
455 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
456 else if ( size == 4 ) val = (int)*LONGP(cp, i);
457 sum_squares += (double)val*(double)val;
458 }
459 if ( len == 0 )
460 res = 0;
461 else
462 res = (unsigned int)sqrt(sum_squares / (double)(len/size));
463 if (res <= INT_MAX)
464 return PyInt_FromLong(res);
465 else
466 return PyLong_FromUnsignedLong(res);
467 }
468
_sum2(short * a,short * b,int len)469 static double _sum2(short *a, short *b, int len)
470 {
471 int i;
472 double sum = 0.0;
473
474 for( i=0; i<len; i++) {
475 sum = sum + (double)a[i]*(double)b[i];
476 }
477 return sum;
478 }
479
480 /*
481 ** Findfit tries to locate a sample within another sample. Its main use
482 ** is in echo-cancellation (to find the feedback of the output signal in
483 ** the input signal).
484 ** The method used is as follows:
485 **
486 ** let R be the reference signal (length n) and A the input signal (length N)
487 ** with N > n, and let all sums be over i from 0 to n-1.
488 **
489 ** Now, for each j in {0..N-n} we compute a factor fj so that -fj*R matches A
490 ** as good as possible, i.e. sum( (A[j+i]+fj*R[i])^2 ) is minimal. This
491 ** equation gives fj = sum( A[j+i]R[i] ) / sum(R[i]^2).
492 **
493 ** Next, we compute the relative distance between the original signal and
494 ** the modified signal and minimize that over j:
495 ** vj = sum( (A[j+i]-fj*R[i])^2 ) / sum( A[j+i]^2 ) =>
496 ** vj = ( sum(A[j+i]^2)*sum(R[i]^2) - sum(A[j+i]R[i])^2 ) / sum( A[j+i]^2 )
497 **
498 ** In the code variables correspond as follows:
499 ** cp1 A
500 ** cp2 R
501 ** len1 N
502 ** len2 n
503 ** aj_m1 A[j-1]
504 ** aj_lm1 A[j+n-1]
505 ** sum_ri_2 sum(R[i]^2)
506 ** sum_aij_2 sum(A[i+j]^2)
507 ** sum_aij_ri sum(A[i+j]R[i])
508 **
509 ** sum_ri is calculated once, sum_aij_2 is updated each step and sum_aij_ri
510 ** is completely recalculated each step.
511 */
512 static PyObject *
audioop_findfit(PyObject * self,PyObject * args)513 audioop_findfit(PyObject *self, PyObject *args)
514 {
515 short *cp1, *cp2;
516 int len1, len2;
517 int j, best_j;
518 double aj_m1, aj_lm1;
519 double sum_ri_2, sum_aij_2, sum_aij_ri, result, best_result, factor;
520
521 /* Passing a short** for an 's' argument is correct only
522 if the string contents is aligned for interpretation
523 as short[]. Due to the definition of PyStringObject,
524 this is currently (Python 2.6) the case. */
525 if ( !PyArg_ParseTuple(args, "s#s#:findfit",
526 (char**)&cp1, &len1, (char**)&cp2, &len2) )
527 return 0;
528 if ( len1 & 1 || len2 & 1 ) {
529 PyErr_SetString(AudioopError, "Strings should be even-sized");
530 return 0;
531 }
532 len1 >>= 1;
533 len2 >>= 1;
534
535 if ( len1 < len2 ) {
536 PyErr_SetString(AudioopError, "First sample should be longer");
537 return 0;
538 }
539 sum_ri_2 = _sum2(cp2, cp2, len2);
540 sum_aij_2 = _sum2(cp1, cp1, len2);
541 sum_aij_ri = _sum2(cp1, cp2, len2);
542
543 result = (sum_ri_2*sum_aij_2 - sum_aij_ri*sum_aij_ri) / sum_aij_2;
544
545 best_result = result;
546 best_j = 0;
547
548 for (j=1; j<=len1-len2; j++) {
549 aj_m1 = (double)cp1[j-1];
550 aj_lm1 = (double)cp1[j+len2-1];
551
552 sum_aij_2 = sum_aij_2 + aj_lm1*aj_lm1 - aj_m1*aj_m1;
553 sum_aij_ri = _sum2(cp1+j, cp2, len2);
554
555 result = (sum_ri_2*sum_aij_2 - sum_aij_ri*sum_aij_ri)
556 / sum_aij_2;
557
558 if ( result < best_result ) {
559 best_result = result;
560 best_j = j;
561 }
562
563 }
564
565 factor = _sum2(cp1+best_j, cp2, len2) / sum_ri_2;
566
567 return Py_BuildValue("(if)", best_j, factor);
568 }
569
570 /*
571 ** findfactor finds a factor f so that the energy in A-fB is minimal.
572 ** See the comment for findfit for details.
573 */
574 static PyObject *
audioop_findfactor(PyObject * self,PyObject * args)575 audioop_findfactor(PyObject *self, PyObject *args)
576 {
577 short *cp1, *cp2;
578 int len1, len2;
579 double sum_ri_2, sum_aij_ri, result;
580
581 if ( !PyArg_ParseTuple(args, "s#s#:findfactor",
582 (char**)&cp1, &len1, (char**)&cp2, &len2) )
583 return 0;
584 if ( len1 & 1 || len2 & 1 ) {
585 PyErr_SetString(AudioopError, "Strings should be even-sized");
586 return 0;
587 }
588 if ( len1 != len2 ) {
589 PyErr_SetString(AudioopError, "Samples should be same size");
590 return 0;
591 }
592 len2 >>= 1;
593 sum_ri_2 = _sum2(cp2, cp2, len2);
594 sum_aij_ri = _sum2(cp1, cp2, len2);
595
596 result = sum_aij_ri / sum_ri_2;
597
598 return PyFloat_FromDouble(result);
599 }
600
601 /*
602 ** findmax returns the index of the n-sized segment of the input sample
603 ** that contains the most energy.
604 */
605 static PyObject *
audioop_findmax(PyObject * self,PyObject * args)606 audioop_findmax(PyObject *self, PyObject *args)
607 {
608 short *cp1;
609 int len1, len2;
610 int j, best_j;
611 double aj_m1, aj_lm1;
612 double result, best_result;
613
614 if ( !PyArg_ParseTuple(args, "s#i:findmax",
615 (char**)&cp1, &len1, &len2) )
616 return 0;
617 if ( len1 & 1 ) {
618 PyErr_SetString(AudioopError, "Strings should be even-sized");
619 return 0;
620 }
621 len1 >>= 1;
622
623 if ( len2 < 0 || len1 < len2 ) {
624 PyErr_SetString(AudioopError, "Input sample should be longer");
625 return 0;
626 }
627
628 result = _sum2(cp1, cp1, len2);
629
630 best_result = result;
631 best_j = 0;
632
633 for (j=1; j<=len1-len2; j++) {
634 aj_m1 = (double)cp1[j-1];
635 aj_lm1 = (double)cp1[j+len2-1];
636
637 result = result + aj_lm1*aj_lm1 - aj_m1*aj_m1;
638
639 if ( result > best_result ) {
640 best_result = result;
641 best_j = j;
642 }
643
644 }
645
646 return PyInt_FromLong(best_j);
647 }
648
649 static PyObject *
audioop_avgpp(PyObject * self,PyObject * args)650 audioop_avgpp(PyObject *self, PyObject *args)
651 {
652 signed char *cp;
653 int len, size, val = 0, prevval = 0, prevextremevalid = 0,
654 prevextreme = 0;
655 int i;
656 double sum = 0.0;
657 unsigned int avg;
658 int diff, prevdiff, nextreme = 0;
659
660 if ( !PyArg_ParseTuple(args, "s#i:avgpp", &cp, &len, &size) )
661 return 0;
662 if (!audioop_check_parameters(len, size))
663 return NULL;
664 if (len <= size*2)
665 return PyInt_FromLong(0);
666 if ( size == 1 ) prevval = (int)*CHARP(cp, 0);
667 else if ( size == 2 ) prevval = (int)*SHORTP(cp, 0);
668 else if ( size == 4 ) prevval = (int)*LONGP(cp, 0);
669 prevdiff = 17; /* Anything != 0, 1 */
670 for ( i=size; i<len; i+= size) {
671 if ( size == 1 ) val = (int)*CHARP(cp, i);
672 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
673 else if ( size == 4 ) val = (int)*LONGP(cp, i);
674 if (val != prevval) {
675 diff = val < prevval;
676 if (prevdiff == !diff) {
677 /* Derivative changed sign. Compute difference to last
678 ** extreme value and remember.
679 */
680 if (prevextremevalid) {
681 sum += fabs((double)prevval - (double)prevextreme);
682 nextreme++;
683 }
684 prevextremevalid = 1;
685 prevextreme = prevval;
686 }
687 prevval = val;
688 prevdiff = diff;
689 }
690 }
691 if ( nextreme == 0 )
692 avg = 0;
693 else
694 avg = (unsigned int)(sum / (double)nextreme);
695 if (avg <= INT_MAX)
696 return PyInt_FromLong(avg);
697 else
698 return PyLong_FromUnsignedLong(avg);
699 }
700
701 static PyObject *
audioop_maxpp(PyObject * self,PyObject * args)702 audioop_maxpp(PyObject *self, PyObject *args)
703 {
704 signed char *cp;
705 int len, size, val = 0, prevval = 0, prevextremevalid = 0,
706 prevextreme = 0;
707 int i;
708 unsigned int max = 0, extremediff;
709 int diff, prevdiff;
710
711 if ( !PyArg_ParseTuple(args, "s#i:maxpp", &cp, &len, &size) )
712 return 0;
713 if (!audioop_check_parameters(len, size))
714 return NULL;
715 if (len <= size)
716 return PyInt_FromLong(0);
717 if ( size == 1 ) prevval = (int)*CHARP(cp, 0);
718 else if ( size == 2 ) prevval = (int)*SHORTP(cp, 0);
719 else if ( size == 4 ) prevval = (int)*LONGP(cp, 0);
720 prevdiff = 17; /* Anything != 0, 1 */
721 for ( i=size; i<len; i+= size) {
722 if ( size == 1 ) val = (int)*CHARP(cp, i);
723 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
724 else if ( size == 4 ) val = (int)*LONGP(cp, i);
725 if (val != prevval) {
726 diff = val < prevval;
727 if (prevdiff == !diff) {
728 /* Derivative changed sign. Compute difference to
729 ** last extreme value and remember.
730 */
731 if (prevextremevalid) {
732 if (prevval < prevextreme)
733 extremediff = (unsigned int)prevextreme -
734 (unsigned int)prevval;
735 else
736 extremediff = (unsigned int)prevval -
737 (unsigned int)prevextreme;
738 if ( extremediff > max )
739 max = extremediff;
740 }
741 prevextremevalid = 1;
742 prevextreme = prevval;
743 }
744 prevval = val;
745 prevdiff = diff;
746 }
747 }
748 if (max <= INT_MAX)
749 return PyInt_FromLong(max);
750 else
751 return PyLong_FromUnsignedLong(max);
752 }
753
754 static PyObject *
audioop_cross(PyObject * self,PyObject * args)755 audioop_cross(PyObject *self, PyObject *args)
756 {
757 signed char *cp;
758 int len, size, val = 0;
759 int i;
760 int prevval, ncross;
761
762 if ( !PyArg_ParseTuple(args, "s#i:cross", &cp, &len, &size) )
763 return 0;
764 if (!audioop_check_parameters(len, size))
765 return NULL;
766 ncross = -1;
767 prevval = 17; /* Anything <> 0,1 */
768 for ( i=0; i<len; i+= size) {
769 if ( size == 1 ) val = ((int)*CHARP(cp, i)) >> 7;
770 else if ( size == 2 ) val = ((int)*SHORTP(cp, i)) >> 15;
771 else if ( size == 4 ) val = ((int)*LONGP(cp, i)) >> 31;
772 val = val & 1;
773 if ( val != prevval ) ncross++;
774 prevval = val;
775 }
776 return PyInt_FromLong(ncross);
777 }
778
779 static PyObject *
audioop_mul(PyObject * self,PyObject * args)780 audioop_mul(PyObject *self, PyObject *args)
781 {
782 signed char *cp, *ncp;
783 int len, size, val = 0;
784 double factor, fval, maxval, minval;
785 PyObject *rv;
786 int i;
787
788 if ( !PyArg_ParseTuple(args, "s#id:mul", &cp, &len, &size, &factor ) )
789 return 0;
790 if (!audioop_check_parameters(len, size))
791 return NULL;
792
793 maxval = (double) maxvals[size];
794 minval = (double) minvals[size];
795
796 rv = PyString_FromStringAndSize(NULL, len);
797 if ( rv == 0 )
798 return 0;
799 ncp = (signed char *)PyString_AsString(rv);
800
801
802 for ( i=0; i < len; i += size ) {
803 if ( size == 1 ) val = (int)*CHARP(cp, i);
804 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
805 else if ( size == 4 ) val = (int)*LONGP(cp, i);
806 fval = (double)val * factor;
807 val = fbound(fval, minval, maxval);
808 if ( size == 1 ) *CHARP(ncp, i) = (signed char)val;
809 else if ( size == 2 ) *SHORTP(ncp, i) = (short)val;
810 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)val;
811 }
812 return rv;
813 }
814
815 static PyObject *
audioop_tomono(PyObject * self,PyObject * args)816 audioop_tomono(PyObject *self, PyObject *args)
817 {
818 signed char *cp, *ncp;
819 int len, size, val1 = 0, val2 = 0;
820 double fac1, fac2, fval, maxval, minval;
821 PyObject *rv;
822 int i;
823
824 if ( !PyArg_ParseTuple(args, "s#idd:tomono",
825 &cp, &len, &size, &fac1, &fac2 ) )
826 return 0;
827 if (!audioop_check_parameters(len, size))
828 return NULL;
829 if (((len / size) & 1) != 0) {
830 PyErr_SetString(AudioopError, "not a whole number of frames");
831 return NULL;
832 }
833
834 maxval = (double) maxvals[size];
835 minval = (double) minvals[size];
836
837 rv = PyString_FromStringAndSize(NULL, len/2);
838 if ( rv == 0 )
839 return 0;
840 ncp = (signed char *)PyString_AsString(rv);
841
842
843 for ( i=0; i < len; i += size*2 ) {
844 if ( size == 1 ) val1 = (int)*CHARP(cp, i);
845 else if ( size == 2 ) val1 = (int)*SHORTP(cp, i);
846 else if ( size == 4 ) val1 = (int)*LONGP(cp, i);
847 if ( size == 1 ) val2 = (int)*CHARP(cp, i+1);
848 else if ( size == 2 ) val2 = (int)*SHORTP(cp, i+2);
849 else if ( size == 4 ) val2 = (int)*LONGP(cp, i+4);
850 fval = (double)val1 * fac1 + (double)val2 * fac2;
851 val1 = fbound(fval, minval, maxval);
852 if ( size == 1 ) *CHARP(ncp, i/2) = (signed char)val1;
853 else if ( size == 2 ) *SHORTP(ncp, i/2) = (short)val1;
854 else if ( size == 4 ) *LONGP(ncp, i/2)= (Py_Int32)val1;
855 }
856 return rv;
857 }
858
859 static PyObject *
audioop_tostereo(PyObject * self,PyObject * args)860 audioop_tostereo(PyObject *self, PyObject *args)
861 {
862 signed char *cp, *ncp;
863 int len, size, val1, val2, val = 0;
864 double fac1, fac2, fval, maxval, minval;
865 PyObject *rv;
866 int i;
867
868 if ( !PyArg_ParseTuple(args, "s#idd:tostereo",
869 &cp, &len, &size, &fac1, &fac2 ) )
870 return 0;
871 if (!audioop_check_parameters(len, size))
872 return NULL;
873
874 maxval = (double) maxvals[size];
875 minval = (double) minvals[size];
876
877 if (len > INT_MAX/2) {
878 PyErr_SetString(PyExc_MemoryError,
879 "not enough memory for output buffer");
880 return 0;
881 }
882
883 rv = PyString_FromStringAndSize(NULL, len*2);
884 if ( rv == 0 )
885 return 0;
886 ncp = (signed char *)PyString_AsString(rv);
887
888
889 for ( i=0; i < len; i += size ) {
890 if ( size == 1 ) val = (int)*CHARP(cp, i);
891 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
892 else if ( size == 4 ) val = (int)*LONGP(cp, i);
893
894 fval = (double)val * fac1;
895 val1 = fbound(fval, minval, maxval);
896
897 fval = (double)val * fac2;
898 val2 = fbound(fval, minval, maxval);
899
900 if ( size == 1 ) *CHARP(ncp, i*2) = (signed char)val1;
901 else if ( size == 2 ) *SHORTP(ncp, i*2) = (short)val1;
902 else if ( size == 4 ) *LONGP(ncp, i*2) = (Py_Int32)val1;
903
904 if ( size == 1 ) *CHARP(ncp, i*2+1) = (signed char)val2;
905 else if ( size == 2 ) *SHORTP(ncp, i*2+2) = (short)val2;
906 else if ( size == 4 ) *LONGP(ncp, i*2+4) = (Py_Int32)val2;
907 }
908 return rv;
909 }
910
911 static PyObject *
audioop_add(PyObject * self,PyObject * args)912 audioop_add(PyObject *self, PyObject *args)
913 {
914 signed char *cp1, *cp2, *ncp;
915 int len1, len2, size, val1 = 0, val2 = 0, minval, maxval, newval;
916 PyObject *rv;
917 int i;
918
919 if ( !PyArg_ParseTuple(args, "s#s#i:add",
920 &cp1, &len1, &cp2, &len2, &size ) )
921 return 0;
922 if (!audioop_check_parameters(len1, size))
923 return NULL;
924 if ( len1 != len2 ) {
925 PyErr_SetString(AudioopError, "Lengths should be the same");
926 return 0;
927 }
928
929 maxval = maxvals[size];
930 minval = minvals[size];
931
932 rv = PyString_FromStringAndSize(NULL, len1);
933 if ( rv == 0 )
934 return 0;
935 ncp = (signed char *)PyString_AsString(rv);
936
937 for ( i=0; i < len1; i += size ) {
938 if ( size == 1 ) val1 = (int)*CHARP(cp1, i);
939 else if ( size == 2 ) val1 = (int)*SHORTP(cp1, i);
940 else if ( size == 4 ) val1 = (int)*LONGP(cp1, i);
941
942 if ( size == 1 ) val2 = (int)*CHARP(cp2, i);
943 else if ( size == 2 ) val2 = (int)*SHORTP(cp2, i);
944 else if ( size == 4 ) val2 = (int)*LONGP(cp2, i);
945
946 if (size < 4) {
947 newval = val1 + val2;
948 /* truncate in case of overflow */
949 if (newval > maxval)
950 newval = maxval;
951 else if (newval < minval)
952 newval = minval;
953 }
954 else {
955 double fval = (double)val1 + (double)val2;
956 /* truncate in case of overflow */
957 newval = fbound(fval, minval, maxval);
958 }
959
960 if ( size == 1 ) *CHARP(ncp, i) = (signed char)newval;
961 else if ( size == 2 ) *SHORTP(ncp, i) = (short)newval;
962 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)newval;
963 }
964 return rv;
965 }
966
967 static PyObject *
audioop_bias(PyObject * self,PyObject * args)968 audioop_bias(PyObject *self, PyObject *args)
969 {
970 signed char *cp, *ncp;
971 int len, size;
972 unsigned int val = 0, mask;
973 PyObject *rv;
974 int i;
975 int bias;
976
977 if ( !PyArg_ParseTuple(args, "s#ii:bias",
978 &cp, &len, &size , &bias) )
979 return 0;
980
981 if (!audioop_check_parameters(len, size))
982 return NULL;
983
984 rv = PyString_FromStringAndSize(NULL, len);
985 if ( rv == 0 )
986 return 0;
987 ncp = (signed char *)PyString_AsString(rv);
988
989 mask = masks[size];
990
991 for ( i=0; i < len; i += size ) {
992 if ( size == 1 ) val = (unsigned int)(unsigned char)*CHARP(cp, i);
993 else if ( size == 2 ) val = (unsigned int)(unsigned short)*SHORTP(cp, i);
994 else if ( size == 4 ) val = (unsigned int)(Py_UInt32)*LONGP(cp, i);
995
996 val += (unsigned int)bias;
997 /* wrap around in case of overflow */
998 val &= mask;
999
1000 if ( size == 1 ) *CHARP(ncp, i) = (signed char)(unsigned char)val;
1001 else if ( size == 2 ) *SHORTP(ncp, i) = (short)(unsigned short)val;
1002 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)(Py_UInt32)val;
1003 }
1004 return rv;
1005 }
1006
1007 static PyObject *
audioop_reverse(PyObject * self,PyObject * args)1008 audioop_reverse(PyObject *self, PyObject *args)
1009 {
1010 signed char *cp;
1011 unsigned char *ncp;
1012 int len, size, val = 0;
1013 PyObject *rv;
1014 int i, j;
1015
1016 if ( !PyArg_ParseTuple(args, "s#i:reverse",
1017 &cp, &len, &size) )
1018 return 0;
1019
1020 if (!audioop_check_parameters(len, size))
1021 return NULL;
1022
1023 rv = PyString_FromStringAndSize(NULL, len);
1024 if ( rv == 0 )
1025 return 0;
1026 ncp = (unsigned char *)PyString_AsString(rv);
1027
1028 for ( i=0; i < len; i += size ) {
1029 if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 24;
1030 else if ( size == 2 ) val = ((int)*SHORTP(cp, i)) << 16;
1031 else if ( size == 4 ) val = (int)*LONGP(cp, i);
1032
1033 j = len - i - size;
1034
1035 if ( size == 1 ) *CHARP(ncp, j) = (signed char)(val >> 24);
1036 else if ( size == 2 ) *SHORTP(ncp, j) = (short)(val >> 16);
1037 else if ( size == 4 ) *LONGP(ncp, j) = (Py_Int32)val;
1038 }
1039 return rv;
1040 }
1041
1042 static PyObject *
audioop_lin2lin(PyObject * self,PyObject * args)1043 audioop_lin2lin(PyObject *self, PyObject *args)
1044 {
1045 signed char *cp;
1046 unsigned char *ncp;
1047 int len, size, size2, val = 0;
1048 PyObject *rv;
1049 int i, j;
1050
1051 if ( !PyArg_ParseTuple(args, "s#ii:lin2lin",
1052 &cp, &len, &size, &size2) )
1053 return 0;
1054
1055 if (!audioop_check_parameters(len, size))
1056 return NULL;
1057 if (!audioop_check_size(size2))
1058 return NULL;
1059
1060 if (len/size > INT_MAX/size2) {
1061 PyErr_SetString(PyExc_MemoryError,
1062 "not enough memory for output buffer");
1063 return 0;
1064 }
1065 rv = PyString_FromStringAndSize(NULL, (len/size)*size2);
1066 if ( rv == 0 )
1067 return 0;
1068 ncp = (unsigned char *)PyString_AsString(rv);
1069
1070 for ( i=0, j=0; i < len; i += size, j += size2 ) {
1071 if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 24;
1072 else if ( size == 2 ) val = ((int)*SHORTP(cp, i)) << 16;
1073 else if ( size == 4 ) val = (int)*LONGP(cp, i);
1074
1075 if ( size2 == 1 ) *CHARP(ncp, j) = (signed char)(val >> 24);
1076 else if ( size2 == 2 ) *SHORTP(ncp, j) = (short)(val >> 16);
1077 else if ( size2 == 4 ) *LONGP(ncp, j) = (Py_Int32)val;
1078 }
1079 return rv;
1080 }
1081
1082 static int
gcd(int a,int b)1083 gcd(int a, int b)
1084 {
1085 while (b > 0) {
1086 int tmp = a % b;
1087 a = b;
1088 b = tmp;
1089 }
1090 return a;
1091 }
1092
1093 static PyObject *
audioop_ratecv(PyObject * self,PyObject * args)1094 audioop_ratecv(PyObject *self, PyObject *args)
1095 {
1096 char *cp, *ncp;
1097 int len, size, nchannels, inrate, outrate, weightA, weightB;
1098 int chan, d, *prev_i, *cur_i, cur_o;
1099 PyObject *state, *samps, *str, *rv = NULL, *channel;
1100 int bytes_per_frame;
1101
1102 weightA = 1;
1103 weightB = 0;
1104 if (!PyArg_ParseTuple(args, "s#iiiiO|ii:ratecv", &cp, &len, &size,
1105 &nchannels, &inrate, &outrate, &state,
1106 &weightA, &weightB))
1107 return NULL;
1108 if (!audioop_check_size(size))
1109 return NULL;
1110 if (nchannels < 1) {
1111 PyErr_SetString(AudioopError, "# of channels should be >= 1");
1112 return NULL;
1113 }
1114 bytes_per_frame = size * nchannels;
1115 if (bytes_per_frame / nchannels != size) {
1116 /* This overflow test is rigorously correct because
1117 both multiplicands are >= 1. Use the argument names
1118 from the docs for the error msg. */
1119 PyErr_SetString(PyExc_OverflowError,
1120 "width * nchannels too big for a C int");
1121 return NULL;
1122 }
1123 if (weightA < 1 || weightB < 0) {
1124 PyErr_SetString(AudioopError,
1125 "weightA should be >= 1, weightB should be >= 0");
1126 return NULL;
1127 }
1128 if (len % bytes_per_frame != 0) {
1129 PyErr_SetString(AudioopError, "not a whole number of frames");
1130 return NULL;
1131 }
1132 if (inrate <= 0 || outrate <= 0) {
1133 PyErr_SetString(AudioopError, "sampling rate not > 0");
1134 return NULL;
1135 }
1136 /* divide inrate and outrate by their greatest common divisor */
1137 d = gcd(inrate, outrate);
1138 inrate /= d;
1139 outrate /= d;
1140 /* divide weightA and weightB by their greatest common divisor */
1141 d = gcd(weightA, weightB);
1142 weightA /= d;
1143 weightB /= d;
1144
1145 if ((size_t)nchannels > PY_SIZE_MAX/sizeof(int)) {
1146 PyErr_SetString(PyExc_MemoryError,
1147 "not enough memory for output buffer");
1148 return 0;
1149 }
1150 prev_i = (int *) malloc(nchannels * sizeof(int));
1151 cur_i = (int *) malloc(nchannels * sizeof(int));
1152 if (prev_i == NULL || cur_i == NULL) {
1153 (void) PyErr_NoMemory();
1154 goto exit;
1155 }
1156
1157 len /= bytes_per_frame; /* # of frames */
1158
1159 if (state == Py_None) {
1160 d = -outrate;
1161 for (chan = 0; chan < nchannels; chan++)
1162 prev_i[chan] = cur_i[chan] = 0;
1163 }
1164 else {
1165 if (!PyTuple_Check(state)) {
1166 PyErr_SetString(PyExc_TypeError, "state must be a tuple or None");
1167 goto exit;
1168 }
1169 if (!PyArg_ParseTuple(state,
1170 "iO!;audioop.ratecv: illegal state argument",
1171 &d, &PyTuple_Type, &samps))
1172 goto exit;
1173 if (PyTuple_Size(samps) != nchannels) {
1174 PyErr_SetString(AudioopError,
1175 "illegal state argument");
1176 goto exit;
1177 }
1178 for (chan = 0; chan < nchannels; chan++) {
1179 channel = PyTuple_GetItem(samps, chan);
1180 if (!PyTuple_Check(channel)) {
1181 PyErr_SetString(PyExc_TypeError,
1182 "ratecv(): illegal state argument");
1183 goto exit;
1184 }
1185 if (!PyArg_ParseTuple(channel,
1186 "ii:ratecv", &prev_i[chan],
1187 &cur_i[chan]))
1188 goto exit;
1189 }
1190 }
1191
1192 /* str <- Space for the output buffer. */
1193 if (len == 0)
1194 str = PyString_FromStringAndSize(NULL, 0);
1195 else {
1196 /* There are len input frames, so we need (mathematically)
1197 ceiling(len*outrate/inrate) output frames, and each frame
1198 requires bytes_per_frame bytes. Computing this
1199 without spurious overflow is the challenge; we can
1200 settle for a reasonable upper bound, though, in this
1201 case ceiling(len/inrate) * outrate. */
1202
1203 /* compute ceiling(len/inrate) without overflow */
1204 int q = len > 0 ? 1 + (len - 1) / inrate : 0;
1205 if (outrate > INT_MAX / q / bytes_per_frame)
1206 str = NULL;
1207 else
1208 str = PyString_FromStringAndSize(NULL,
1209 q * outrate * bytes_per_frame);
1210 }
1211 if (str == NULL) {
1212 PyErr_SetString(PyExc_MemoryError,
1213 "not enough memory for output buffer");
1214 goto exit;
1215 }
1216 ncp = PyString_AsString(str);
1217
1218 for (;;) {
1219 while (d < 0) {
1220 if (len == 0) {
1221 samps = PyTuple_New(nchannels);
1222 if (samps == NULL)
1223 goto exit;
1224 for (chan = 0; chan < nchannels; chan++)
1225 PyTuple_SetItem(samps, chan,
1226 Py_BuildValue("(ii)",
1227 prev_i[chan],
1228 cur_i[chan]));
1229 if (PyErr_Occurred())
1230 goto exit;
1231 /* We have checked before that the length
1232 * of the string fits into int. */
1233 len = (int)(ncp - PyString_AsString(str));
1234 if (len == 0) {
1235 /*don't want to resize to zero length*/
1236 rv = PyString_FromStringAndSize("", 0);
1237 Py_DECREF(str);
1238 str = rv;
1239 } else if (_PyString_Resize(&str, len) < 0)
1240 goto exit;
1241 rv = Py_BuildValue("(O(iO))", str, d, samps);
1242 Py_DECREF(samps);
1243 Py_DECREF(str);
1244 goto exit; /* return rv */
1245 }
1246 for (chan = 0; chan < nchannels; chan++) {
1247 prev_i[chan] = cur_i[chan];
1248 if (size == 1)
1249 cur_i[chan] = ((int)*CHARP(cp, 0)) << 24;
1250 else if (size == 2)
1251 cur_i[chan] = ((int)*SHORTP(cp, 0)) << 16;
1252 else if (size == 4)
1253 cur_i[chan] = (int)*LONGP(cp, 0);
1254 cp += size;
1255 /* implements a simple digital filter */
1256 cur_i[chan] = (int)(
1257 ((double)weightA * (double)cur_i[chan] +
1258 (double)weightB * (double)prev_i[chan]) /
1259 ((double)weightA + (double)weightB));
1260 }
1261 len--;
1262 d += outrate;
1263 }
1264 while (d >= 0) {
1265 for (chan = 0; chan < nchannels; chan++) {
1266 cur_o = (int)(((double)prev_i[chan] * (double)d +
1267 (double)cur_i[chan] * (double)(outrate - d)) /
1268 (double)outrate);
1269 if (size == 1)
1270 *CHARP(ncp, 0) = (signed char)(cur_o >> 24);
1271 else if (size == 2)
1272 *SHORTP(ncp, 0) = (short)(cur_o >> 16);
1273 else if (size == 4)
1274 *LONGP(ncp, 0) = (Py_Int32)(cur_o);
1275 ncp += size;
1276 }
1277 d -= inrate;
1278 }
1279 }
1280 exit:
1281 if (prev_i != NULL)
1282 free(prev_i);
1283 if (cur_i != NULL)
1284 free(cur_i);
1285 return rv;
1286 }
1287
1288 static PyObject *
audioop_lin2ulaw(PyObject * self,PyObject * args)1289 audioop_lin2ulaw(PyObject *self, PyObject *args)
1290 {
1291 signed char *cp;
1292 unsigned char *ncp;
1293 int len, size, val = 0;
1294 PyObject *rv;
1295 int i;
1296
1297 if ( !PyArg_ParseTuple(args, "s#i:lin2ulaw",
1298 &cp, &len, &size) )
1299 return 0 ;
1300
1301 if (!audioop_check_parameters(len, size))
1302 return NULL;
1303
1304 rv = PyString_FromStringAndSize(NULL, len/size);
1305 if ( rv == 0 )
1306 return 0;
1307 ncp = (unsigned char *)PyString_AsString(rv);
1308
1309 for ( i=0; i < len; i += size ) {
1310 if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
1311 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
1312 else if ( size == 4 ) val = ((int)*LONGP(cp, i)) >> 16;
1313
1314 *ncp++ = st_14linear2ulaw(val);
1315 }
1316 return rv;
1317 }
1318
1319 static PyObject *
audioop_ulaw2lin(PyObject * self,PyObject * args)1320 audioop_ulaw2lin(PyObject *self, PyObject *args)
1321 {
1322 unsigned char *cp;
1323 unsigned char cval;
1324 signed char *ncp;
1325 int len, size, val;
1326 PyObject *rv;
1327 int i;
1328
1329 if ( !PyArg_ParseTuple(args, "s#i:ulaw2lin",
1330 &cp, &len, &size) )
1331 return 0;
1332
1333 if (!audioop_check_size(size))
1334 return NULL;
1335
1336 if (len > INT_MAX/size) {
1337 PyErr_SetString(PyExc_MemoryError,
1338 "not enough memory for output buffer");
1339 return 0;
1340 }
1341 rv = PyString_FromStringAndSize(NULL, len*size);
1342 if ( rv == 0 )
1343 return 0;
1344 ncp = (signed char *)PyString_AsString(rv);
1345
1346 for ( i=0; i < len*size; i += size ) {
1347 cval = *cp++;
1348 val = st_ulaw2linear16(cval);
1349
1350 if ( size == 1 ) *CHARP(ncp, i) = (signed char)(val >> 8);
1351 else if ( size == 2 ) *SHORTP(ncp, i) = (short)(val);
1352 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)(val<<16);
1353 }
1354 return rv;
1355 }
1356
1357 static PyObject *
audioop_lin2alaw(PyObject * self,PyObject * args)1358 audioop_lin2alaw(PyObject *self, PyObject *args)
1359 {
1360 signed char *cp;
1361 unsigned char *ncp;
1362 int len, size, val = 0;
1363 PyObject *rv;
1364 int i;
1365
1366 if ( !PyArg_ParseTuple(args, "s#i:lin2alaw",
1367 &cp, &len, &size) )
1368 return 0;
1369
1370 if (!audioop_check_parameters(len, size))
1371 return NULL;
1372
1373 rv = PyString_FromStringAndSize(NULL, len/size);
1374 if ( rv == 0 )
1375 return 0;
1376 ncp = (unsigned char *)PyString_AsString(rv);
1377
1378 for ( i=0; i < len; i += size ) {
1379 if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
1380 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
1381 else if ( size == 4 ) val = ((int)*LONGP(cp, i)) >> 16;
1382
1383 *ncp++ = st_linear2alaw(val);
1384 }
1385 return rv;
1386 }
1387
1388 static PyObject *
audioop_alaw2lin(PyObject * self,PyObject * args)1389 audioop_alaw2lin(PyObject *self, PyObject *args)
1390 {
1391 unsigned char *cp;
1392 unsigned char cval;
1393 signed char *ncp;
1394 int len, size, val;
1395 PyObject *rv;
1396 int i;
1397
1398 if ( !PyArg_ParseTuple(args, "s#i:alaw2lin",
1399 &cp, &len, &size) )
1400 return 0;
1401
1402 if (!audioop_check_size(size))
1403 return NULL;
1404
1405 if (len > INT_MAX/size) {
1406 PyErr_SetString(PyExc_MemoryError,
1407 "not enough memory for output buffer");
1408 return 0;
1409 }
1410 rv = PyString_FromStringAndSize(NULL, len*size);
1411 if ( rv == 0 )
1412 return 0;
1413 ncp = (signed char *)PyString_AsString(rv);
1414
1415 for ( i=0; i < len*size; i += size ) {
1416 cval = *cp++;
1417 val = st_alaw2linear16(cval);
1418
1419 if ( size == 1 ) *CHARP(ncp, i) = (signed char)(val >> 8);
1420 else if ( size == 2 ) *SHORTP(ncp, i) = (short)(val);
1421 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)(val<<16);
1422 }
1423 return rv;
1424 }
1425
1426 static PyObject *
audioop_lin2adpcm(PyObject * self,PyObject * args)1427 audioop_lin2adpcm(PyObject *self, PyObject *args)
1428 {
1429 signed char *cp;
1430 signed char *ncp;
1431 int len, size, val = 0, step, valpred, delta,
1432 index, sign, vpdiff, diff;
1433 PyObject *rv, *state, *str;
1434 int i, outputbuffer = 0, bufferstep;
1435
1436 if ( !PyArg_ParseTuple(args, "s#iO:lin2adpcm",
1437 &cp, &len, &size, &state) )
1438 return 0;
1439
1440 if (!audioop_check_parameters(len, size))
1441 return NULL;
1442
1443 /* Decode state, should have (value, step) */
1444 if ( state == Py_None ) {
1445 /* First time, it seems. Set defaults */
1446 valpred = 0;
1447 index = 0;
1448 }
1449 else if (!PyTuple_Check(state)) {
1450 PyErr_SetString(PyExc_TypeError, "state must be a tuple or None");
1451 return NULL;
1452 }
1453 else if (!PyArg_ParseTuple(state, "ii", &valpred, &index)) {
1454 return NULL;
1455 }
1456 else if (valpred >= 0x8000 || valpred < -0x8000 ||
1457 (size_t)index >= sizeof(stepsizeTable)/sizeof(stepsizeTable[0])) {
1458 PyErr_SetString(PyExc_ValueError, "bad state");
1459 return NULL;
1460 }
1461
1462 str = PyString_FromStringAndSize(NULL, len/(size*2));
1463 if ( str == 0 )
1464 return 0;
1465 ncp = (signed char *)PyString_AsString(str);
1466
1467 step = stepsizeTable[index];
1468 bufferstep = 1;
1469
1470 for ( i=0; i < len; i += size ) {
1471 if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
1472 else if ( size == 2 ) val = (int)*SHORTP(cp, i);
1473 else if ( size == 4 ) val = ((int)*LONGP(cp, i)) >> 16;
1474
1475 /* Step 1 - compute difference with previous value */
1476 diff = val - valpred;
1477 sign = (diff < 0) ? 8 : 0;
1478 if ( sign ) diff = (-diff);
1479
1480 /* Step 2 - Divide and clamp */
1481 /* Note:
1482 ** This code *approximately* computes:
1483 ** delta = diff*4/step;
1484 ** vpdiff = (delta+0.5)*step/4;
1485 ** but in shift step bits are dropped. The net result of this
1486 ** is that even if you have fast mul/div hardware you cannot
1487 ** put it to good use since the fixup would be too expensive.
1488 */
1489 delta = 0;
1490 vpdiff = (step >> 3);
1491
1492 if ( diff >= step ) {
1493 delta = 4;
1494 diff -= step;
1495 vpdiff += step;
1496 }
1497 step >>= 1;
1498 if ( diff >= step ) {
1499 delta |= 2;
1500 diff -= step;
1501 vpdiff += step;
1502 }
1503 step >>= 1;
1504 if ( diff >= step ) {
1505 delta |= 1;
1506 vpdiff += step;
1507 }
1508
1509 /* Step 3 - Update previous value */
1510 if ( sign )
1511 valpred -= vpdiff;
1512 else
1513 valpred += vpdiff;
1514
1515 /* Step 4 - Clamp previous value to 16 bits */
1516 if ( valpred > 32767 )
1517 valpred = 32767;
1518 else if ( valpred < -32768 )
1519 valpred = -32768;
1520
1521 /* Step 5 - Assemble value, update index and step values */
1522 delta |= sign;
1523
1524 index += indexTable[delta];
1525 if ( index < 0 ) index = 0;
1526 if ( index > 88 ) index = 88;
1527 step = stepsizeTable[index];
1528
1529 /* Step 6 - Output value */
1530 if ( bufferstep ) {
1531 outputbuffer = (delta << 4) & 0xf0;
1532 } else {
1533 *ncp++ = (delta & 0x0f) | outputbuffer;
1534 }
1535 bufferstep = !bufferstep;
1536 }
1537 rv = Py_BuildValue("(O(ii))", str, valpred, index);
1538 Py_DECREF(str);
1539 return rv;
1540 }
1541
1542 static PyObject *
audioop_adpcm2lin(PyObject * self,PyObject * args)1543 audioop_adpcm2lin(PyObject *self, PyObject *args)
1544 {
1545 signed char *cp;
1546 signed char *ncp;
1547 int len, size, valpred, step, delta, index, sign, vpdiff;
1548 PyObject *rv, *str, *state;
1549 int i, inputbuffer = 0, bufferstep;
1550
1551 if ( !PyArg_ParseTuple(args, "s#iO:adpcm2lin",
1552 &cp, &len, &size, &state) )
1553 return 0;
1554
1555 if (!audioop_check_size(size))
1556 return NULL;
1557
1558 /* Decode state, should have (value, step) */
1559 if ( state == Py_None ) {
1560 /* First time, it seems. Set defaults */
1561 valpred = 0;
1562 index = 0;
1563 }
1564 else if (!PyTuple_Check(state)) {
1565 PyErr_SetString(PyExc_TypeError, "state must be a tuple or None");
1566 return NULL;
1567 }
1568 else if (!PyArg_ParseTuple(state, "ii", &valpred, &index)) {
1569 return NULL;
1570 }
1571 else if (valpred >= 0x8000 || valpred < -0x8000 ||
1572 (size_t)index >= sizeof(stepsizeTable)/sizeof(stepsizeTable[0])) {
1573 PyErr_SetString(PyExc_ValueError, "bad state");
1574 return NULL;
1575 }
1576
1577 if (len > (INT_MAX/2)/size) {
1578 PyErr_SetString(PyExc_MemoryError,
1579 "not enough memory for output buffer");
1580 return 0;
1581 }
1582 str = PyString_FromStringAndSize(NULL, len*size*2);
1583 if ( str == 0 )
1584 return 0;
1585 ncp = (signed char *)PyString_AsString(str);
1586
1587 step = stepsizeTable[index];
1588 bufferstep = 0;
1589
1590 for ( i=0; i < len*size*2; i += size ) {
1591 /* Step 1 - get the delta value and compute next index */
1592 if ( bufferstep ) {
1593 delta = inputbuffer & 0xf;
1594 } else {
1595 inputbuffer = *cp++;
1596 delta = (inputbuffer >> 4) & 0xf;
1597 }
1598
1599 bufferstep = !bufferstep;
1600
1601 /* Step 2 - Find new index value (for later) */
1602 index += indexTable[delta];
1603 if ( index < 0 ) index = 0;
1604 if ( index > 88 ) index = 88;
1605
1606 /* Step 3 - Separate sign and magnitude */
1607 sign = delta & 8;
1608 delta = delta & 7;
1609
1610 /* Step 4 - Compute difference and new predicted value */
1611 /*
1612 ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
1613 ** in adpcm_coder.
1614 */
1615 vpdiff = step >> 3;
1616 if ( delta & 4 ) vpdiff += step;
1617 if ( delta & 2 ) vpdiff += step>>1;
1618 if ( delta & 1 ) vpdiff += step>>2;
1619
1620 if ( sign )
1621 valpred -= vpdiff;
1622 else
1623 valpred += vpdiff;
1624
1625 /* Step 5 - clamp output value */
1626 if ( valpred > 32767 )
1627 valpred = 32767;
1628 else if ( valpred < -32768 )
1629 valpred = -32768;
1630
1631 /* Step 6 - Update step value */
1632 step = stepsizeTable[index];
1633
1634 /* Step 6 - Output value */
1635 if ( size == 1 ) *CHARP(ncp, i) = (signed char)(valpred >> 8);
1636 else if ( size == 2 ) *SHORTP(ncp, i) = (short)(valpred);
1637 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)(valpred<<16);
1638 }
1639
1640 rv = Py_BuildValue("(O(ii))", str, valpred, index);
1641 Py_DECREF(str);
1642 return rv;
1643 }
1644
1645 static PyMethodDef audioop_methods[] = {
1646 { "max", audioop_max, METH_VARARGS },
1647 { "minmax", audioop_minmax, METH_VARARGS },
1648 { "avg", audioop_avg, METH_VARARGS },
1649 { "maxpp", audioop_maxpp, METH_VARARGS },
1650 { "avgpp", audioop_avgpp, METH_VARARGS },
1651 { "rms", audioop_rms, METH_VARARGS },
1652 { "findfit", audioop_findfit, METH_VARARGS },
1653 { "findmax", audioop_findmax, METH_VARARGS },
1654 { "findfactor", audioop_findfactor, METH_VARARGS },
1655 { "cross", audioop_cross, METH_VARARGS },
1656 { "mul", audioop_mul, METH_VARARGS },
1657 { "add", audioop_add, METH_VARARGS },
1658 { "bias", audioop_bias, METH_VARARGS },
1659 { "ulaw2lin", audioop_ulaw2lin, METH_VARARGS },
1660 { "lin2ulaw", audioop_lin2ulaw, METH_VARARGS },
1661 { "alaw2lin", audioop_alaw2lin, METH_VARARGS },
1662 { "lin2alaw", audioop_lin2alaw, METH_VARARGS },
1663 { "lin2lin", audioop_lin2lin, METH_VARARGS },
1664 { "adpcm2lin", audioop_adpcm2lin, METH_VARARGS },
1665 { "lin2adpcm", audioop_lin2adpcm, METH_VARARGS },
1666 { "tomono", audioop_tomono, METH_VARARGS },
1667 { "tostereo", audioop_tostereo, METH_VARARGS },
1668 { "getsample", audioop_getsample, METH_VARARGS },
1669 { "reverse", audioop_reverse, METH_VARARGS },
1670 { "ratecv", audioop_ratecv, METH_VARARGS },
1671 { 0, 0 }
1672 };
1673
1674 PyMODINIT_FUNC
initaudioop(void)1675 initaudioop(void)
1676 {
1677 PyObject *m, *d;
1678 m = Py_InitModule("audioop", audioop_methods);
1679 if (m == NULL)
1680 return;
1681 d = PyModule_GetDict(m);
1682 if (d == NULL)
1683 return;
1684 AudioopError = PyErr_NewException("audioop.error", NULL, NULL);
1685 if (AudioopError != NULL)
1686 PyDict_SetItemString(d,"error",AudioopError);
1687 }
1688