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 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 (at) 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 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 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 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 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 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 * 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 * 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 * 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 * 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 * 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 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 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