Fred Drake | 295da24 | 1998-08-10 19:42:37 +0000 | [diff] [blame] | 1 | \section{\module{audioop} --- |
Fred Drake | ffbe687 | 1999-04-22 21:23:22 +0000 | [diff] [blame] | 2 | Manipulate raw audio data} |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 3 | |
Fred Drake | ffbe687 | 1999-04-22 21:23:22 +0000 | [diff] [blame] | 4 | \declaremodule{builtin}{audioop} |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 5 | \modulesynopsis{Manipulate raw audio data.} |
| 6 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 7 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 8 | The \module{audioop} module contains some useful operations on sound |
| 9 | fragments. It operates on sound fragments consisting of signed |
| 10 | integer samples 8, 16 or 32 bits wide, stored in Python strings. This |
Fred Drake | ffbe687 | 1999-04-22 21:23:22 +0000 | [diff] [blame] | 11 | is the same format as used by the \refmodule{al} and \refmodule{sunaudiodev} |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 12 | modules. All scalar items are integers, unless specified otherwise. |
| 13 | |
| 14 | % This para is mostly here to provide an excuse for the index entries... |
Anthony Baxter | fa86907 | 2006-03-20 05:21:58 +0000 | [diff] [blame] | 15 | This module provides support for a-LAW, u-LAW and Intel/DVI ADPCM encodings. |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 16 | \index{Intel/DVI ADPCM} |
| 17 | \index{ADPCM, Intel/DVI} |
Anthony Baxter | fa86907 | 2006-03-20 05:21:58 +0000 | [diff] [blame] | 18 | \index{a-LAW} |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 19 | \index{u-LAW} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 20 | |
| 21 | A few of the more complicated operations only take 16-bit samples, |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 22 | otherwise the sample size (in bytes) is always a parameter of the |
| 23 | operation. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 24 | |
| 25 | The module defines the following variables and functions: |
| 26 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 27 | \begin{excdesc}{error} |
| 28 | This exception is raised on all errors, such as unknown number of bytes |
| 29 | per sample, etc. |
| 30 | \end{excdesc} |
| 31 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 32 | \begin{funcdesc}{add}{fragment1, fragment2, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 33 | Return a fragment which is the addition of the two samples passed as |
| 34 | parameters. \var{width} is the sample width in bytes, either |
| 35 | \code{1}, \code{2} or \code{4}. Both fragments should have the same |
| 36 | length. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 37 | \end{funcdesc} |
| 38 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 39 | \begin{funcdesc}{adpcm2lin}{adpcmfragment, width, state} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 40 | Decode an Intel/DVI ADPCM coded fragment to a linear fragment. See |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 41 | the description of \function{lin2adpcm()} for details on ADPCM coding. |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 42 | Return a tuple \code{(\var{sample}, \var{newstate})} where the sample |
| 43 | has the width specified in \var{width}. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 44 | \end{funcdesc} |
| 45 | |
Anthony Baxter | fa86907 | 2006-03-20 05:21:58 +0000 | [diff] [blame] | 46 | \begin{funcdesc}{alaw2lin}{fragment, width} |
| 47 | Convert sound fragments in a-LAW encoding to linearly encoded sound |
| 48 | fragments. a-LAW encoding always uses 8 bits samples, so \var{width} |
| 49 | refers only to the sample width of the output fragment here. |
| 50 | \versionadded{2.5} |
| 51 | \end{funcdesc} |
| 52 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 53 | \begin{funcdesc}{avg}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 54 | Return the average over all samples in the fragment. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 55 | \end{funcdesc} |
| 56 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 57 | \begin{funcdesc}{avgpp}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 58 | Return the average peak-peak value over all samples in the fragment. |
| 59 | No filtering is done, so the usefulness of this routine is |
| 60 | questionable. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 61 | \end{funcdesc} |
| 62 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 63 | \begin{funcdesc}{bias}{fragment, width, bias} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 64 | Return a fragment that is the original fragment with a bias added to |
| 65 | each sample. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 66 | \end{funcdesc} |
| 67 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 68 | \begin{funcdesc}{cross}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 69 | Return the number of zero crossings in the fragment passed as an |
| 70 | argument. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 71 | \end{funcdesc} |
| 72 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 73 | \begin{funcdesc}{findfactor}{fragment, reference} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 74 | Return a factor \var{F} such that |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 75 | \code{rms(add(\var{fragment}, mul(\var{reference}, -\var{F})))} is |
| 76 | minimal, i.e., return the factor with which you should multiply |
| 77 | \var{reference} to make it match as well as possible to |
| 78 | \var{fragment}. The fragments should both contain 2-byte samples. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 79 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 80 | The time taken by this routine is proportional to |
| 81 | \code{len(\var{fragment})}. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 82 | \end{funcdesc} |
| 83 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 84 | \begin{funcdesc}{findfit}{fragment, reference} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 85 | Try to match \var{reference} as well as possible to a portion of |
| 86 | \var{fragment} (which should be the longer fragment). This is |
| 87 | (conceptually) done by taking slices out of \var{fragment}, using |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 88 | \function{findfactor()} to compute the best match, and minimizing the |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 89 | result. The fragments should both contain 2-byte samples. Return a |
| 90 | tuple \code{(\var{offset}, \var{factor})} where \var{offset} is the |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 91 | (integer) offset into \var{fragment} where the optimal match started |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 92 | and \var{factor} is the (floating-point) factor as per |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 93 | \function{findfactor()}. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 94 | \end{funcdesc} |
| 95 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 96 | \begin{funcdesc}{findmax}{fragment, length} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 97 | Search \var{fragment} for a slice of length \var{length} samples (not |
| 98 | bytes!)\ with maximum energy, i.e., return \var{i} for which |
| 99 | \code{rms(fragment[i*2:(i+length)*2])} is maximal. The fragments |
| 100 | should both contain 2-byte samples. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 101 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 102 | The routine takes time proportional to \code{len(\var{fragment})}. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 103 | \end{funcdesc} |
| 104 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 105 | \begin{funcdesc}{getsample}{fragment, width, index} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 106 | Return the value of sample \var{index} from the fragment. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 107 | \end{funcdesc} |
| 108 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 109 | \begin{funcdesc}{lin2adpcm}{fragment, width, state} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 110 | Convert samples to 4 bit Intel/DVI ADPCM encoding. ADPCM coding is an |
| 111 | adaptive coding scheme, whereby each 4 bit number is the difference |
| 112 | between one sample and the next, divided by a (varying) step. The |
| 113 | Intel/DVI ADPCM algorithm has been selected for use by the IMA, so it |
| 114 | may well become a standard. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 115 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 116 | \var{state} is a tuple containing the state of the coder. The coder |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 117 | returns a tuple \code{(\var{adpcmfrag}, \var{newstate})}, and the |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 118 | \var{newstate} should be passed to the next call of |
| 119 | \function{lin2adpcm()}. In the initial call, \code{None} can be |
| 120 | passed as the state. \var{adpcmfrag} is the ADPCM coded fragment |
| 121 | packed 2 4-bit values per byte. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 122 | \end{funcdesc} |
| 123 | |
Anthony Baxter | fa86907 | 2006-03-20 05:21:58 +0000 | [diff] [blame] | 124 | \begin{funcdesc}{lin2alaw}{fragment, width} |
| 125 | Convert samples in the audio fragment to a-LAW encoding and return |
| 126 | this as a Python string. a-LAW is an audio encoding format whereby |
| 127 | you get a dynamic range of about 13 bits using only 8 bit samples. It |
| 128 | is used by the Sun audio hardware, among others. |
| 129 | \versionadded{2.5} |
| 130 | \end{funcdesc} |
| 131 | |
| 132 | \begin{funcdesc}{lin2lin}{fragment, width, newwidth} |
| 133 | Convert samples between 1-, 2- and 4-byte formats. |
| 134 | \end{funcdesc} |
| 135 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 136 | \begin{funcdesc}{lin2ulaw}{fragment, width} |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 137 | Convert samples in the audio fragment to u-LAW encoding and return |
| 138 | this as a Python string. u-LAW is an audio encoding format whereby |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 139 | you get a dynamic range of about 14 bits using only 8 bit samples. It |
| 140 | is used by the Sun audio hardware, among others. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 141 | \end{funcdesc} |
| 142 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 143 | \begin{funcdesc}{minmax}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 144 | Return a tuple consisting of the minimum and maximum values of all |
| 145 | samples in the sound fragment. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 146 | \end{funcdesc} |
| 147 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 148 | \begin{funcdesc}{max}{fragment, width} |
Fred Drake | af8a015 | 1998-01-14 14:51:31 +0000 | [diff] [blame] | 149 | Return the maximum of the \emph{absolute value} of all samples in a |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 150 | fragment. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 151 | \end{funcdesc} |
| 152 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 153 | \begin{funcdesc}{maxpp}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 154 | Return the maximum peak-peak value in the sound fragment. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 155 | \end{funcdesc} |
| 156 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 157 | \begin{funcdesc}{mul}{fragment, width, factor} |
Thomas Wouters | f831663 | 2000-07-16 19:01:10 +0000 | [diff] [blame] | 158 | Return a fragment that has all samples in the original fragment |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 159 | multiplied by the floating-point value \var{factor}. Overflow is |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 160 | silently ignored. |
| 161 | \end{funcdesc} |
| 162 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 163 | \begin{funcdesc}{ratecv}{fragment, width, nchannels, inrate, outrate, |
| 164 | state\optional{, weightA\optional{, weightB}}} |
Guido van Rossum | 6fb6f10 | 1997-02-14 15:59:49 +0000 | [diff] [blame] | 165 | Convert the frame rate of the input fragment. |
| 166 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 167 | \var{state} is a tuple containing the state of the converter. The |
Thomas Wouters | f831663 | 2000-07-16 19:01:10 +0000 | [diff] [blame] | 168 | converter returns a tuple \code{(\var{newfragment}, \var{newstate})}, |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 169 | and \var{newstate} should be passed to the next call of |
Tim Peters | c7cb692 | 2001-12-06 23:16:09 +0000 | [diff] [blame] | 170 | \function{ratecv()}. The initial call should pass \code{None} |
| 171 | as the state. |
Guido van Rossum | 6fb6f10 | 1997-02-14 15:59:49 +0000 | [diff] [blame] | 172 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 173 | The \var{weightA} and \var{weightB} arguments are parameters for a |
Fred Drake | 4aa4f30 | 1999-04-23 17:30:40 +0000 | [diff] [blame] | 174 | simple digital filter and default to \code{1} and \code{0} respectively. |
Guido van Rossum | 6fb6f10 | 1997-02-14 15:59:49 +0000 | [diff] [blame] | 175 | \end{funcdesc} |
| 176 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 177 | \begin{funcdesc}{reverse}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 178 | Reverse the samples in a fragment and returns the modified fragment. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 179 | \end{funcdesc} |
| 180 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 181 | \begin{funcdesc}{rms}{fragment, width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 182 | Return the root-mean-square of the fragment, i.e. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 183 | \begin{displaymath} |
| 184 | \catcode`_=8 |
| 185 | \sqrt{\frac{\sum{{S_{i}}^{2}}}{n}} |
| 186 | \end{displaymath} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 187 | This is a measure of the power in an audio signal. |
| 188 | \end{funcdesc} |
| 189 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 190 | \begin{funcdesc}{tomono}{fragment, width, lfactor, rfactor} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 191 | Convert a stereo fragment to a mono fragment. The left channel is |
| 192 | multiplied by \var{lfactor} and the right channel by \var{rfactor} |
| 193 | before adding the two channels to give a mono signal. |
Guido van Rossum | 6bb1adc | 1995-03-13 10:03:32 +0000 | [diff] [blame] | 194 | \end{funcdesc} |
| 195 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 196 | \begin{funcdesc}{tostereo}{fragment, width, lfactor, rfactor} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 197 | Generate a stereo fragment from a mono fragment. Each pair of samples |
| 198 | in the stereo fragment are computed from the mono sample, whereby left |
| 199 | channel samples are multiplied by \var{lfactor} and right channel |
| 200 | samples by \var{rfactor}. |
Guido van Rossum | 6bb1adc | 1995-03-13 10:03:32 +0000 | [diff] [blame] | 201 | \end{funcdesc} |
| 202 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 203 | \begin{funcdesc}{ulaw2lin}{fragment, width} |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 204 | Convert sound fragments in u-LAW encoding to linearly encoded sound |
| 205 | fragments. u-LAW encoding always uses 8 bits samples, so \var{width} |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 206 | refers only to the sample width of the output fragment here. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 207 | \end{funcdesc} |
| 208 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 209 | Note that operations such as \function{mul()} or \function{max()} make |
| 210 | no distinction between mono and stereo fragments, i.e.\ all samples |
| 211 | are treated equal. If this is a problem the stereo fragment should be |
| 212 | split into two mono fragments first and recombined later. Here is an |
| 213 | example of how to do that: |
| 214 | |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 215 | \begin{verbatim} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 216 | def mul_stereo(sample, width, lfactor, rfactor): |
| 217 | lsample = audioop.tomono(sample, width, 1, 0) |
| 218 | rsample = audioop.tomono(sample, width, 0, 1) |
| 219 | lsample = audioop.mul(sample, width, lfactor) |
| 220 | rsample = audioop.mul(sample, width, rfactor) |
| 221 | lsample = audioop.tostereo(lsample, width, 1, 0) |
| 222 | rsample = audioop.tostereo(rsample, width, 0, 1) |
| 223 | return audioop.add(lsample, rsample, width) |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 224 | \end{verbatim} |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 225 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 226 | If you use the ADPCM coder to build network packets and you want your |
Guido van Rossum | 6bb1adc | 1995-03-13 10:03:32 +0000 | [diff] [blame] | 227 | protocol to be stateless (i.e.\ to be able to tolerate packet loss) |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 228 | you should not only transmit the data but also the state. Note that |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 229 | you should send the \var{initial} state (the one you passed to |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 230 | \function{lin2adpcm()}) along to the decoder, not the final state (as |
| 231 | returned by the coder). If you want to use \function{struct.struct()} |
| 232 | to store the state in binary you can code the first element (the |
| 233 | predicted value) in 16 bits and the second (the delta index) in 8. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 234 | |
| 235 | The ADPCM coders have never been tried against other ADPCM coders, |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 236 | only against themselves. It could well be that I misinterpreted the |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 237 | standards in which case they will not be interoperable with the |
| 238 | respective standards. |
| 239 | |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 240 | The \function{find*()} routines might look a bit funny at first sight. |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 241 | They are primarily meant to do echo cancellation. A reasonably |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 242 | fast way to do this is to pick the most energetic piece of the output |
| 243 | sample, locate that in the input sample and subtract the whole output |
| 244 | sample from the input sample: |
Fred Drake | fc57619 | 1998-04-04 07:15:02 +0000 | [diff] [blame] | 245 | |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 246 | \begin{verbatim} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 247 | def echocancel(outputdata, inputdata): |
| 248 | pos = audioop.findmax(outputdata, 800) # one tenth second |
| 249 | out_test = outputdata[pos*2:] |
| 250 | in_test = inputdata[pos*2:] |
| 251 | ipos, factor = audioop.findfit(in_test, out_test) |
| 252 | # Optional (for better cancellation): |
| 253 | # factor = audioop.findfactor(in_test[ipos*2:ipos*2+len(out_test)], |
| 254 | # out_test) |
| 255 | prefill = '\0'*(pos+ipos)*2 |
| 256 | postfill = '\0'*(len(inputdata)-len(prefill)-len(outputdata)) |
| 257 | outputdata = prefill + audioop.mul(outputdata,2,-factor) + postfill |
| 258 | return audioop.add(inputdata, outputdata, 2) |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 259 | \end{verbatim} |