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