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 PyInt_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 PyInt_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 PyInt_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 PyInt_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 PyStringObject,

   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 PyInt_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 PyInt_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 PyInt_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 PyInt_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 = PyString_FromStringAndSize(NULL, len);

   763         if ( rv == 0 )

   764                 return 0;

   765         ncp = (signed char *)PyString_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         signed char *cp, *ncp;

   787         int len, size, val1 = 0, val2 = 0;

   788         double fac1, fac2, fval, maxval;

   789         PyObject *rv;

   790         int i;

   791 

   792         if ( !PyArg_ParseTuple(args, "s#idd:tomono",

   793 	                       &cp, &len, &size, &fac1, &fac2 ) )

   794                 return 0;

   795     

   796         if ( size == 1 ) maxval = (double) 0x7f;

   797         else if ( size == 2 ) maxval = (double) 0x7fff;

   798         else if ( size == 4 ) maxval = (double) 0x7fffffff;

   799         else {

   800                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

   801                 return 0;

   802         }

   803     

   804         rv = PyString_FromStringAndSize(NULL, len/2);

   805         if ( rv == 0 )

   806                 return 0;

   807         ncp = (signed char *)PyString_AsString(rv);

   808     

   809     

   810         for ( i=0; i < len; i += size*2 ) {

   811                 if ( size == 1 )      val1 = (int)*CHARP(cp, i);

   812                 else if ( size == 2 ) val1 = (int)*SHORTP(cp, i);

   813                 else if ( size == 4 ) val1 = (int)*LONGP(cp, i);

   814                 if ( size == 1 )      val2 = (int)*CHARP(cp, i+1);

   815                 else if ( size == 2 ) val2 = (int)*SHORTP(cp, i+2);

   816                 else if ( size == 4 ) val2 = (int)*LONGP(cp, i+4);

   817                 fval = (double)val1*fac1 + (double)val2*fac2;

   818                 if ( fval > maxval ) fval = maxval;

   819                 else if ( fval < -maxval ) fval = -maxval;

   820                 val1 = (int)fval;

   821                 if ( size == 1 )      *CHARP(ncp, i/2) = (signed char)val1;

   822                 else if ( size == 2 ) *SHORTP(ncp, i/2) = (short)val1;

   823                 else if ( size == 4 ) *LONGP(ncp, i/2)= (Py_Int32)val1;

   824         }

   825         return rv;

   826 }

   827 

   828 static PyObject *

   829 audioop_tostereo(PyObject *self, PyObject *args)

   830 {

   831         signed char *cp, *ncp;

   832         int len, new_len, size, val1, val2, val = 0;

   833         double fac1, fac2, fval, maxval;

   834         PyObject *rv;

   835         int i;

   836 

   837         if ( !PyArg_ParseTuple(args, "s#idd:tostereo",

   838 	                       &cp, &len, &size, &fac1, &fac2 ) )

   839                 return 0;

   840     

   841         if ( size == 1 ) maxval = (double) 0x7f;

   842         else if ( size == 2 ) maxval = (double) 0x7fff;

   843         else if ( size == 4 ) maxval = (double) 0x7fffffff;

   844         else {

   845                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

   846                 return 0;

   847         }

   848     

   849         new_len = len*2;

   850         if (new_len < 0) {

   851                 PyErr_SetString(PyExc_MemoryError,

   852                                 "not enough memory for output buffer");

   853                 return 0;

   854         }

   855 

   856         rv = PyString_FromStringAndSize(NULL, new_len);

   857         if ( rv == 0 )

   858                 return 0;

   859         ncp = (signed char *)PyString_AsString(rv);

   860     

   861     

   862         for ( i=0; i < len; i += size ) {

   863                 if ( size == 1 )      val = (int)*CHARP(cp, i);

   864                 else if ( size == 2 ) val = (int)*SHORTP(cp, i);

   865                 else if ( size == 4 ) val = (int)*LONGP(cp, i);

   866 

   867                 fval = (double)val*fac1;

   868                 if ( fval > maxval ) fval = maxval;

   869                 else if ( fval < -maxval ) fval = -maxval;

   870                 val1 = (int)fval;

   871 

   872                 fval = (double)val*fac2;

   873                 if ( fval > maxval ) fval = maxval;

   874                 else if ( fval < -maxval ) fval = -maxval;

   875                 val2 = (int)fval;

   876 

   877                 if ( size == 1 )      *CHARP(ncp, i*2) = (signed char)val1;

   878                 else if ( size == 2 ) *SHORTP(ncp, i*2) = (short)val1;

   879                 else if ( size == 4 ) *LONGP(ncp, i*2) = (Py_Int32)val1;

   880 

   881                 if ( size == 1 )      *CHARP(ncp, i*2+1) = (signed char)val2;

   882                 else if ( size == 2 ) *SHORTP(ncp, i*2+2) = (short)val2;

   883                 else if ( size == 4 ) *LONGP(ncp, i*2+4) = (Py_Int32)val2;

   884         }

   885         return rv;

   886 }

   887 

   888 static PyObject *

   889 audioop_add(PyObject *self, PyObject *args)

   890 {

   891         signed char *cp1, *cp2, *ncp;

   892         int len1, len2, size, val1 = 0, val2 = 0, maxval, newval;

   893         PyObject *rv;

   894         int i;

   895 

   896         if ( !PyArg_ParseTuple(args, "s#s#i:add",

   897                           &cp1, &len1, &cp2, &len2, &size ) )

   898                 return 0;

   899 

   900         if ( len1 != len2 ) {

   901                 PyErr_SetString(AudioopError, "Lengths should be the same");

   902                 return 0;

   903         }

   904     

   905         if ( size == 1 ) maxval = 0x7f;

   906         else if ( size == 2 ) maxval = 0x7fff;

   907         else if ( size == 4 ) maxval = 0x7fffffff;

   908         else {

   909                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

   910                 return 0;

   911         }

   912 

   913         rv = PyString_FromStringAndSize(NULL, len1);

   914         if ( rv == 0 )

   915                 return 0;

   916         ncp = (signed char *)PyString_AsString(rv);

   917 

   918         for ( i=0; i < len1; i += size ) {

   919                 if ( size == 1 )      val1 = (int)*CHARP(cp1, i);

   920                 else if ( size == 2 ) val1 = (int)*SHORTP(cp1, i);

   921                 else if ( size == 4 ) val1 = (int)*LONGP(cp1, i);

   922         

   923                 if ( size == 1 )      val2 = (int)*CHARP(cp2, i);

   924                 else if ( size == 2 ) val2 = (int)*SHORTP(cp2, i);

   925                 else if ( size == 4 ) val2 = (int)*LONGP(cp2, i);

   926 

   927                 newval = val1 + val2;

   928                 /* truncate in case of overflow */

   929                 if (newval > maxval) newval = maxval;

   930                 else if (newval < -maxval) newval = -maxval;

   931                 else if (size == 4 && (newval^val1) < 0 && (newval^val2) < 0)

   932                         newval = val1 > 0 ? maxval : - maxval;

   933 

   934                 if ( size == 1 )      *CHARP(ncp, i) = (signed char)newval;

   935                 else if ( size == 2 ) *SHORTP(ncp, i) = (short)newval;

   936                 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)newval;

   937         }

   938         return rv;

   939 }

   940 

   941 static PyObject *

   942 audioop_bias(PyObject *self, PyObject *args)

   943 {

   944         signed char *cp, *ncp;

   945         int len, size, val = 0;

   946         PyObject *rv;

   947         int i;

   948         int bias;

   949 

   950         if ( !PyArg_ParseTuple(args, "s#ii:bias",

   951                           &cp, &len, &size , &bias) )

   952                 return 0;

   953 

   954         if ( size != 1 && size != 2 && size != 4) {

   955                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

   956                 return 0;

   957         }

   958     

   959         rv = PyString_FromStringAndSize(NULL, len);

   960         if ( rv == 0 )

   961                 return 0;

   962         ncp = (signed char *)PyString_AsString(rv);

   963     

   964     

   965         for ( i=0; i < len; i += size ) {

   966                 if ( size == 1 )      val = (int)*CHARP(cp, i);

   967                 else if ( size == 2 ) val = (int)*SHORTP(cp, i);

   968                 else if ( size == 4 ) val = (int)*LONGP(cp, i);

   969         

   970                 if ( size == 1 )      *CHARP(ncp, i) = (signed char)(val+bias);

   971                 else if ( size == 2 ) *SHORTP(ncp, i) = (short)(val+bias);

   972                 else if ( size == 4 ) *LONGP(ncp, i) = (Py_Int32)(val+bias);

   973         }

   974         return rv;

   975 }

   976 

   977 static PyObject *

   978 audioop_reverse(PyObject *self, PyObject *args)

   979 {

   980         signed char *cp;

   981         unsigned char *ncp;

   982         int len, size, val = 0;

   983         PyObject *rv;

   984         int i, j;

   985 

   986         if ( !PyArg_ParseTuple(args, "s#i:reverse",

   987                           &cp, &len, &size) )

   988                 return 0;

   989 

   990         if ( size != 1 && size != 2 && size != 4 ) {

   991                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

   992                 return 0;

   993         }

   994     

   995         rv = PyString_FromStringAndSize(NULL, len);

   996         if ( rv == 0 )

   997                 return 0;

   998         ncp = (unsigned char *)PyString_AsString(rv);

   999     

  1000         for ( i=0; i < len; i += size ) {

  1001                 if ( size == 1 )      val = ((int)*CHARP(cp, i)) << 8;

  1002                 else if ( size == 2 ) val = (int)*SHORTP(cp, i);

  1003                 else if ( size == 4 ) val = ((int)*LONGP(cp, i)) >> 16;

  1004 

  1005                 j = len - i - size;

  1006         

  1007                 if ( size == 1 )      *CHARP(ncp, j) = (signed char)(val >> 8);

  1008                 else if ( size == 2 ) *SHORTP(ncp, j) = (short)(val);

  1009                 else if ( size == 4 ) *LONGP(ncp, j) = (Py_Int32)(val<<16);

  1010         }

  1011         return rv;

  1012 }

  1013 

  1014 static PyObject *

  1015 audioop_lin2lin(PyObject *self, PyObject *args)

  1016 {

  1017         signed char *cp;

  1018         unsigned char *ncp;

  1019         int len, new_len, size, size2, val = 0;

  1020         PyObject *rv;

  1021         int i, j;

  1022 

  1023         if ( !PyArg_ParseTuple(args, "s#ii:lin2lin",

  1024                           &cp, &len, &size, &size2) )

  1025                 return 0;

  1026 

  1027         if ( (size != 1 && size != 2 && size != 4) ||

  1028              (size2 != 1 && size2 != 2 && size2 != 4)) {

  1029                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

  1030                 return 0;

  1031         }

  1032     

  1033         new_len = (len/size)*size2;

  1034         if (new_len < 0) {

  1035                 PyErr_SetString(PyExc_MemoryError,

  1036                                 "not enough memory for output buffer");

  1037                 return 0;

  1038         }

  1039         rv = PyString_FromStringAndSize(NULL, new_len);

  1040         if ( rv == 0 )

  1041                 return 0;

  1042         ncp = (unsigned char *)PyString_AsString(rv);

  1043     

  1044         for ( i=0, j=0; i < len; i += size, j += size2 ) {

  1045                 if ( size == 1 )      val = ((int)*CHARP(cp, i)) << 8;

  1046                 else if ( size == 2 ) val = (int)*SHORTP(cp, i);

  1047                 else if ( size == 4 ) val = ((int)*LONGP(cp, i)) >> 16;

  1048 

  1049                 if ( size2 == 1 )  *CHARP(ncp, j) = (signed char)(val >> 8);

  1050                 else if ( size2 == 2 ) *SHORTP(ncp, j) = (short)(val);

  1051                 else if ( size2 == 4 ) *LONGP(ncp, j) = (Py_Int32)(val<<16);

  1052         }

  1053         return rv;

  1054 }

  1055 

  1056 static int

  1057 gcd(int a, int b)

  1058 {

  1059         while (b > 0) {

  1060                 int tmp = a % b;

  1061                 a = b;

  1062                 b = tmp;

  1063         }

  1064         return a;

  1065 }

  1066 

  1067 static PyObject *

  1068 audioop_ratecv(PyObject *self, PyObject *args)

  1069 {

  1070         char *cp, *ncp;

  1071         int len, size, nchannels, inrate, outrate, weightA, weightB;

  1072         int chan, d, *prev_i, *cur_i, cur_o;

  1073         PyObject *state, *samps, *str, *rv = NULL;

  1074         int bytes_per_frame;

  1075         size_t alloc_size;

  1076 

  1077         weightA = 1;

  1078         weightB = 0;

  1079         if (!PyArg_ParseTuple(args, "s#iiiiO|ii:ratecv", &cp, &len, &size,

  1080 	                      &nchannels, &inrate, &outrate, &state,

  1081 			      &weightA, &weightB))

  1082                 return NULL;

  1083         if (size != 1 && size != 2 && size != 4) {

  1084                 PyErr_SetString(AudioopError, "Size should be 1, 2 or 4");

  1085                 return NULL;

  1086         }

  1087         if (nchannels < 1) {

  1088                 PyErr_SetString(AudioopError, "# of channels should be >= 1");

  1089                 return NULL;

  1090         }

  1091         bytes_per_frame = size * nchannels;

  1092         if (bytes_per_frame / nchannels != size) {

  1093                 /* This overflow test is rigorously correct because

  1094                    both multiplicands are >= 1.  Use the argument names

  1095                    from the docs for the error msg. */

  1096                 PyErr_SetString(PyExc_OverflowError,

  1097                                 "width * nchannels too big for a C int");

  1098                 return NULL;

  1099         }

  1100         if (weightA < 1 || weightB < 0) {

  1101                 PyErr_SetString(AudioopError,

  1102                         "weightA should be >= 1, weightB should be >= 0");

  1103                 return NULL;

  1104         }

  1105         if (len % bytes_per_frame != 0) {

  1106                 PyErr_SetString(AudioopError, "not a whole number of frames");

  1107                 return NULL;

  1108         }

  1109         if (inrate <= 0 || outrate <= 0) {

  1110                 PyErr_SetString(AudioopError, "sampling rate not > 0");

  1111                 return NULL;

  1112         }

  1113         /* divide inrate and outrate by their greatest common divisor */

  1114         d = gcd(inrate, outrate);

  1115         inrate /= d;

  1116         outrate /= d;

  1117 

  1118         alloc_size = sizeof(int) * (unsigned)nchannels;

  1119         if (alloc_size < nchannels) {

  1120                 PyErr_SetString(PyExc_MemoryError,

  1121                                 "not enough memory for output buffer");

  1122                 return 0;

  1123         }

  1124         prev_i = (int *) malloc(alloc_size);

  1125         cur_i = (int *) malloc(alloc_size);

  1126         if (prev_i == NULL || cur_i == NULL) {

  1127                 (void) PyErr_NoMemory();

  1128                 goto exit;

  1129         }

  1130 

  1131         len /= bytes_per_frame; /* # of frames */

  1132 

  1133         if (state == Py_None) {

  1134                 d = -outrate;

  1135                 for (chan = 0; chan < nchannels; chan++)