2 /* audioopmodule - Module to detect peak values in arrays */
8 typedef unsigned int Py_UInt32
;
11 typedef long Py_Int32
;
12 typedef unsigned long Py_UInt32
;
14 #error "No 4-byte integral type"
18 typedef short PyInt16
;
20 #if defined(__CHAR_UNSIGNED__)
22 /* This module currently does not work on systems where only unsigned
23 characters are available. Take it out of Setup. Sorry. */
27 /* Code shamelessly stolen from sox, 12.17.7, g711.c
28 ** (c) Craig Reese, Joe Campbell and Jeff Poskanzer 1989 */
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
37 * Borge Lindberg, Center for PersonKommunikation, Aalborg University.
41 #define BIAS 0x84 /* define the add-in bias for 16 bit samples */
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. */
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};
54 search(PyInt16 val
, PyInt16
*table
, int size
)
58 for (i
= 0; i
< size
; i
++) {
64 #define st_ulaw2linear16(uc) (_st_ulaw2linear16[uc])
65 #define st_alaw2linear16(uc) (_st_alaw2linear16[uc])
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,
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
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:
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
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.
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.
136 * For further information see John C. Bellamy's Digital Telephony, 1982,
137 * John Wiley & Sons, pps 98-111 and 472-476.
140 st_14linear2ulaw(PyInt16 pcm_val
) /* 2's complement (14-bit range) */
146 /* The original sox code does this in the calling function, not here */
147 pcm_val
= pcm_val
>> 2;
149 /* u-law inverts all bits */
150 /* Get the sign and the magnitude of the value. */
157 if ( pcm_val
> CLIP
) pcm_val
= CLIP
; /* clip the magnitude */
158 pcm_val
+= (BIAS
>> 2);
160 /* Convert the scaled magnitude to segment number. */
161 seg
= search(pcm_val
, seg_uend
, 8);
164 * Combine the sign, segment, quantization bits;
165 * and complement the code word.
167 if (seg
>= 8) /* out of range, return maximum value. */
168 return (unsigned char) (0x7F ^ mask
);
170 uval
= (unsigned char) (seg
<< 4) | ((pcm_val
>> (seg
+ 1)) & 0xF);
171 return (uval
^ mask
);
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,
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
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
233 * For further information see John C. Bellamy's Digital Telephony, 1982,
234 * John Wiley & Sons, pps 98-111 and 472-476.
237 st_linear2alaw(PyInt16 pcm_val
) /* 2's complement (13-bit range) */
243 /* The original sox code does this in the calling function, not here */
244 pcm_val
= pcm_val
>> 3;
246 /* A-law using even bit inversion */
248 mask
= 0xD5; /* sign (7th) bit = 1 */
250 mask
= 0x55; /* sign bit = 0 */
251 pcm_val
= -pcm_val
- 1;
254 /* Convert the scaled magnitude to segment number. */
255 seg
= search(pcm_val
, seg_aend
, 8);
257 /* Combine the sign, segment, and quantization bits. */
259 if (seg
>= 8) /* out of range, return maximum value. */
260 return (unsigned char) (0x7F ^ mask
);
262 aval
= (unsigned char) seg
<< SEG_SHIFT
;
264 aval
|= (pcm_val
>> 1) & QUANT_MASK
;
266 aval
|= (pcm_val
>> seg
) & QUANT_MASK
;
267 return (aval
^ mask
);
270 /* End of code taken from sox */
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,
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
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))
296 static PyObject
*AudioopError
;
299 audioop_getsample(PyObject
*self
, PyObject
*args
)
302 int len
, size
, val
= 0;
305 if ( !PyArg_ParseTuple(args
, "s#ii:getsample", &cp
, &len
, &size
, &i
) )
307 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
308 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
311 if ( i
< 0 || i
>= len
/size
) {
312 PyErr_SetString(AudioopError
, "Index out of range");
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 PyInt_FromLong(val
);
322 audioop_max(PyObject
*self
, PyObject
*args
)
325 int len
, size
, val
= 0;
329 if ( !PyArg_ParseTuple(args
, "s#i:max", &cp
, &len
, &size
) )
331 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
332 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
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
;
342 return PyInt_FromLong(max
);
346 audioop_minmax(PyObject
*self
, PyObject
*args
)
349 int len
, size
, val
= 0;
351 int min
= 0x7fffffff, max
= -0x7fffffff;
353 if (!PyArg_ParseTuple(args
, "s#i:minmax", &cp
, &len
, &size
))
355 if (size
!= 1 && size
!= 2 && size
!= 4) {
356 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
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
;
366 return Py_BuildValue("(ii)", min
, max
);
370 audioop_avg(PyObject
*self
, PyObject
*args
)
373 int len
, size
, val
= 0;
377 if ( !PyArg_ParseTuple(args
, "s#i:avg", &cp
, &len
, &size
) )
379 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
380 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
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
);
392 val
= (int)(avg
/ (double)(len
/size
));
393 return PyInt_FromLong(val
);
397 audioop_rms(PyObject
*self
, PyObject
*args
)
400 int len
, size
, val
= 0;
402 double sum_squares
= 0.0;
404 if ( !PyArg_ParseTuple(args
, "s#i:rms", &cp
, &len
, &size
) )
406 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
407 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
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
;
419 val
= (int)sqrt(sum_squares
/ (double)(len
/size
));
420 return PyInt_FromLong(val
);
423 static double _sum2(short *a
, short *b
, int len
)
428 for( i
=0; i
<len
; i
++) {
429 sum
= sum
+ (double)a
[i
]*(double)b
[i
];
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:
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.
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).
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 )
452 ** In the code variables correspond as follows:
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])
463 ** sum_ri is calculated once, sum_aij_2 is updated each step and sum_aij_ri
464 ** is completely recalculated each step.
467 audioop_findfit(PyObject
*self
, PyObject
*args
)
472 double aj_m1
, aj_lm1
;
473 double sum_ri_2
, sum_aij_2
, sum_aij_ri
, result
, best_result
, factor
;
475 if ( !PyArg_ParseTuple(args
, "s#s#:findfit",
476 &cp1
, &len1
, &cp2
, &len2
) )
478 if ( len1
& 1 || len2
& 1 ) {
479 PyErr_SetString(AudioopError
, "Strings should be even-sized");
486 PyErr_SetString(AudioopError
, "First sample should be longer");
489 sum_ri_2
= _sum2(cp2
, cp2
, len2
);
490 sum_aij_2
= _sum2(cp1
, cp1
, len2
);
491 sum_aij_ri
= _sum2(cp1
, cp2
, len2
);
493 result
= (sum_ri_2
*sum_aij_2
- sum_aij_ri
*sum_aij_ri
) / sum_aij_2
;
495 best_result
= result
;
499 for ( j
=1; j
<=len1
-len2
; j
++) {
500 aj_m1
= (double)cp1
[j
-1];
501 aj_lm1
= (double)cp1
[j
+len2
-1];
503 sum_aij_2
= sum_aij_2
+ aj_lm1
*aj_lm1
- aj_m1
*aj_m1
;
504 sum_aij_ri
= _sum2(cp1
+j
, cp2
, len2
);
506 result
= (sum_ri_2
*sum_aij_2
- sum_aij_ri
*sum_aij_ri
)
509 if ( result
< best_result
) {
510 best_result
= result
;
516 factor
= _sum2(cp1
+best_j
, cp2
, len2
) / sum_ri_2
;
518 return Py_BuildValue("(if)", best_j
, factor
);
522 ** findfactor finds a factor f so that the energy in A-fB is minimal.
523 ** See the comment for findfit for details.
526 audioop_findfactor(PyObject
*self
, PyObject
*args
)
530 double sum_ri_2
, sum_aij_ri
, result
;
532 if ( !PyArg_ParseTuple(args
, "s#s#:findfactor",
533 &cp1
, &len1
, &cp2
, &len2
) )
535 if ( len1
& 1 || len2
& 1 ) {
536 PyErr_SetString(AudioopError
, "Strings should be even-sized");
539 if ( len1
!= len2
) {
540 PyErr_SetString(AudioopError
, "Samples should be same size");
544 sum_ri_2
= _sum2(cp2
, cp2
, len2
);
545 sum_aij_ri
= _sum2(cp1
, cp2
, len2
);
547 result
= sum_aij_ri
/ sum_ri_2
;
549 return PyFloat_FromDouble(result
);
553 ** findmax returns the index of the n-sized segment of the input sample
554 ** that contains the most energy.
557 audioop_findmax(PyObject
*self
, PyObject
*args
)
562 double aj_m1
, aj_lm1
;
563 double result
, best_result
;
565 if ( !PyArg_ParseTuple(args
, "s#i:findmax", &cp1
, &len1
, &len2
) )
568 PyErr_SetString(AudioopError
, "Strings should be even-sized");
574 PyErr_SetString(AudioopError
, "Input sample should be longer");
578 result
= _sum2(cp1
, cp1
, len2
);
580 best_result
= result
;
584 for ( j
=1; j
<=len1
-len2
; j
++) {
585 aj_m1
= (double)cp1
[j
-1];
586 aj_lm1
= (double)cp1
[j
+len2
-1];
588 result
= result
+ aj_lm1
*aj_lm1
- aj_m1
*aj_m1
;
590 if ( result
> best_result
) {
591 best_result
= result
;
597 return PyInt_FromLong(best_j
);
601 audioop_avgpp(PyObject
*self
, PyObject
*args
)
604 int len
, size
, val
= 0, prevval
= 0, prevextremevalid
= 0,
608 int diff
, prevdiff
, extremediff
, nextreme
= 0;
610 if ( !PyArg_ParseTuple(args
, "s#i:avgpp", &cp
, &len
, &size
) )
612 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
613 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
616 /* Compute first delta value ahead. Also automatically makes us
617 ** skip the first extreme value
619 if ( size
== 1 ) prevval
= (int)*CHARP(cp
, 0);
620 else if ( size
== 2 ) prevval
= (int)*SHORTP(cp
, 0);
621 else if ( size
== 4 ) prevval
= (int)*LONGP(cp
, 0);
622 if ( size
== 1 ) val
= (int)*CHARP(cp
, size
);
623 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, size
);
624 else if ( size
== 4 ) val
= (int)*LONGP(cp
, size
);
625 prevdiff
= val
- prevval
;
627 for ( i
=size
; i
<len
; i
+= size
) {
628 if ( size
== 1 ) val
= (int)*CHARP(cp
, i
);
629 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
630 else if ( size
== 4 ) val
= (int)*LONGP(cp
, i
);
631 diff
= val
- prevval
;
632 if ( diff
*prevdiff
< 0 ) {
633 /* Derivative changed sign. Compute difference to last
634 ** extreme value and remember.
636 if ( prevextremevalid
) {
637 extremediff
= prevval
- prevextreme
;
638 if ( extremediff
< 0 )
639 extremediff
= -extremediff
;
643 prevextremevalid
= 1;
644 prevextreme
= prevval
;
653 val
= (int)(avg
/ (double)nextreme
);
654 return PyInt_FromLong(val
);
658 audioop_maxpp(PyObject
*self
, PyObject
*args
)
661 int len
, size
, val
= 0, prevval
= 0, prevextremevalid
= 0,
665 int diff
, prevdiff
, extremediff
;
667 if ( !PyArg_ParseTuple(args
, "s#i:maxpp", &cp
, &len
, &size
) )
669 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
670 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
673 /* Compute first delta value ahead. Also automatically makes us
674 ** skip the first extreme value
676 if ( size
== 1 ) prevval
= (int)*CHARP(cp
, 0);
677 else if ( size
== 2 ) prevval
= (int)*SHORTP(cp
, 0);
678 else if ( size
== 4 ) prevval
= (int)*LONGP(cp
, 0);
679 if ( size
== 1 ) val
= (int)*CHARP(cp
, size
);
680 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, size
);
681 else if ( size
== 4 ) val
= (int)*LONGP(cp
, size
);
682 prevdiff
= val
- prevval
;
684 for ( i
=size
; i
<len
; i
+= size
) {
685 if ( size
== 1 ) val
= (int)*CHARP(cp
, i
);
686 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
687 else if ( size
== 4 ) val
= (int)*LONGP(cp
, i
);
688 diff
= val
- prevval
;
689 if ( diff
*prevdiff
< 0 ) {
690 /* Derivative changed sign. Compute difference to
691 ** last extreme value and remember.
693 if ( prevextremevalid
) {
694 extremediff
= prevval
- prevextreme
;
695 if ( extremediff
< 0 )
696 extremediff
= -extremediff
;
697 if ( extremediff
> max
)
700 prevextremevalid
= 1;
701 prevextreme
= prevval
;
707 return PyInt_FromLong(max
);
711 audioop_cross(PyObject
*self
, PyObject
*args
)
714 int len
, size
, val
= 0;
718 if ( !PyArg_ParseTuple(args
, "s#i:cross", &cp
, &len
, &size
) )
720 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
721 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
725 prevval
= 17; /* Anything <> 0,1 */
726 for ( i
=0; i
<len
; i
+= size
) {
727 if ( size
== 1 ) val
= ((int)*CHARP(cp
, i
)) >> 7;
728 else if ( size
== 2 ) val
= ((int)*SHORTP(cp
, i
)) >> 15;
729 else if ( size
== 4 ) val
= ((int)*LONGP(cp
, i
)) >> 31;
731 if ( val
!= prevval
) ncross
++;
734 return PyInt_FromLong(ncross
);
738 audioop_mul(PyObject
*self
, PyObject
*args
)
740 signed char *cp
, *ncp
;
741 int len
, size
, val
= 0;
742 double factor
, fval
, maxval
;
746 if ( !PyArg_ParseTuple(args
, "s#id:mul", &cp
, &len
, &size
, &factor
) )
749 if ( size
== 1 ) maxval
= (double) 0x7f;
750 else if ( size
== 2 ) maxval
= (double) 0x7fff;
751 else if ( size
== 4 ) maxval
= (double) 0x7fffffff;
753 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
757 rv
= PyString_FromStringAndSize(NULL
, len
);
760 ncp
= (signed char *)PyString_AsString(rv
);
763 for ( i
=0; i
< len
; i
+= size
) {
764 if ( size
== 1 ) val
= (int)*CHARP(cp
, i
);
765 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
766 else if ( size
== 4 ) val
= (int)*LONGP(cp
, i
);
767 fval
= (double)val
*factor
;
768 if ( fval
> maxval
) fval
= maxval
;
769 else if ( fval
< -maxval
) fval
= -maxval
;
771 if ( size
== 1 ) *CHARP(ncp
, i
) = (signed char)val
;
772 else if ( size
== 2 ) *SHORTP(ncp
, i
) = (short)val
;
773 else if ( size
== 4 ) *LONGP(ncp
, i
) = (Py_Int32
)val
;
779 audioop_tomono(PyObject
*self
, PyObject
*args
)
781 signed char *cp
, *ncp
;
782 int len
, size
, val1
= 0, val2
= 0;
783 double fac1
, fac2
, fval
, maxval
;
787 if ( !PyArg_ParseTuple(args
, "s#idd:tomono",
788 &cp
, &len
, &size
, &fac1
, &fac2
) )
791 if ( size
== 1 ) maxval
= (double) 0x7f;
792 else if ( size
== 2 ) maxval
= (double) 0x7fff;
793 else if ( size
== 4 ) maxval
= (double) 0x7fffffff;
795 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
799 rv
= PyString_FromStringAndSize(NULL
, len
/2);
802 ncp
= (signed char *)PyString_AsString(rv
);
805 for ( i
=0; i
< len
; i
+= size
*2 ) {
806 if ( size
== 1 ) val1
= (int)*CHARP(cp
, i
);
807 else if ( size
== 2 ) val1
= (int)*SHORTP(cp
, i
);
808 else if ( size
== 4 ) val1
= (int)*LONGP(cp
, i
);
809 if ( size
== 1 ) val2
= (int)*CHARP(cp
, i
+1);
810 else if ( size
== 2 ) val2
= (int)*SHORTP(cp
, i
+2);
811 else if ( size
== 4 ) val2
= (int)*LONGP(cp
, i
+4);
812 fval
= (double)val1
*fac1
+ (double)val2
*fac2
;
813 if ( fval
> maxval
) fval
= maxval
;
814 else if ( fval
< -maxval
) fval
= -maxval
;
816 if ( size
== 1 ) *CHARP(ncp
, i
/2) = (signed char)val1
;
817 else if ( size
== 2 ) *SHORTP(ncp
, i
/2) = (short)val1
;
818 else if ( size
== 4 ) *LONGP(ncp
, i
/2)= (Py_Int32
)val1
;
824 audioop_tostereo(PyObject
*self
, PyObject
*args
)
826 signed char *cp
, *ncp
;
827 int len
, size
, val1
, val2
, val
= 0;
828 double fac1
, fac2
, fval
, maxval
;
832 if ( !PyArg_ParseTuple(args
, "s#idd:tostereo",
833 &cp
, &len
, &size
, &fac1
, &fac2
) )
836 if ( size
== 1 ) maxval
= (double) 0x7f;
837 else if ( size
== 2 ) maxval
= (double) 0x7fff;
838 else if ( size
== 4 ) maxval
= (double) 0x7fffffff;
840 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
844 rv
= PyString_FromStringAndSize(NULL
, len
*2);
847 ncp
= (signed char *)PyString_AsString(rv
);
850 for ( i
=0; i
< len
; i
+= size
) {
851 if ( size
== 1 ) val
= (int)*CHARP(cp
, i
);
852 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
853 else if ( size
== 4 ) val
= (int)*LONGP(cp
, i
);
855 fval
= (double)val
*fac1
;
856 if ( fval
> maxval
) fval
= maxval
;
857 else if ( fval
< -maxval
) fval
= -maxval
;
860 fval
= (double)val
*fac2
;
861 if ( fval
> maxval
) fval
= maxval
;
862 else if ( fval
< -maxval
) fval
= -maxval
;
865 if ( size
== 1 ) *CHARP(ncp
, i
*2) = (signed char)val1
;
866 else if ( size
== 2 ) *SHORTP(ncp
, i
*2) = (short)val1
;
867 else if ( size
== 4 ) *LONGP(ncp
, i
*2) = (Py_Int32
)val1
;
869 if ( size
== 1 ) *CHARP(ncp
, i
*2+1) = (signed char)val2
;
870 else if ( size
== 2 ) *SHORTP(ncp
, i
*2+2) = (short)val2
;
871 else if ( size
== 4 ) *LONGP(ncp
, i
*2+4) = (Py_Int32
)val2
;
877 audioop_add(PyObject
*self
, PyObject
*args
)
879 signed char *cp1
, *cp2
, *ncp
;
880 int len1
, len2
, size
, val1
= 0, val2
= 0, maxval
, newval
;
884 if ( !PyArg_ParseTuple(args
, "s#s#i:add",
885 &cp1
, &len1
, &cp2
, &len2
, &size
) )
888 if ( len1
!= len2
) {
889 PyErr_SetString(AudioopError
, "Lengths should be the same");
893 if ( size
== 1 ) maxval
= 0x7f;
894 else if ( size
== 2 ) maxval
= 0x7fff;
895 else if ( size
== 4 ) maxval
= 0x7fffffff;
897 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
901 rv
= PyString_FromStringAndSize(NULL
, len1
);
904 ncp
= (signed char *)PyString_AsString(rv
);
906 for ( i
=0; i
< len1
; i
+= size
) {
907 if ( size
== 1 ) val1
= (int)*CHARP(cp1
, i
);
908 else if ( size
== 2 ) val1
= (int)*SHORTP(cp1
, i
);
909 else if ( size
== 4 ) val1
= (int)*LONGP(cp1
, i
);
911 if ( size
== 1 ) val2
= (int)*CHARP(cp2
, i
);
912 else if ( size
== 2 ) val2
= (int)*SHORTP(cp2
, i
);
913 else if ( size
== 4 ) val2
= (int)*LONGP(cp2
, i
);
915 newval
= val1
+ val2
;
916 /* truncate in case of overflow */
917 if (newval
> maxval
) newval
= maxval
;
918 else if (newval
< -maxval
) newval
= -maxval
;
919 else if (size
== 4 && (newval
^val1
) < 0 && (newval
^val2
) < 0)
920 newval
= val1
> 0 ? maxval
: - maxval
;
922 if ( size
== 1 ) *CHARP(ncp
, i
) = (signed char)newval
;
923 else if ( size
== 2 ) *SHORTP(ncp
, i
) = (short)newval
;
924 else if ( size
== 4 ) *LONGP(ncp
, i
) = (Py_Int32
)newval
;
930 audioop_bias(PyObject
*self
, PyObject
*args
)
932 signed char *cp
, *ncp
;
933 int len
, size
, val
= 0;
938 if ( !PyArg_ParseTuple(args
, "s#ii:bias",
939 &cp
, &len
, &size
, &bias
) )
942 if ( size
!= 1 && size
!= 2 && size
!= 4) {
943 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
947 rv
= PyString_FromStringAndSize(NULL
, len
);
950 ncp
= (signed char *)PyString_AsString(rv
);
953 for ( i
=0; i
< len
; i
+= size
) {
954 if ( size
== 1 ) val
= (int)*CHARP(cp
, i
);
955 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
956 else if ( size
== 4 ) val
= (int)*LONGP(cp
, i
);
958 if ( size
== 1 ) *CHARP(ncp
, i
) = (signed char)(val
+bias
);
959 else if ( size
== 2 ) *SHORTP(ncp
, i
) = (short)(val
+bias
);
960 else if ( size
== 4 ) *LONGP(ncp
, i
) = (Py_Int32
)(val
+bias
);
966 audioop_reverse(PyObject
*self
, PyObject
*args
)
970 int len
, size
, val
= 0;
974 if ( !PyArg_ParseTuple(args
, "s#i:reverse",
978 if ( size
!= 1 && size
!= 2 && size
!= 4 ) {
979 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
983 rv
= PyString_FromStringAndSize(NULL
, len
);
986 ncp
= (unsigned char *)PyString_AsString(rv
);
988 for ( i
=0; i
< len
; i
+= size
) {
989 if ( size
== 1 ) val
= ((int)*CHARP(cp
, i
)) << 8;
990 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
991 else if ( size
== 4 ) val
= ((int)*LONGP(cp
, i
)) >> 16;
995 if ( size
== 1 ) *CHARP(ncp
, j
) = (signed char)(val
>> 8);
996 else if ( size
== 2 ) *SHORTP(ncp
, j
) = (short)(val
);
997 else if ( size
== 4 ) *LONGP(ncp
, j
) = (Py_Int32
)(val
<<16);
1003 audioop_lin2lin(PyObject
*self
, PyObject
*args
)
1007 int len
, size
, size2
, val
= 0;
1011 if ( !PyArg_ParseTuple(args
, "s#ii:lin2lin",
1012 &cp
, &len
, &size
, &size2
) )
1015 if ( (size
!= 1 && size
!= 2 && size
!= 4) ||
1016 (size2
!= 1 && size2
!= 2 && size2
!= 4)) {
1017 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1021 rv
= PyString_FromStringAndSize(NULL
, (len
/size
)*size2
);
1024 ncp
= (unsigned char *)PyString_AsString(rv
);
1026 for ( i
=0, j
=0; i
< len
; i
+= size
, j
+= size2
) {
1027 if ( size
== 1 ) val
= ((int)*CHARP(cp
, i
)) << 8;
1028 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
1029 else if ( size
== 4 ) val
= ((int)*LONGP(cp
, i
)) >> 16;
1031 if ( size2
== 1 ) *CHARP(ncp
, j
) = (signed char)(val
>> 8);
1032 else if ( size2
== 2 ) *SHORTP(ncp
, j
) = (short)(val
);
1033 else if ( size2
== 4 ) *LONGP(ncp
, j
) = (Py_Int32
)(val
<<16);
1050 audioop_ratecv(PyObject
*self
, PyObject
*args
)
1053 int len
, size
, nchannels
, inrate
, outrate
, weightA
, weightB
;
1054 int chan
, d
, *prev_i
, *cur_i
, cur_o
;
1055 PyObject
*state
, *samps
, *str
, *rv
= NULL
;
1056 int bytes_per_frame
;
1060 if (!PyArg_ParseTuple(args
, "s#iiiiO|ii:ratecv", &cp
, &len
, &size
,
1061 &nchannels
, &inrate
, &outrate
, &state
,
1062 &weightA
, &weightB
))
1064 if (size
!= 1 && size
!= 2 && size
!= 4) {
1065 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1068 if (nchannels
< 1) {
1069 PyErr_SetString(AudioopError
, "# of channels should be >= 1");
1072 bytes_per_frame
= size
* nchannels
;
1073 if (bytes_per_frame
/ nchannels
!= size
) {
1074 /* This overflow test is rigorously correct because
1075 both multiplicands are >= 1. Use the argument names
1076 from the docs for the error msg. */
1077 PyErr_SetString(PyExc_OverflowError
,
1078 "width * nchannels too big for a C int");
1081 if (weightA
< 1 || weightB
< 0) {
1082 PyErr_SetString(AudioopError
,
1083 "weightA should be >= 1, weightB should be >= 0");
1086 if (len
% bytes_per_frame
!= 0) {
1087 PyErr_SetString(AudioopError
, "not a whole number of frames");
1090 if (inrate
<= 0 || outrate
<= 0) {
1091 PyErr_SetString(AudioopError
, "sampling rate not > 0");
1094 /* divide inrate and outrate by their greatest common divisor */
1095 d
= gcd(inrate
, outrate
);
1099 prev_i
= (int *) malloc(nchannels
* sizeof(int));
1100 cur_i
= (int *) malloc(nchannels
* sizeof(int));
1101 if (prev_i
== NULL
|| cur_i
== NULL
) {
1102 (void) PyErr_NoMemory();
1106 len
/= bytes_per_frame
; /* # of frames */
1108 if (state
== Py_None
) {
1110 for (chan
= 0; chan
< nchannels
; chan
++)
1111 prev_i
[chan
] = cur_i
[chan
] = 0;
1114 if (!PyArg_ParseTuple(state
,
1115 "iO!;audioop.ratecv: illegal state argument",
1116 &d
, &PyTuple_Type
, &samps
))
1118 if (PyTuple_Size(samps
) != nchannels
) {
1119 PyErr_SetString(AudioopError
,
1120 "illegal state argument");
1123 for (chan
= 0; chan
< nchannels
; chan
++) {
1124 if (!PyArg_ParseTuple(PyTuple_GetItem(samps
, chan
),
1125 "ii:ratecv", &prev_i
[chan
],
1131 /* str <- Space for the output buffer. */
1133 /* There are len input frames, so we need (mathematically)
1134 ceiling(len*outrate/inrate) output frames, and each frame
1135 requires bytes_per_frame bytes. Computing this
1136 without spurious overflow is the challenge; we can
1137 settle for a reasonable upper bound, though. */
1138 int ceiling
; /* the number of output frames */
1139 int nbytes
; /* the number of output bytes needed */
1140 int q
= len
/ inrate
;
1141 /* Now len = q * inrate + r exactly (with r = len % inrate),
1142 and this is less than q * inrate + inrate = (q+1)*inrate.
1143 So a reasonable upper bound on len*outrate/inrate is
1144 ((q+1)*inrate)*outrate/inrate =
1147 ceiling
= (q
+1) * outrate
;
1148 nbytes
= ceiling
* bytes_per_frame
;
1149 /* See whether anything overflowed; if not, get the space. */
1151 ceiling
/ outrate
!= q
+1 ||
1152 nbytes
/ bytes_per_frame
!= ceiling
)
1155 str
= PyString_FromStringAndSize(NULL
, nbytes
);
1158 PyErr_SetString(PyExc_MemoryError
,
1159 "not enough memory for output buffer");
1163 ncp
= PyString_AsString(str
);
1168 samps
= PyTuple_New(nchannels
);
1171 for (chan
= 0; chan
< nchannels
; chan
++)
1172 PyTuple_SetItem(samps
, chan
,
1173 Py_BuildValue("(ii)",
1176 if (PyErr_Occurred())
1178 /* We have checked before that the length
1179 * of the string fits into int. */
1180 len
= (int)(ncp
- PyString_AsString(str
));
1182 /*don't want to resize to zero length*/
1183 rv
= PyString_FromStringAndSize("", 0);
1186 } else if (_PyString_Resize(&str
, len
) < 0)
1188 rv
= Py_BuildValue("(O(iO))", str
, d
, samps
);
1191 goto exit
; /* return rv */
1193 for (chan
= 0; chan
< nchannels
; chan
++) {
1194 prev_i
[chan
] = cur_i
[chan
];
1196 cur_i
[chan
] = ((int)*CHARP(cp
, 0)) << 8;
1198 cur_i
[chan
] = (int)*SHORTP(cp
, 0);
1200 cur_i
[chan
] = ((int)*LONGP(cp
, 0)) >> 16;
1202 /* implements a simple digital filter */
1204 (weightA
* cur_i
[chan
] +
1205 weightB
* prev_i
[chan
]) /
1206 (weightA
+ weightB
);
1212 for (chan
= 0; chan
< nchannels
; chan
++) {
1213 cur_o
= (prev_i
[chan
] * d
+
1214 cur_i
[chan
] * (outrate
- d
)) /
1217 *CHARP(ncp
, 0) = (signed char)(cur_o
>> 8);
1219 *SHORTP(ncp
, 0) = (short)(cur_o
);
1221 *LONGP(ncp
, 0) = (Py_Int32
)(cur_o
<<16);
1236 audioop_lin2ulaw(PyObject
*self
, PyObject
*args
)
1240 int len
, size
, val
= 0;
1244 if ( !PyArg_ParseTuple(args
, "s#i:lin2ulaw",
1248 if ( size
!= 1 && size
!= 2 && size
!= 4) {
1249 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1253 rv
= PyString_FromStringAndSize(NULL
, len
/size
);
1256 ncp
= (unsigned char *)PyString_AsString(rv
);
1258 for ( i
=0; i
< len
; i
+= size
) {
1259 if ( size
== 1 ) val
= ((int)*CHARP(cp
, i
)) << 8;
1260 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
1261 else if ( size
== 4 ) val
= ((int)*LONGP(cp
, i
)) >> 16;
1263 *ncp
++ = st_14linear2ulaw(val
);
1269 audioop_ulaw2lin(PyObject
*self
, PyObject
*args
)
1278 if ( !PyArg_ParseTuple(args
, "s#i:ulaw2lin",
1282 if ( size
!= 1 && size
!= 2 && size
!= 4) {
1283 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1287 rv
= PyString_FromStringAndSize(NULL
, len
*size
);
1290 ncp
= (signed char *)PyString_AsString(rv
);
1292 for ( i
=0; i
< len
*size
; i
+= size
) {
1294 val
= st_ulaw2linear16(cval
);
1296 if ( size
== 1 ) *CHARP(ncp
, i
) = (signed char)(val
>> 8);
1297 else if ( size
== 2 ) *SHORTP(ncp
, i
) = (short)(val
);
1298 else if ( size
== 4 ) *LONGP(ncp
, i
) = (Py_Int32
)(val
<<16);
1304 audioop_lin2alaw(PyObject
*self
, PyObject
*args
)
1308 int len
, size
, val
= 0;
1312 if ( !PyArg_ParseTuple(args
, "s#i:lin2alaw",
1316 if ( size
!= 1 && size
!= 2 && size
!= 4) {
1317 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1321 rv
= PyString_FromStringAndSize(NULL
, len
/size
);
1324 ncp
= (unsigned char *)PyString_AsString(rv
);
1326 for ( i
=0; i
< len
; i
+= size
) {
1327 if ( size
== 1 ) val
= ((int)*CHARP(cp
, i
)) << 8;
1328 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
1329 else if ( size
== 4 ) val
= ((int)*LONGP(cp
, i
)) >> 16;
1331 *ncp
++ = st_linear2alaw(val
);
1337 audioop_alaw2lin(PyObject
*self
, PyObject
*args
)
1346 if ( !PyArg_ParseTuple(args
, "s#i:alaw2lin",
1350 if ( size
!= 1 && size
!= 2 && size
!= 4) {
1351 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1355 rv
= PyString_FromStringAndSize(NULL
, len
*size
);
1358 ncp
= (signed char *)PyString_AsString(rv
);
1360 for ( i
=0; i
< len
*size
; i
+= size
) {
1362 val
= st_alaw2linear16(cval
);
1364 if ( size
== 1 ) *CHARP(ncp
, i
) = (signed char)(val
>> 8);
1365 else if ( size
== 2 ) *SHORTP(ncp
, i
) = (short)(val
);
1366 else if ( size
== 4 ) *LONGP(ncp
, i
) = (Py_Int32
)(val
<<16);
1372 audioop_lin2adpcm(PyObject
*self
, PyObject
*args
)
1376 int len
, size
, val
= 0, step
, valpred
, delta
,
1377 index
, sign
, vpdiff
, diff
;
1378 PyObject
*rv
, *state
, *str
;
1379 int i
, outputbuffer
= 0, bufferstep
;
1381 if ( !PyArg_ParseTuple(args
, "s#iO:lin2adpcm",
1382 &cp
, &len
, &size
, &state
) )
1386 if ( size
!= 1 && size
!= 2 && size
!= 4) {
1387 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1391 str
= PyString_FromStringAndSize(NULL
, len
/(size
*2));
1394 ncp
= (signed char *)PyString_AsString(str
);
1396 /* Decode state, should have (value, step) */
1397 if ( state
== Py_None
) {
1398 /* First time, it seems. Set defaults */
1402 } else if ( !PyArg_ParseTuple(state
, "ii", &valpred
, &index
) )
1405 step
= stepsizeTable
[index
];
1408 for ( i
=0; i
< len
; i
+= size
) {
1409 if ( size
== 1 ) val
= ((int)*CHARP(cp
, i
)) << 8;
1410 else if ( size
== 2 ) val
= (int)*SHORTP(cp
, i
);
1411 else if ( size
== 4 ) val
= ((int)*LONGP(cp
, i
)) >> 16;
1413 /* Step 1 - compute difference with previous value */
1414 diff
= val
- valpred
;
1415 sign
= (diff
< 0) ? 8 : 0;
1416 if ( sign
) diff
= (-diff
);
1418 /* Step 2 - Divide and clamp */
1420 ** This code *approximately* computes:
1421 ** delta = diff*4/step;
1422 ** vpdiff = (delta+0.5)*step/4;
1423 ** but in shift step bits are dropped. The net result of this
1424 ** is that even if you have fast mul/div hardware you cannot
1425 ** put it to good use since the fixup would be too expensive.
1428 vpdiff
= (step
>> 3);
1430 if ( diff
>= step
) {
1436 if ( diff
>= step
) {
1442 if ( diff
>= step
) {
1447 /* Step 3 - Update previous value */
1453 /* Step 4 - Clamp previous value to 16 bits */
1454 if ( valpred
> 32767 )
1456 else if ( valpred
< -32768 )
1459 /* Step 5 - Assemble value, update index and step values */
1462 index
+= indexTable
[delta
];
1463 if ( index
< 0 ) index
= 0;
1464 if ( index
> 88 ) index
= 88;
1465 step
= stepsizeTable
[index
];
1467 /* Step 6 - Output value */
1469 outputbuffer
= (delta
<< 4) & 0xf0;
1471 *ncp
++ = (delta
& 0x0f) | outputbuffer
;
1473 bufferstep
= !bufferstep
;
1475 rv
= Py_BuildValue("(O(ii))", str
, valpred
, index
);
1481 audioop_adpcm2lin(PyObject
*self
, PyObject
*args
)
1485 int len
, size
, valpred
, step
, delta
, index
, sign
, vpdiff
;
1486 PyObject
*rv
, *str
, *state
;
1487 int i
, inputbuffer
= 0, bufferstep
;
1489 if ( !PyArg_ParseTuple(args
, "s#iO:adpcm2lin",
1490 &cp
, &len
, &size
, &state
) )
1493 if ( size
!= 1 && size
!= 2 && size
!= 4) {
1494 PyErr_SetString(AudioopError
, "Size should be 1, 2 or 4");
1498 /* Decode state, should have (value, step) */
1499 if ( state
== Py_None
) {
1500 /* First time, it seems. Set defaults */
1504 } else if ( !PyArg_ParseTuple(state
, "ii", &valpred
, &index
) )
1507 str
= PyString_FromStringAndSize(NULL
, len
*size
*2);
1510 ncp
= (signed char *)PyString_AsString(str
);
1512 step
= stepsizeTable
[index
];
1515 for ( i
=0; i
< len
*size
*2; i
+= size
) {
1516 /* Step 1 - get the delta value and compute next index */
1518 delta
= inputbuffer
& 0xf;
1520 inputbuffer
= *cp
++;
1521 delta
= (inputbuffer
>> 4) & 0xf;
1524 bufferstep
= !bufferstep
;
1526 /* Step 2 - Find new index value (for later) */
1527 index
+= indexTable
[delta
];
1528 if ( index
< 0 ) index
= 0;
1529 if ( index
> 88 ) index
= 88;
1531 /* Step 3 - Separate sign and magnitude */
1535 /* Step 4 - Compute difference and new predicted value */
1537 ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
1541 if ( delta
& 4 ) vpdiff
+= step
;
1542 if ( delta
& 2 ) vpdiff
+= step
>>1;
1543 if ( delta
& 1 ) vpdiff
+= step
>>2;
1550 /* Step 5 - clamp output value */
1551 if ( valpred
> 32767 )
1553 else if ( valpred
< -32768 )
1556 /* Step 6 - Update step value */
1557 step
= stepsizeTable
[index
];
1559 /* Step 6 - Output value */
1560 if ( size
== 1 ) *CHARP(ncp
, i
) = (signed char)(valpred
>> 8);
1561 else if ( size
== 2 ) *SHORTP(ncp
, i
) = (short)(valpred
);
1562 else if ( size
== 4 ) *LONGP(ncp
, i
) = (Py_Int32
)(valpred
<<16);
1565 rv
= Py_BuildValue("(O(ii))", str
, valpred
, index
);
1570 static PyMethodDef audioop_methods
[] = {
1571 { "max", audioop_max
, METH_VARARGS
},
1572 { "minmax", audioop_minmax
, METH_VARARGS
},
1573 { "avg", audioop_avg
, METH_VARARGS
},
1574 { "maxpp", audioop_maxpp
, METH_VARARGS
},
1575 { "avgpp", audioop_avgpp
, METH_VARARGS
},
1576 { "rms", audioop_rms
, METH_VARARGS
},
1577 { "findfit", audioop_findfit
, METH_VARARGS
},
1578 { "findmax", audioop_findmax
, METH_VARARGS
},
1579 { "findfactor", audioop_findfactor
, METH_VARARGS
},
1580 { "cross", audioop_cross
, METH_VARARGS
},
1581 { "mul", audioop_mul
, METH_VARARGS
},
1582 { "add", audioop_add
, METH_VARARGS
},
1583 { "bias", audioop_bias
, METH_VARARGS
},
1584 { "ulaw2lin", audioop_ulaw2lin
, METH_VARARGS
},
1585 { "lin2ulaw", audioop_lin2ulaw
, METH_VARARGS
},
1586 { "alaw2lin", audioop_alaw2lin
, METH_VARARGS
},
1587 { "lin2alaw", audioop_lin2alaw
, METH_VARARGS
},
1588 { "lin2lin", audioop_lin2lin
, METH_VARARGS
},
1589 { "adpcm2lin", audioop_adpcm2lin
, METH_VARARGS
},
1590 { "lin2adpcm", audioop_lin2adpcm
, METH_VARARGS
},
1591 { "tomono", audioop_tomono
, METH_VARARGS
},
1592 { "tostereo", audioop_tostereo
, METH_VARARGS
},
1593 { "getsample", audioop_getsample
, METH_VARARGS
},
1594 { "reverse", audioop_reverse
, METH_VARARGS
},
1595 { "ratecv", audioop_ratecv
, METH_VARARGS
},
1603 m
= Py_InitModule("audioop", audioop_methods
);
1606 d
= PyModule_GetDict(m
);
1609 AudioopError
= PyErr_NewException("audioop.error", NULL
, NULL
);
1610 if (AudioopError
!= NULL
)
1611 PyDict_SetItemString(d
,"error",AudioopError
);