Получается очень много шума после этого..
Oleg_B wrote:Кодирование просто уменьшает разрядность за счёт загрубления данных. Так понятно? Вы же не удивляетесь, MPEG, к примеру, шумит больше, чем исходное видео?
Oleg_B wrote:uniqueman wrote:по T1 приходит голос в цифре (PCM) на серверное приложение (там Dialogic T1 карты стоят). Приложение кодирует его (сейчас через gsm 6.10) и отправляет клиентам по IP.
Обычно Т1 передаёт голос в u-law 8x8KHz (G.711)
uniqueman wrote:Я получаю сигнал, кодированный через G 711 (как говорят это стандарт для Т1), конвертирую его в чистый, линейный PCM. Затем конвертирую обратно в тот же G 711 который был, в u-law PCM. В результате качество искажается очень сильно.. почему? ведь по идее я сделал два действия , которые противополжны друг другу... взял число два, умножил на два (перевел в linear PCM), потом опять разделил на два (перевел обратно в G 711).. и у меня не получилось исходной двойки
Oleg_B wrote:uniqueman wrote:От кого и от чего зависит каким кодеком сжимается линейный PCM для передачи по Т1?
Как вы подключены к Т1? Девайс, его интерфейс (PRI, BRI, ISDN, Raw?) Умных слов немножко насыпьте, может и поймём чего...
Ну вот и читайте документацию этого диалоджика, смотрите его установки. Скорее всего, мю-ло идёт.
Меня смущает этот огромный рак... Я не знаю, что такое Нью-бридж и зачем он... Что в него приходит? Т-3?
Oleg_B wrote:ну так проверьте эти функции,
для всех чисел от 0 до 255: раскодировать в линейный и закодировать обратно. должно получиться то же число. если нет - то претензии к тому, кто это писал...
Code: Select all
1 /*
2 * mulaw.h --
3 *
4 * Mulaw table declarations
5 *
6 * Copyright (c) 1991-2002 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 * A. Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 * B. Redistributions in binary form must reproduce the above copyright notice,
15 * this list of conditions and the following disclaimer in the documentation
16 * and/or other materials provided with the distribution.
17 * C. Neither the names of the copyright holders nor the names of its
18 * contributors may be used to endorse or promote products derived from this
19 * software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
22 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
23 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 *
33 * @(#) $Header: /usr/mash/src/repository/mash/mash-1/codec/audio/mulaw.h,v 1.5 2002/02/03 03:11:42 lim Exp $
34 */
35
36 extern short mulawtolin[256];
37 extern u_char lintomulaw[65536];
38 extern u_char mulawsum[256*256];
39
Code: Select all
1 /*
2 * mktab.c --
3 *
4 * Tables for mulaw
5 *
32 */
33
34 #ifndef lint
35 static char rcsid[] =
36 "@(#) $Header: /usr/mash/src/repository/mash/mash-1/codec/audio/mktab.c,v 1.6 2002/02/03 03:11:42 lim Exp $";
37 #endif
38
39 #include <stdio.h>
40 #include <math.h>
41 #include <sys/types.h>
42 #include "mulaw.h"
43
44 #define BIAS 0x84
45 #define CLIP 32635
46
47 u_char
48 st_linear_to_ulaw(register int linear)
49 {
50 static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
51 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
52 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
53 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
54 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
55 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
56 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
57 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
58 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
59 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
60 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
61 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
62 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
63 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
64 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
65 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
66 register int sign, exponent, mantissa;
67 register u_char ulawbyte;
68
69 /* Get the value into sign-magnitude. */
70 sign = (linear >> 8) & 0x80;
71 if (sign != 0) {
72 /* sign extend the value, just in case */
73 linear |= 0xffff0000;
74 linear = -linear;
75 }
76 if (linear > CLIP)
77 linear = CLIP;
78
79 /* Convert from 16 bit linear to ulaw. */
80 linear += BIAS;
81 exponent = exp_lut[(linear >> 7) & 0xFF];
82 mantissa = (linear >> (exponent + 3)) & 0x0F;
83 ulawbyte = ~(sign | (exponent << 4) | mantissa);
84 return ulawbyte;
85 }
86
87 int
88 st_ulaw_to_linear(ulawbyte)
89 u_char ulawbyte;
90 {
91 static int exp_lut[8] = { 0, 132, 396, 924, 1980, 4092, 8316, 16764 };
92 int sign, exponent, mantissa, sample;
93
94 ulawbyte = ~ulawbyte;
95 sign = (ulawbyte & 0x80);
96 exponent = (ulawbyte >> 4) & 0x07;
97 mantissa = ulawbyte & 0x0F;
98 sample = exp_lut[exponent] + (mantissa << (exponent + 3)) +
99 (1 << (exponent + 2));
100 if (sign != 0)
101 sample = -sample;
102 /*
103 * ulaw maps zero to full-scale negative. This is a very poor
104 * choice given that most i/o failure modes stick zero in the
105 * buffer. So, to save our ears, we map ulaw zero to linear zero.
106 */
107 return (ulawbyte == 0xff? 0 : sample);
108 }
109
110 tab_tolin(f)
111 register FILE *f;
112 {
113 register int i, j;
114
115 fprintf(f, "const short mulawtolin[256] = {\n");
116 for (i = 0; i < 256; ) {
117 putc('\t', f);
118 for (j = i + 8; i < j; ++i)
119 fprintf(f, "%d, ", st_ulaw_to_linear(i));
120 putc('\n', f);
121 }
122 fprintf(f, "};\n");
123 }
124
125 tab_tomu(f)
126 register FILE *f;
127 {
128 register int i, j;
129
130 fprintf(f, "const unsigned char lintomulaw[65536] = {\n");
131 for (i = 0; i < 65536; ) {
132 putc('\t', f);
133 for (j = i + 8; i < j; ++i)
134 fprintf(f, "%d, ", st_linear_to_ulaw(i));
135 putc('\n', f);
136 }
137 fprintf(f, "};\n");
138 }
139
140 /*
141 * build a linear to mulaw lookup table extended by 1
142 * bit to handle clipping in the table lookup rather
143 * than testing each sample.
144 */
145 tab_tomuX(f)
146 register FILE *f;
147 {
148 register int i, j;
149
150 fprintf(f, "const unsigned char lintomulawX[65536*2] = {\n");
151 /* positive half */
152 for (i = 0; i < 32768; ) {
153 putc('\t', f);
154 for (j = i + 8; i < j; ++i)
155 fprintf(f, "%d, ", st_linear_to_ulaw(i));
156 putc('\n', f);
157 }
158 /* positive overflow (clipped) */
159 for (i = 32768; i < 65536; ) {
160 putc('\t', f);
161 for (j = i + 8; i < j; ++i)
162 fprintf(f, "%d, ", 0x80);
163 putc('\n', f);
164 }
165 /* negative overflow (clipped) */
166 for (i = 65536; i < 98304; ) {
167 putc('\t', f);
168 for (j = i + 8; i < j; ++i)
169 fprintf(f, "%d, ", 0x01);
170 putc('\n', f);
171 }
172 /* negative half */
173 for (i = 98304; i < 131072; ) {
174 putc('\t', f);
175 for (j = i + 8; i < j; ++i)
176 fprintf(f, "%d, ", st_linear_to_ulaw(i));
177 putc('\n', f);
178 }
179 fprintf(f, "};\n");
180 }
181
182 void
183 prtone(f, u)
184 register FILE *f;
185 register int u;
186 {
187 if (u < -CLIP)
188 u = -CLIP;
189 else if (u > CLIP)
190 u = CLIP;
191 fprintf(f, "%d, ", st_linear_to_ulaw(u));
192 }
193
194 tab_sum(f)
195 register FILE *f;
196 {
197 register int i, j, k, u;
198
199 fprintf(f, "const unsigned char mulawsum[256*256] = {\n");
200 for (i = 0; i < 256; ++i) {
201 fprintf(f, "/* %d */\n", i);
202 u = st_ulaw_to_linear(i);
203 for (j = 0; j < 256; ) {
204 putc('\t', f);
205 for (k = j + 8; j < k; ++j)
206 prtone(f, u + st_ulaw_to_linear(j));
207 putc('\n', f);
208 }
209 }
210 fprintf(f, "};\n");
211 }
212
213 void
214 prt8(f, u, us)
215 register FILE *f;
216 register int u;
217 register int* us;
218 {
219 register int k;
220
221 putc('\t', f);
222 for (k = 0; k < 8; ++k)
223 prtone(f, u + us[k]);
224 putc('\n', f);
225 }
226
227 int
228 prtup64(f, u, uj)
229 register FILE *f;
230 register int u, uj;
231 {
232 register int k;
233 int us[64], uabs, uk;
234
235 /*
236 * compute the 64 values that would precede uj in a mulaw
237 * table (assuming a gain of 17/16 which is roughly right
238 * for large uj). Do them in reverse order since mulaw
239 * values are complemented.
240 */
241 uabs = (uj>=0? uj : -uj) << 4;
242 for (k = 64; --k >= 0; ) {
243 uk = uabs >> 4;
244 us[k] = uj>=0? uk : -uk;
245 uabs += uk;
246 }
247 for (k = 0; k < 64; k += 8)
248 prt8(f, u, us + k);
249 }
250
251 int
252 prtlow64(f, u, uj)
253 register FILE *f;
254 register int u, uj;
255 {
256 register int k;
257 int us[64], uabs, uk;
258
259 /*
260 * compute the 64 values that would follow uj in a mulaw
261 * table.
262 */
263 uabs = 1 << 4;
264 for (k = 48; --k >= 0; ) {
265 uk = uabs >> 4;
266 us[k] = uj>=0? uk : -uk;
267 uabs += uk;
268 }
269 for (k = 64; --k >= 48; ) {
270 us[k] = 0;
271 }
272 for (k = 0; k < 64; k += 8)
273 prt8(f, u, us + k);
274 }
275
276 tab_mugain(f)
277 register FILE *f;
278 {
279 register int i, j, k;
280 #define M 16.
281 double g = 1.;
282 double gi = pow(M, (double)1. / 32.);
283
284 fprintf(f, "const unsigned char mugaintab[64*256] = {\n");
285 for (i = 0; i < 64; ++i) {
286 fprintf(f, "/* step %d (gain %g) */\n", i - 32, g / M);
287
288 for (j = 0; j < 256; ) {
289 putc('\t', f);
290 for (k = j + 8; j < k; ++j) {
291 double v = g / M * (double)st_ulaw_to_linear(j);
292 prtone(f, (int)v);
293 }
294 putc('\n', f);
295 }
296 g *= gi;
297 }
298 fprintf(f, "};\n");
299 #undef M
300 }
301
302 /*
303 * Output a table that maps mulaw samples to power levels, where
304 * the power level is given by p = log_2(x^2) (i.e., not really db).
305 * p is expressed in 32-bit fixed point, with 19 bits of fraction.
306 * Since ulaw samples range over 16 bits (linear), we need 32 bits
307 * to represent log_2(x^2). To compute the power in a frame, we add
308 * 160 of these samples, so we need to be able to represent 32 * 160 = 0x1400,
309 * with the encoding. Thus, we need 13 bits for the integer part,
310 * which gives 19 bits of fraction. This encoding will allow the
311 * frame size to go to 256. Note that all the values are positive
312 * since the smallest linear value is 4 (except for 0, which we will
313 * just encode as 0).
314 */
315 #ifdef notdef
316 tab_mudb(f)
317 register FILE *f;
318 {
319 register int i, j;
320 double log2 = log((double)2);
321
322 fprintf(f, "const unsigned long mulawtodb[256] = {\n");
323 for (i = 0; i < 256; ) {
324 putc('\t', f);
325 for (j = i + 4; i < j; ++i) {
326 u_long s;
327 double d = (double)st_ulaw_to_linear(i);
328 if (d != 0) {
329 d = d * d;
330 d = log(d) / log2;
331 d *= (double)(1 << MUDB_FRACBITS);
332 }
333 fprintf(f, "0x%lx, ", (u_long)irint(d));
334 }
335 putc('\n', f);
336 }
337 fprintf(f, "};\n");
338 }
339
340 tab_x(f)
341 register FILE *f;
342 {
343 register int i;
344
345 for (i = 0; i <= CLIP; ++i) {
346 int u = st_linear_to_ulaw(i);
347 printf("%d\n", ~u & 0x7f);
348 }
349 }
350
351 tab_xx(f)
352 register FILE *f;
353 {
354 register int i;
355
356 for (i = 0; i <= CLIP; ++i) {
357 int u = st_linear_to_ulaw(i);
358 printf("%d\n", st_ulaw_to_linear(u));
359 }
360 }
361 #endif
362
363 main(int argc, char* argv[])
364 {
365 if (argc != 2)
366 exit(1);
367 if (strcmp(argv[1], "-mulaw") == 0) {
368 tab_tolin(stdout);
369 tab_tomu(stdout);
370 } else if (strcmp(argv[1], "-sum") == 0)
371 tab_sum(stdout);
372 else if (strcmp(argv[1], "-scale") == 0)
373 tab_mugain(stdout);
374 else if (strcmp(argv[1], "-muX") == 0)
375 tab_tomuX(stdout);
376 #ifdef notdef
377 else if (strcmp(argv[1], "-db") == 0)
378 tab_mudb(stdout);
379 else if (strcmp(argv[1], "-x") == 0)
380 tab_x(stdout);
381 else if (strcmp(argv[1], "-xx") == 0)
382 tab_xx(stdout);
383 #endif
384 else
385 exit(1);
386 exit(0);
387 }
388
Code: Select all
1 /* $OpenBSD: mulaw.c,v 1.11 2004/02/23 23:59:21 deraadt Exp $ */
2 /* $NetBSD: mulaw.c,v 1.15 2001/01/18 20:28:20 jdolecek Exp $ */
3
4 /*
5 * Copyright (c) 1991-1993 Regents of the University of California.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the Computer Systems
19 * Engineering Group at Lawrence Berkeley Laboratory.
20 * 4. Neither the name of the University nor of the Laboratory may be used
21 * to endorse or promote products derived from this software without
22 * specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 */
37
38 #include <sys/types.h>
39 #include <sys/audioio.h>
40 #include <dev/mulaw.h>
41
42 /*
43 * This table converts a (8 bit) mu-law value two a 16 bit value.
44 * The 16 bits are represented as an array of two bytes for easier access
45 * to the individual bytes.
46 */
47 static const u_char mulawtolin16[256][2] = {
48 {0x02,0x84}, {0x06,0x84}, {0x0a,0x84}, {0x0e,0x84},
49 {0x12,0x84}, {0x16,0x84}, {0x1a,0x84}, {0x1e,0x84},
50 {0x22,0x84}, {0x26,0x84}, {0x2a,0x84}, {0x2e,0x84},
51 {0x32,0x84}, {0x36,0x84}, {0x3a,0x84}, {0x3e,0x84},
52 {0x41,0x84}, {0x43,0x84}, {0x45,0x84}, {0x47,0x84},
53 {0x49,0x84}, {0x4b,0x84}, {0x4d,0x84}, {0x4f,0x84},
54 {0x51,0x84}, {0x53,0x84}, {0x55,0x84}, {0x57,0x84},
55 {0x59,0x84}, {0x5b,0x84}, {0x5d,0x84}, {0x5f,0x84},
56 {0x61,0x04}, {0x62,0x04}, {0x63,0x04}, {0x64,0x04},
57 {0x65,0x04}, {0x66,0x04}, {0x67,0x04}, {0x68,0x04},
58 {0x69,0x04}, {0x6a,0x04}, {0x6b,0x04}, {0x6c,0x04},
59 {0x6d,0x04}, {0x6e,0x04}, {0x6f,0x04}, {0x70,0x04},
60 {0x70,0xc4}, {0x71,0x44}, {0x71,0xc4}, {0x72,0x44},
61 {0x72,0xc4}, {0x73,0x44}, {0x73,0xc4}, {0x74,0x44},
62 {0x74,0xc4}, {0x75,0x44}, {0x75,0xc4}, {0x76,0x44},
63 {0x76,0xc4}, {0x77,0x44}, {0x77,0xc4}, {0x78,0x44},
64 {0x78,0xa4}, {0x78,0xe4}, {0x79,0x24}, {0x79,0x64},
65 {0x79,0xa4}, {0x79,0xe4}, {0x7a,0x24}, {0x7a,0x64},
66 {0x7a,0xa4}, {0x7a,0xe4}, {0x7b,0x24}, {0x7b,0x64},
67 {0x7b,0xa4}, {0x7b,0xe4}, {0x7c,0x24}, {0x7c,0x64},
68 {0x7c,0x94}, {0x7c,0xb4}, {0x7c,0xd4}, {0x7c,0xf4},
69 {0x7d,0x14}, {0x7d,0x34}, {0x7d,0x54}, {0x7d,0x74},
70 {0x7d,0x94}, {0x7d,0xb4}, {0x7d,0xd4}, {0x7d,0xf4},
71 {0x7e,0x14}, {0x7e,0x34}, {0x7e,0x54}, {0x7e,0x74},
72 {0x7e,0x8c}, {0x7e,0x9c}, {0x7e,0xac}, {0x7e,0xbc},
73 {0x7e,0xcc}, {0x7e,0xdc}, {0x7e,0xec}, {0x7e,0xfc},
74 {0x7f,0x0c}, {0x7f,0x1c}, {0x7f,0x2c}, {0x7f,0x3c},
75 {0x7f,0x4c}, {0x7f,0x5c}, {0x7f,0x6c}, {0x7f,0x7c},
76 {0x7f,0x88}, {0x7f,0x90}, {0x7f,0x98}, {0x7f,0xa0},
77 {0x7f,0xa8}, {0x7f,0xb0}, {0x7f,0xb8}, {0x7f,0xc0},
78 {0x7f,0xc8}, {0x7f,0xd0}, {0x7f,0xd8}, {0x7f,0xe0},
79 {0x7f,0xe8}, {0x7f,0xf0}, {0x7f,0xf8}, {0x80,0x00},
80 {0xfd,0x7c}, {0xf9,0x7c}, {0xf5,0x7c}, {0xf1,0x7c},
81 {0xed,0x7c}, {0xe9,0x7c}, {0xe5,0x7c}, {0xe1,0x7c},
82 {0xdd,0x7c}, {0xd9,0x7c}, {0xd5,0x7c}, {0xd1,0x7c},
83 {0xcd,0x7c}, {0xc9,0x7c}, {0xc5,0x7c}, {0xc1,0x7c},
84 {0xbe,0x7c}, {0xbc,0x7c}, {0xba,0x7c}, {0xb8,0x7c},
85 {0xb6,0x7c}, {0xb4,0x7c}, {0xb2,0x7c}, {0xb0,0x7c},
86 {0xae,0x7c}, {0xac,0x7c}, {0xaa,0x7c}, {0xa8,0x7c},
87 {0xa6,0x7c}, {0xa4,0x7c}, {0xa2,0x7c}, {0xa0,0x7c},
88 {0x9e,0xfc}, {0x9d,0xfc}, {0x9c,0xfc}, {0x9b,0xfc},
89 {0x9a,0xfc}, {0x99,0xfc}, {0x98,0xfc}, {0x97,0xfc},
90 {0x96,0xfc}, {0x95,0xfc}, {0x94,0xfc}, {0x93,0xfc},
91 {0x92,0xfc}, {0x91,0xfc}, {0x90,0xfc}, {0x8f,0xfc},
92 {0x8f,0x3c}, {0x8e,0xbc}, {0x8e,0x3c}, {0x8d,0xbc},
93 {0x8d,0x3c}, {0x8c,0xbc}, {0x8c,0x3c}, {0x8b,0xbc},
94 {0x8b,0x3c}, {0x8a,0xbc}, {0x8a,0x3c}, {0x89,0xbc},
95 {0x89,0x3c}, {0x88,0xbc}, {0x88,0x3c}, {0x87,0xbc},
96 {0x87,0x5c}, {0x87,0x1c}, {0x86,0xdc}, {0x86,0x9c},
97 {0x86,0x5c}, {0x86,0x1c}, {0x85,0xdc}, {0x85,0x9c},
98 {0x85,0x5c}, {0x85,0x1c}, {0x84,0xdc}, {0x84,0x9c},
99 {0x84,0x5c}, {0x84,0x1c}, {0x83,0xdc}, {0x83,0x9c},
100 {0x83,0x6c}, {0x83,0x4c}, {0x83,0x2c}, {0x83,0x0c},
101 {0x82,0xec}, {0x82,0xcc}, {0x82,0xac}, {0x82,0x8c},
102 {0x82,0x6c}, {0x82,0x4c}, {0x82,0x2c}, {0x82,0x0c},
103 {0x81,0xec}, {0x81,0xcc}, {0x81,0xac}, {0x81,0x8c},
104 {0x81,0x74}, {0x81,0x64}, {0x81,0x54}, {0x81,0x44},
105 {0x81,0x34}, {0x81,0x24}, {0x81,0x14}, {0x81,0x04},
106 {0x80,0xf4}, {0x80,0xe4}, {0x80,0xd4}, {0x80,0xc4},
107 {0x80,0xb4}, {0x80,0xa4}, {0x80,0x94}, {0x80,0x84},
108 {0x80,0x78}, {0x80,0x70}, {0x80,0x68}, {0x80,0x60},
109 {0x80,0x58}, {0x80,0x50}, {0x80,0x48}, {0x80,0x40},
110 {0x80,0x38}, {0x80,0x30}, {0x80,0x28}, {0x80,0x20},
111 {0x80,0x18}, {0x80,0x10}, {0x80,0x08}, {0x80,0x00},
112 };
113
114 static const u_char lintomulaw[256] = {
115 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
116 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,
117 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05,
118 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07,
119 0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
120 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b,
121 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d,
122 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f,
123 0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13,
124 0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17,
125 0x17, 0x18, 0x18, 0x19, 0x19, 0x1a, 0x1a, 0x1b,
126 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f,
127 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
128 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
129 0x2f, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c,
130 0x3e, 0x41, 0x45, 0x49, 0x4d, 0x53, 0x5b, 0x67,
131 0xff, 0xe7, 0xdb, 0xd3, 0xcd, 0xc9, 0xc5, 0xc1,
132 0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, 0xb2, 0xb0,
133 0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
134 0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
135 0x9f, 0x9f, 0x9e, 0x9e, 0x9d, 0x9d, 0x9c, 0x9c,
136 0x9b, 0x9b, 0x9a, 0x9a, 0x99, 0x99, 0x98, 0x98,
137 0x97, 0x97, 0x96, 0x96, 0x95, 0x95, 0x94, 0x94,
138 0x93, 0x93, 0x92, 0x92, 0x91, 0x91, 0x90, 0x90,
139 0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e,
140 0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c,
141 0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a,
142 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88,
143 0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86,
144 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84,
145 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
146 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80,
147 };
148
149 static const u_char alawtolin16[256][2] = {
150 {0x6a,0x80}, {0x6b,0x80}, {0x68,0x80}, {0x69,0x80},
151 {0x6e,0x80}, {0x6f,0x80}, {0x6c,0x80}, {0x6d,0x80},
152 {0x62,0x80}, {0x63,0x80}, {0x60,0x80}, {0x61,0x80},
153 {0x66,0x80}, {0x67,0x80}, {0x64,0x80}, {0x65,0x80},
154 {0x75,0x40}, {0x75,0xc0}, {0x74,0x40}, {0x74,0xc0},
155 {0x77,0x40}, {0x77,0xc0}, {0x76,0x40}, {0x76,0xc0},
156 {0x71,0x40}, {0x71,0xc0}, {0x70,0x40}, {0x70,0xc0},
157 {0x73,0x40}, {0x73,0xc0}, {0x72,0x40}, {0x72,0xc0},
158 {0x2a,0x00}, {0x2e,0x00}, {0x22,0x00}, {0x26,0x00},
159 {0x3a,0x00}, {0x3e,0x00}, {0x32,0x00}, {0x36,0x00},
160 {0x0a,0x00}, {0x0e,0x00}, {0x02,0x00}, {0x06,0x00},
161 {0x1a,0x00}, {0x1e,0x00}, {0x12,0x00}, {0x16,0x00},
162 {0x55,0x00}, {0x57,0x00}, {0x51,0x00}, {0x53,0x00},
163 {0x5d,0x00}, {0x5f,0x00}, {0x59,0x00}, {0x5b,0x00},
164 {0x45,0x00}, {0x47,0x00}, {0x41,0x00}, {0x43,0x00},
165 {0x4d,0x00}, {0x4f,0x00}, {0x49,0x00}, {0x4b,0x00},
166 {0x7e,0xa8}, {0x7e,0xb8}, {0x7e,0x88}, {0x7e,0x98},
167 {0x7e,0xe8}, {0x7e,0xf8}, {0x7e,0xc8}, {0x7e,0xd8},
168 {0x7e,0x28}, {0x7e,0x38}, {0x7e,0x08}, {0x7e,0x18},
169 {0x7e,0x68}, {0x7e,0x78}, {0x7e,0x48}, {0x7e,0x58},
170 {0x7f,0xa8}, {0x7f,0xb8}, {0x7f,0x88}, {0x7f,0x98},
171 {0x7f,0xe8}, {0x7f,0xf8}, {0x7f,0xc8}, {0x7f,0xd8},
172 {0x7f,0x28}, {0x7f,0x38}, {0x7f,0x08}, {0x7f,0x18},
173 {0x7f,0x68}, {0x7f,0x78}, {0x7f,0x48}, {0x7f,0x58},
174 {0x7a,0xa0}, {0x7a,0xe0}, {0x7a,0x20}, {0x7a,0x60},
175 {0x7b,0xa0}, {0x7b,0xe0}, {0x7b,0x20}, {0x7b,0x60},
176 {0x78,0xa0}, {0x78,0xe0}, {0x78,0x20}, {0x78,0x60},
177 {0x79,0xa0}, {0x79,0xe0}, {0x79,0x20}, {0x79,0x60},
178 {0x7d,0x50}, {0x7d,0x70}, {0x7d,0x10}, {0x7d,0x30},
179 {0x7d,0xd0}, {0x7d,0xf0}, {0x7d,0x90}, {0x7d,0xb0},
180 {0x7c,0x50}, {0x7c,0x70}, {0x7c,0x10}, {0x7c,0x30},
181 {0x7c,0xd0}, {0x7c,0xf0}, {0x7c,0x90}, {0x7c,0xb0},
182 {0x95,0x80}, {0x94,0x80}, {0x97,0x80}, {0x96,0x80},
183 {0x91,0x80}, {0x90,0x80}, {0x93,0x80}, {0x92,0x80},
184 {0x9d,0x80}, {0x9c,0x80}, {0x9f,0x80}, {0x9e,0x80},
185 {0x99,0x80}, {0x98,0x80}, {0x9b,0x80}, {0x9a,0x80},
186 {0x8a,0xc0}, {0x8a,0x40}, {0x8b,0xc0}, {0x8b,0x40},
187 {0x88,0xc0}, {0x88,0x40}, {0x89,0xc0}, {0x89,0x40},
188 {0x8e,0xc0}, {0x8e,0x40}, {0x8f,0xc0}, {0x8f,0x40},
189 {0x8c,0xc0}, {0x8c,0x40}, {0x8d,0xc0}, {0x8d,0x40},
190 {0xd6,0x00}, {0xd2,0x00}, {0xde,0x00}, {0xda,0x00},
191 {0xc6,0x00}, {0xc2,0x00}, {0xce,0x00}, {0xca,0x00},
192 {0xf6,0x00}, {0xf2,0x00}, {0xfe,0x00}, {0xfa,0x00},
193 {0xe6,0x00}, {0xe2,0x00}, {0xee,0x00}, {0xea,0x00},
194 {0xab,0x00}, {0xa9,0x00}, {0xaf,0x00}, {0xad,0x00},
195 {0xa3,0x00}, {0xa1,0x00}, {0xa7,0x00}, {0xa5,0x00},
196 {0xbb,0x00}, {0xb9,0x00}, {0xbf,0x00}, {0xbd,0x00},
197 {0xb3,0x00}, {0xb1,0x00}, {0xb7,0x00}, {0xb5,0x00},
198 {0x81,0x58}, {0x81,0x48}, {0x81,0x78}, {0x81,0x68},
199 {0x81,0x18}, {0x81,0x08}, {0x81,0x38}, {0x81,0x28},
200 {0x81,0xd8}, {0x81,0xc8}, {0x81,0xf8}, {0x81,0xe8},
201 {0x81,0x98}, {0x81,0x88}, {0x81,0xb8}, {0x81,0xa8},
202 {0x80,0x58}, {0x80,0x48}, {0x80,0x78}, {0x80,0x68},
203 {0x80,0x18}, {0x80,0x08}, {0x80,0x38}, {0x80,0x28},
204 {0x80,0xd8}, {0x80,0xc8}, {0x80,0xf8}, {0x80,0xe8},
205 {0x80,0x98}, {0x80,0x88}, {0x80,0xb8}, {0x80,0xa8},
206 {0x85,0x60}, {0x85,0x20}, {0x85,0xe0}, {0x85,0xa0},
207 {0x84,0x60}, {0x84,0x20}, {0x84,0xe0}, {0x84,0xa0},
208 {0x87,0x60}, {0x87,0x20}, {0x87,0xe0}, {0x87,0xa0},
209 {0x86,0x60}, {0x86,0x20}, {0x86,0xe0}, {0x86,0xa0},
210 {0x82,0xb0}, {0x82,0x90}, {0x82,0xf0}, {0x82,0xd0},
211 {0x82,0x30}, {0x82,0x10}, {0x82,0x70}, {0x82,0x50},
212 {0x83,0xb0}, {0x83,0x90}, {0x83,0xf0}, {0x83,0xd0},
213 {0x83,0x30}, {0x83,0x10}, {0x83,0x70}, {0x83,0x50},
214 };
215
216 static const u_char lintoalaw[256] = {
217 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b,
218 0x28, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29,
219 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f,
220 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d,
221 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23,
222 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21,
223 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27,
224 0x24, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x25,
225 0x3a, 0x3a, 0x3b, 0x3b, 0x38, 0x38, 0x39, 0x39,
226 0x3e, 0x3e, 0x3f, 0x3f, 0x3c, 0x3c, 0x3d, 0x3d,
227 0x32, 0x32, 0x33, 0x33, 0x30, 0x30, 0x31, 0x31,
228 0x36, 0x36, 0x37, 0x37, 0x34, 0x34, 0x35, 0x35,
229 0x0a, 0x0b, 0x08, 0x09, 0x0e, 0x0f, 0x0c, 0x0d,
230 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
231 0x1a, 0x18, 0x1e, 0x1c, 0x12, 0x10, 0x16, 0x14,
232 0x6a, 0x6e, 0x62, 0x66, 0x7a, 0x72, 0x4a, 0x5a,
233 0xd5, 0xc5, 0xf5, 0xfd, 0xe5, 0xe1, 0xed, 0xe9,
234 0x95, 0x97, 0x91, 0x93, 0x9d, 0x9f, 0x99, 0x9b,
235 0x85, 0x84, 0x87, 0x86, 0x81, 0x80, 0x83, 0x82,
236 0x8d, 0x8c, 0x8f, 0x8e, 0x89, 0x88, 0x8b, 0x8a,
237 0xb5, 0xb5, 0xb4, 0xb4, 0xb7, 0xb7, 0xb6, 0xb6,
238 0xb1, 0xb1, 0xb0, 0xb0, 0xb3, 0xb3, 0xb2, 0xb2,
239 0xbd, 0xbd, 0xbc, 0xbc, 0xbf, 0xbf, 0xbe, 0xbe,
240 0xb9, 0xb9, 0xb8, 0xb8, 0xbb, 0xbb, 0xba, 0xba,
241 0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4,
242 0xa7, 0xa7, 0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6,
243 0xa1, 0xa1, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, 0xa0,
244 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2,
245 0xad, 0xad, 0xad, 0xad, 0xac, 0xac, 0xac, 0xac,
246 0xaf, 0xaf, 0xaf, 0xaf, 0xae, 0xae, 0xae, 0xae,
247 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8,
248 0xab, 0xab, 0xab, 0xab, 0xaa, 0xaa, 0xaa, 0xaa,
249 };
250
251 void
252 mulaw_to_ulinear8(void *v, u_char *p, int cc)
253 {
254 /* Use the 16 bit table for 8 bits too. */
255 while (--cc >= 0) {
256 *p = mulawtolin16[*p][0];
257 ++p;
258 }
259 }
260
261 void
262 mulaw_to_slinear8(void *v, u_char *p, int cc)
263 {
264 /* Use the 16 bit table for 8 bits too. */
265 while (--cc >= 0) {
266 *p = mulawtolin16[*p][0] ^ 0x80;
267 ++p;
268 }
269 }
270
271 void
272 mulaw_to_ulinear16_le(void *v, u_char *p, int cc)
273 {
274 u_char *q = p;
275
276 p += cc;
277 q += cc << 1;
278 while (--cc >= 0) {
279 --p;
280 q -= 2;
281 q[1] = mulawtolin16[*p][0];
282 q[0] = mulawtolin16[*p][1];
283 }
284 }
285
286 void
287 mulaw_to_ulinear16_be(void *v, u_char *p, int cc)
288 {
289 u_char *q = p;
290
291 p += cc;
292 q += cc << 1;
293 while (--cc >= 0) {
294 --p;
295 q -= 2;
296 q[0] = mulawtolin16[*p][0];
297 q[1] = mulawtolin16[*p][1];
298 }
299 }
300
301 void
302 mulaw_to_slinear16_le(void *v, u_char *p, int cc)
303 {
304 u_char *q = p;
305
306 p += cc;
307 q += cc << 1;
308 while (--cc >= 0) {
309 --p;
310 q -= 2;
311 q[1] = mulawtolin16[*p][0] ^ 0x80;
312 q[0] = mulawtolin16[*p][1];
313 }
314 }
315
316 void
317 mulaw_to_slinear16_be(void *v, u_char *p, int cc)
318 {
319 u_char *q = p;
320
321 p += cc;
322 q += cc << 1;
323 while (--cc >= 0) {
324 --p;
325 q -= 2;
326 q[0] = mulawtolin16[*p][0] ^ 0x80;
327 q[1] = mulawtolin16[*p][1];
328 }
329 }
330
331 void
332 slinear16_to_mulaw_le(void *v, u_char* p, int cc)
333 {
334 u_char *q = p + 1; /* q points higher byte. */
335
336 while (--cc >= 0) {
337 *p++ = lintomulaw[*q ^ 0x80];
338 q +=2 ;
339 }
340 }
341
342 void
343 ulinear8_to_mulaw(void *v, u_char *p, int cc)
344 {
345 while (--cc >= 0) {
346 *p = lintomulaw[*p];
347 ++p;
348 }
349 }
350
351 void
352 slinear8_to_mulaw(void *v, u_char *p, int cc)
353 {
354 while (--cc >= 0) {
355 *p = lintomulaw[*p ^ 0x80];
356 ++p;
357 }
358 }
359
360 void
361 alaw_to_ulinear8(void *v, u_char *p, int cc)
362 {
363 /* Use the 16 bit table for 8 bits too. */
364 while (--cc >= 0) {
365 *p = alawtolin16[*p][0];
366 ++p;
367 }
368 }
369
370 void
371 alaw_to_slinear8(void *v, u_char *p, int cc)
372 {
373 /* Use the 16 bit table for 8 bits too. */
374 while (--cc >= 0) {
375 *p = alawtolin16[*p][0] ^ 0x80;
376 ++p;
377 }
378 }
379
380 void
381 alaw_to_ulinear16_le(void *v, u_char *p, int cc)
382 {
383 u_char *q = p;
384
385 p += cc;
386 q += cc << 1;
387 while (--cc >= 0) {
388 --p;
389 q -= 2;
390 q[1] = alawtolin16[*p][0];
391 q[0] = alawtolin16[*p][1];
392 }
393 }
394
395 void
396 alaw_to_ulinear16_be(void *v, u_char *p, int cc)
397 {
398 u_char *q = p;
399
400 p += cc;
401 q += cc << 1;
402 while (--cc >= 0) {
403 --p;
404 q -= 2;
405 q[0] = alawtolin16[*p][0];
406 q[1] = alawtolin16[*p][1];
407 }
408 }
409
410 void
411 alaw_to_slinear16_le(void *v, u_char *p, int cc)
412 {
413 u_char *q = p;
414
415 p += cc;
416 q += cc << 1;
417 while (--cc >= 0) {
418 --p;
419 q -= 2;
420 q[1] = alawtolin16[*p][0] ^ 0x80;
421 q[0] = alawtolin16[*p][1];
422 }
423 }
424
425 void
426 alaw_to_slinear16_be(void *v, u_char *p, int cc)
427 {
428 u_char *q = p;
429
430 p += cc;
431 q += cc << 1;
432 while (--cc >= 0) {
433 --p;
434 q -= 2;
435 q[0] = alawtolin16[*p][0] ^ 0x80;
436 q[1] = alawtolin16[*p][1];
437 }
438 }
439
440 void
441 ulinear8_to_alaw(void *v, u_char *p, int cc)
442 {
443 while (--cc >= 0) {
444 *p = lintoalaw[*p];
445 ++p;
446 }
447 }
448
449 void
450 slinear8_to_alaw(void *v, u_char *p, int cc)
451 {
452 while (--cc >= 0) {
453 *p = lintoalaw[*p ^ 0x80];
454 ++p;
455 }
456 }
457
458 void
459 slinear16_to_alaw_le(void *v, u_char *p, int cc)
460 {
461 u_char *q = p;
462
463 while (--cc >= 0) {
464 *p = lintoalaw[q[1] ^ 0x80];
465 ++p;
466 q += 2;
467 }
468 }
469
470
471 void
472 slinear16_to_alaw_be(void *v, u_char *p, int cc)
473 {
474 u_char *q = p;
475
476 while (--cc >= 0) {
477 *p = lintoalaw[q[0] ^ 0x80];
478 ++p;
479 q += 2;
480 }
481 }
482
483 /*
484 * same as mulaw_to_ulinear16_le(), plus expand mono to stereo
485 */
486 void
487 mulaw_to_ulinear16_le_mts(void *v, u_char *p, int cc)
488 {
489 u_char *q = p;
490
491 p += cc;
492 q += cc * 4;
493 while (--cc >= 0) {
494 --p;
495 q -= 4;
496 q[1] = q[3] = mulawtolin16[*p][0];
497 q[0] = q[2] = mulawtolin16[*p][1];
498 }
499 }
500
501 /*
502 * same as mulaw_to_ulinear16_be(), plus expand mono to stereo
503 */
504 void
505 mulaw_to_ulinear16_be_mts(void *v, u_char *p, int cc)
506 {
507 u_char *q = p;
508
509 p += cc;
510 q += cc * 4;
511 while (--cc >= 0) {
512 --p;
513 q -= 4;
514 q[0] = q[2] = mulawtolin16[*p][0];
515 q[1] = q[3] = mulawtolin16[*p][1];
516 }
517 }
518
519 /*
520 * same as alaw_to_slinear16_le(), plus expand mono to stereo
521 */
522 void
523 alaw_to_slinear16_le_mts(void *v, u_char *p, int cc)
524 {
525 u_char *q = p;
526
527 p += cc;
528 q += cc * 4;
529 while (--cc >= 0) {
530 --p;
531 q -= 4;
532 q[1] = q[3] = alawtolin16[*p][0] ^ 0x80;
533 q[0] = q[2] = alawtolin16[*p][1];
534 }
535 }
536
537 /*
538 * same as alaw_to_slinear16_be(), plus expand mono to stereo
539 */
540 void
541 alaw_to_slinear16_be_mts(void *v, u_char *p, int cc)
542 {
543 u_char *q = p;
544
545 p += cc;
546 q += cc * 4;
547 while (--cc >= 0) {
548 --p;
549 q -= 4;
550 q[0] = q[2] = alawtolin16[*p][0] ^ 0x80;
551 q[1] = q[3] = alawtolin16[*p][1];
552 }
553 }
554
555 void
556 alaw_to_mulaw(void *v, u_char *p, int cc)
557 {
558 while (--cc >= 0) {
559 *p = lintomulaw[alawtolin16[*p][0]];
560 ++p;
561 }
562 }
563
564 void
565 mulaw_to_alaw(void *v, u_char *p, int cc)
566 {
567 while (--cc >= 0) {
568 *p = lintoalaw[mulawtolin16[*p][0]];
569 ++p;
570 }
571 }
572