FreeBSD/Linux Kernel Cross Reference
sys/dev/mulaw.c
1 /* $NetBSD: mulaw.c,v 1.21 2003/04/06 18:20:12 wiz Exp $ */
2
3 /*
4 * Copyright (c) 1991-1993 Regents of the University of California.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by the Computer Systems
18 * Engineering Group at Lawrence Berkeley Laboratory.
19 * 4. Neither the name of the University nor of the Laboratory may be used
20 * to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 */
36
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: mulaw.c,v 1.21 2003/04/06 18:20:12 wiz Exp $");
39
40 #include <sys/types.h>
41 #include <sys/audioio.h>
42 #include <dev/mulaw.h>
43
44 /*
45 * This table converts a (8 bit) mu-law value to a 16 bit value.
46 * The 16 bits are represented as an array of two bytes for easier access
47 * to the individual bytes.
48 */
49 static const u_char mulawtolin16[256][2] = {
50 {0x02,0x84}, {0x06,0x84}, {0x0a,0x84}, {0x0e,0x84},
51 {0x12,0x84}, {0x16,0x84}, {0x1a,0x84}, {0x1e,0x84},
52 {0x22,0x84}, {0x26,0x84}, {0x2a,0x84}, {0x2e,0x84},
53 {0x32,0x84}, {0x36,0x84}, {0x3a,0x84}, {0x3e,0x84},
54 {0x41,0x84}, {0x43,0x84}, {0x45,0x84}, {0x47,0x84},
55 {0x49,0x84}, {0x4b,0x84}, {0x4d,0x84}, {0x4f,0x84},
56 {0x51,0x84}, {0x53,0x84}, {0x55,0x84}, {0x57,0x84},
57 {0x59,0x84}, {0x5b,0x84}, {0x5d,0x84}, {0x5f,0x84},
58 {0x61,0x04}, {0x62,0x04}, {0x63,0x04}, {0x64,0x04},
59 {0x65,0x04}, {0x66,0x04}, {0x67,0x04}, {0x68,0x04},
60 {0x69,0x04}, {0x6a,0x04}, {0x6b,0x04}, {0x6c,0x04},
61 {0x6d,0x04}, {0x6e,0x04}, {0x6f,0x04}, {0x70,0x04},
62 {0x70,0xc4}, {0x71,0x44}, {0x71,0xc4}, {0x72,0x44},
63 {0x72,0xc4}, {0x73,0x44}, {0x73,0xc4}, {0x74,0x44},
64 {0x74,0xc4}, {0x75,0x44}, {0x75,0xc4}, {0x76,0x44},
65 {0x76,0xc4}, {0x77,0x44}, {0x77,0xc4}, {0x78,0x44},
66 {0x78,0xa4}, {0x78,0xe4}, {0x79,0x24}, {0x79,0x64},
67 {0x79,0xa4}, {0x79,0xe4}, {0x7a,0x24}, {0x7a,0x64},
68 {0x7a,0xa4}, {0x7a,0xe4}, {0x7b,0x24}, {0x7b,0x64},
69 {0x7b,0xa4}, {0x7b,0xe4}, {0x7c,0x24}, {0x7c,0x64},
70 {0x7c,0x94}, {0x7c,0xb4}, {0x7c,0xd4}, {0x7c,0xf4},
71 {0x7d,0x14}, {0x7d,0x34}, {0x7d,0x54}, {0x7d,0x74},
72 {0x7d,0x94}, {0x7d,0xb4}, {0x7d,0xd4}, {0x7d,0xf4},
73 {0x7e,0x14}, {0x7e,0x34}, {0x7e,0x54}, {0x7e,0x74},
74 {0x7e,0x8c}, {0x7e,0x9c}, {0x7e,0xac}, {0x7e,0xbc},
75 {0x7e,0xcc}, {0x7e,0xdc}, {0x7e,0xec}, {0x7e,0xfc},
76 {0x7f,0x0c}, {0x7f,0x1c}, {0x7f,0x2c}, {0x7f,0x3c},
77 {0x7f,0x4c}, {0x7f,0x5c}, {0x7f,0x6c}, {0x7f,0x7c},
78 {0x7f,0x88}, {0x7f,0x90}, {0x7f,0x98}, {0x7f,0xa0},
79 {0x7f,0xa8}, {0x7f,0xb0}, {0x7f,0xb8}, {0x7f,0xc0},
80 {0x7f,0xc8}, {0x7f,0xd0}, {0x7f,0xd8}, {0x7f,0xe0},
81 {0x7f,0xe8}, {0x7f,0xf0}, {0x7f,0xf8}, {0x80,0x00},
82 {0xfd,0x7c}, {0xf9,0x7c}, {0xf5,0x7c}, {0xf1,0x7c},
83 {0xed,0x7c}, {0xe9,0x7c}, {0xe5,0x7c}, {0xe1,0x7c},
84 {0xdd,0x7c}, {0xd9,0x7c}, {0xd5,0x7c}, {0xd1,0x7c},
85 {0xcd,0x7c}, {0xc9,0x7c}, {0xc5,0x7c}, {0xc1,0x7c},
86 {0xbe,0x7c}, {0xbc,0x7c}, {0xba,0x7c}, {0xb8,0x7c},
87 {0xb6,0x7c}, {0xb4,0x7c}, {0xb2,0x7c}, {0xb0,0x7c},
88 {0xae,0x7c}, {0xac,0x7c}, {0xaa,0x7c}, {0xa8,0x7c},
89 {0xa6,0x7c}, {0xa4,0x7c}, {0xa2,0x7c}, {0xa0,0x7c},
90 {0x9e,0xfc}, {0x9d,0xfc}, {0x9c,0xfc}, {0x9b,0xfc},
91 {0x9a,0xfc}, {0x99,0xfc}, {0x98,0xfc}, {0x97,0xfc},
92 {0x96,0xfc}, {0x95,0xfc}, {0x94,0xfc}, {0x93,0xfc},
93 {0x92,0xfc}, {0x91,0xfc}, {0x90,0xfc}, {0x8f,0xfc},
94 {0x8f,0x3c}, {0x8e,0xbc}, {0x8e,0x3c}, {0x8d,0xbc},
95 {0x8d,0x3c}, {0x8c,0xbc}, {0x8c,0x3c}, {0x8b,0xbc},
96 {0x8b,0x3c}, {0x8a,0xbc}, {0x8a,0x3c}, {0x89,0xbc},
97 {0x89,0x3c}, {0x88,0xbc}, {0x88,0x3c}, {0x87,0xbc},
98 {0x87,0x5c}, {0x87,0x1c}, {0x86,0xdc}, {0x86,0x9c},
99 {0x86,0x5c}, {0x86,0x1c}, {0x85,0xdc}, {0x85,0x9c},
100 {0x85,0x5c}, {0x85,0x1c}, {0x84,0xdc}, {0x84,0x9c},
101 {0x84,0x5c}, {0x84,0x1c}, {0x83,0xdc}, {0x83,0x9c},
102 {0x83,0x6c}, {0x83,0x4c}, {0x83,0x2c}, {0x83,0x0c},
103 {0x82,0xec}, {0x82,0xcc}, {0x82,0xac}, {0x82,0x8c},
104 {0x82,0x6c}, {0x82,0x4c}, {0x82,0x2c}, {0x82,0x0c},
105 {0x81,0xec}, {0x81,0xcc}, {0x81,0xac}, {0x81,0x8c},
106 {0x81,0x74}, {0x81,0x64}, {0x81,0x54}, {0x81,0x44},
107 {0x81,0x34}, {0x81,0x24}, {0x81,0x14}, {0x81,0x04},
108 {0x80,0xf4}, {0x80,0xe4}, {0x80,0xd4}, {0x80,0xc4},
109 {0x80,0xb4}, {0x80,0xa4}, {0x80,0x94}, {0x80,0x84},
110 {0x80,0x78}, {0x80,0x70}, {0x80,0x68}, {0x80,0x60},
111 {0x80,0x58}, {0x80,0x50}, {0x80,0x48}, {0x80,0x40},
112 {0x80,0x38}, {0x80,0x30}, {0x80,0x28}, {0x80,0x20},
113 {0x80,0x18}, {0x80,0x10}, {0x80,0x08}, {0x80,0x00},
114 };
115
116 static const u_char lintomulaw[256] = {
117 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
118 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,
119 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05,
120 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07,
121 0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
122 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b,
123 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d,
124 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f,
125 0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13,
126 0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17,
127 0x17, 0x18, 0x18, 0x19, 0x19, 0x1a, 0x1a, 0x1b,
128 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f,
129 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
130 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
131 0x2f, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c,
132 0x3e, 0x41, 0x45, 0x49, 0x4d, 0x53, 0x5b, 0x67,
133 0xff, 0xe7, 0xdb, 0xd3, 0xcd, 0xc9, 0xc5, 0xc1,
134 0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, 0xb2, 0xb0,
135 0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
136 0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
137 0x9f, 0x9f, 0x9e, 0x9e, 0x9d, 0x9d, 0x9c, 0x9c,
138 0x9b, 0x9b, 0x9a, 0x9a, 0x99, 0x99, 0x98, 0x98,
139 0x97, 0x97, 0x96, 0x96, 0x95, 0x95, 0x94, 0x94,
140 0x93, 0x93, 0x92, 0x92, 0x91, 0x91, 0x90, 0x90,
141 0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e,
142 0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c,
143 0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a,
144 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88,
145 0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86,
146 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84,
147 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
148 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80,
149 };
150
151 static const u_char alawtolin16[256][2] = {
152 {0x6a,0x80}, {0x6b,0x80}, {0x68,0x80}, {0x69,0x80},
153 {0x6e,0x80}, {0x6f,0x80}, {0x6c,0x80}, {0x6d,0x80},
154 {0x62,0x80}, {0x63,0x80}, {0x60,0x80}, {0x61,0x80},
155 {0x66,0x80}, {0x67,0x80}, {0x64,0x80}, {0x65,0x80},
156 {0x75,0x40}, {0x75,0xc0}, {0x74,0x40}, {0x74,0xc0},
157 {0x77,0x40}, {0x77,0xc0}, {0x76,0x40}, {0x76,0xc0},
158 {0x71,0x40}, {0x71,0xc0}, {0x70,0x40}, {0x70,0xc0},
159 {0x73,0x40}, {0x73,0xc0}, {0x72,0x40}, {0x72,0xc0},
160 {0x2a,0x00}, {0x2e,0x00}, {0x22,0x00}, {0x26,0x00},
161 {0x3a,0x00}, {0x3e,0x00}, {0x32,0x00}, {0x36,0x00},
162 {0x0a,0x00}, {0x0e,0x00}, {0x02,0x00}, {0x06,0x00},
163 {0x1a,0x00}, {0x1e,0x00}, {0x12,0x00}, {0x16,0x00},
164 {0x55,0x00}, {0x57,0x00}, {0x51,0x00}, {0x53,0x00},
165 {0x5d,0x00}, {0x5f,0x00}, {0x59,0x00}, {0x5b,0x00},
166 {0x45,0x00}, {0x47,0x00}, {0x41,0x00}, {0x43,0x00},
167 {0x4d,0x00}, {0x4f,0x00}, {0x49,0x00}, {0x4b,0x00},
168 {0x7e,0xa8}, {0x7e,0xb8}, {0x7e,0x88}, {0x7e,0x98},
169 {0x7e,0xe8}, {0x7e,0xf8}, {0x7e,0xc8}, {0x7e,0xd8},
170 {0x7e,0x28}, {0x7e,0x38}, {0x7e,0x08}, {0x7e,0x18},
171 {0x7e,0x68}, {0x7e,0x78}, {0x7e,0x48}, {0x7e,0x58},
172 {0x7f,0xa8}, {0x7f,0xb8}, {0x7f,0x88}, {0x7f,0x98},
173 {0x7f,0xe8}, {0x7f,0xf8}, {0x7f,0xc8}, {0x7f,0xd8},
174 {0x7f,0x28}, {0x7f,0x38}, {0x7f,0x08}, {0x7f,0x18},
175 {0x7f,0x68}, {0x7f,0x78}, {0x7f,0x48}, {0x7f,0x58},
176 {0x7a,0xa0}, {0x7a,0xe0}, {0x7a,0x20}, {0x7a,0x60},
177 {0x7b,0xa0}, {0x7b,0xe0}, {0x7b,0x20}, {0x7b,0x60},
178 {0x78,0xa0}, {0x78,0xe0}, {0x78,0x20}, {0x78,0x60},
179 {0x79,0xa0}, {0x79,0xe0}, {0x79,0x20}, {0x79,0x60},
180 {0x7d,0x50}, {0x7d,0x70}, {0x7d,0x10}, {0x7d,0x30},
181 {0x7d,0xd0}, {0x7d,0xf0}, {0x7d,0x90}, {0x7d,0xb0},
182 {0x7c,0x50}, {0x7c,0x70}, {0x7c,0x10}, {0x7c,0x30},
183 {0x7c,0xd0}, {0x7c,0xf0}, {0x7c,0x90}, {0x7c,0xb0},
184 {0x95,0x80}, {0x94,0x80}, {0x97,0x80}, {0x96,0x80},
185 {0x91,0x80}, {0x90,0x80}, {0x93,0x80}, {0x92,0x80},
186 {0x9d,0x80}, {0x9c,0x80}, {0x9f,0x80}, {0x9e,0x80},
187 {0x99,0x80}, {0x98,0x80}, {0x9b,0x80}, {0x9a,0x80},
188 {0x8a,0xc0}, {0x8a,0x40}, {0x8b,0xc0}, {0x8b,0x40},
189 {0x88,0xc0}, {0x88,0x40}, {0x89,0xc0}, {0x89,0x40},
190 {0x8e,0xc0}, {0x8e,0x40}, {0x8f,0xc0}, {0x8f,0x40},
191 {0x8c,0xc0}, {0x8c,0x40}, {0x8d,0xc0}, {0x8d,0x40},
192 {0xd6,0x00}, {0xd2,0x00}, {0xde,0x00}, {0xda,0x00},
193 {0xc6,0x00}, {0xc2,0x00}, {0xce,0x00}, {0xca,0x00},
194 {0xf6,0x00}, {0xf2,0x00}, {0xfe,0x00}, {0xfa,0x00},
195 {0xe6,0x00}, {0xe2,0x00}, {0xee,0x00}, {0xea,0x00},
196 {0xab,0x00}, {0xa9,0x00}, {0xaf,0x00}, {0xad,0x00},
197 {0xa3,0x00}, {0xa1,0x00}, {0xa7,0x00}, {0xa5,0x00},
198 {0xbb,0x00}, {0xb9,0x00}, {0xbf,0x00}, {0xbd,0x00},
199 {0xb3,0x00}, {0xb1,0x00}, {0xb7,0x00}, {0xb5,0x00},
200 {0x81,0x58}, {0x81,0x48}, {0x81,0x78}, {0x81,0x68},
201 {0x81,0x18}, {0x81,0x08}, {0x81,0x38}, {0x81,0x28},
202 {0x81,0xd8}, {0x81,0xc8}, {0x81,0xf8}, {0x81,0xe8},
203 {0x81,0x98}, {0x81,0x88}, {0x81,0xb8}, {0x81,0xa8},
204 {0x80,0x58}, {0x80,0x48}, {0x80,0x78}, {0x80,0x68},
205 {0x80,0x18}, {0x80,0x08}, {0x80,0x38}, {0x80,0x28},
206 {0x80,0xd8}, {0x80,0xc8}, {0x80,0xf8}, {0x80,0xe8},
207 {0x80,0x98}, {0x80,0x88}, {0x80,0xb8}, {0x80,0xa8},
208 {0x85,0x60}, {0x85,0x20}, {0x85,0xe0}, {0x85,0xa0},
209 {0x84,0x60}, {0x84,0x20}, {0x84,0xe0}, {0x84,0xa0},
210 {0x87,0x60}, {0x87,0x20}, {0x87,0xe0}, {0x87,0xa0},
211 {0x86,0x60}, {0x86,0x20}, {0x86,0xe0}, {0x86,0xa0},
212 {0x82,0xb0}, {0x82,0x90}, {0x82,0xf0}, {0x82,0xd0},
213 {0x82,0x30}, {0x82,0x10}, {0x82,0x70}, {0x82,0x50},
214 {0x83,0xb0}, {0x83,0x90}, {0x83,0xf0}, {0x83,0xd0},
215 {0x83,0x30}, {0x83,0x10}, {0x83,0x70}, {0x83,0x50},
216 };
217
218 static const u_char lintoalaw[256] = {
219 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b,
220 0x28, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29,
221 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f,
222 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d,
223 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23,
224 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21,
225 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27,
226 0x24, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x25,
227 0x3a, 0x3a, 0x3b, 0x3b, 0x38, 0x38, 0x39, 0x39,
228 0x3e, 0x3e, 0x3f, 0x3f, 0x3c, 0x3c, 0x3d, 0x3d,
229 0x32, 0x32, 0x33, 0x33, 0x30, 0x30, 0x31, 0x31,
230 0x36, 0x36, 0x37, 0x37, 0x34, 0x34, 0x35, 0x35,
231 0x0a, 0x0b, 0x08, 0x09, 0x0e, 0x0f, 0x0c, 0x0d,
232 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
233 0x1a, 0x18, 0x1e, 0x1c, 0x12, 0x10, 0x16, 0x14,
234 0x6a, 0x6e, 0x62, 0x66, 0x7a, 0x72, 0x4a, 0x5a,
235 0xd5, 0xc5, 0xf5, 0xfd, 0xe5, 0xe1, 0xed, 0xe9,
236 0x95, 0x97, 0x91, 0x93, 0x9d, 0x9f, 0x99, 0x9b,
237 0x85, 0x84, 0x87, 0x86, 0x81, 0x80, 0x83, 0x82,
238 0x8d, 0x8c, 0x8f, 0x8e, 0x89, 0x88, 0x8b, 0x8a,
239 0xb5, 0xb5, 0xb4, 0xb4, 0xb7, 0xb7, 0xb6, 0xb6,
240 0xb1, 0xb1, 0xb0, 0xb0, 0xb3, 0xb3, 0xb2, 0xb2,
241 0xbd, 0xbd, 0xbc, 0xbc, 0xbf, 0xbf, 0xbe, 0xbe,
242 0xb9, 0xb9, 0xb8, 0xb8, 0xbb, 0xbb, 0xba, 0xba,
243 0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4,
244 0xa7, 0xa7, 0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6,
245 0xa1, 0xa1, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, 0xa0,
246 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2,
247 0xad, 0xad, 0xad, 0xad, 0xac, 0xac, 0xac, 0xac,
248 0xaf, 0xaf, 0xaf, 0xaf, 0xae, 0xae, 0xae, 0xae,
249 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8,
250 0xab, 0xab, 0xab, 0xab, 0xaa, 0xaa, 0xaa, 0xaa,
251 };
252
253 void
254 mulaw_to_ulinear8(void *v, u_char *p, int cc)
255 {
256 /* Use the 16 bit table for 8 bits too. */
257 while (--cc >= 0) {
258 *p = mulawtolin16[*p][0];
259 ++p;
260 }
261 }
262
263 void
264 mulaw_to_slinear8(void *v, u_char *p, int cc)
265 {
266 /* Use the 16 bit table for 8 bits too. */
267 while (--cc >= 0) {
268 *p = mulawtolin16[*p][0] ^ 0x80;
269 ++p;
270 }
271 }
272
273 void
274 mulaw_to_ulinear16_le(void *v, u_char *p, int cc)
275 {
276 u_char *q = p;
277
278 p += cc;
279 q += cc << 1;
280 while (--cc >= 0) {
281 --p;
282 q -= 2;
283 q[1] = mulawtolin16[*p][0];
284 q[0] = mulawtolin16[*p][1];
285 }
286 }
287
288 void
289 mulaw_to_ulinear16_be(void *v, u_char *p, int cc)
290 {
291 u_char *q = p;
292
293 p += cc;
294 q += cc << 1;
295 while (--cc >= 0) {
296 --p;
297 q -= 2;
298 q[0] = mulawtolin16[*p][0];
299 q[1] = mulawtolin16[*p][1];
300 }
301 }
302
303 void
304 mulaw_to_slinear16_le(void *v, u_char *p, int cc)
305 {
306 u_char *q = p;
307
308 p += cc;
309 q += cc << 1;
310 while (--cc >= 0) {
311 --p;
312 q -= 2;
313 q[1] = mulawtolin16[*p][0] ^ 0x80;
314 q[0] = mulawtolin16[*p][1];
315 }
316 }
317
318 void
319 mulaw_to_slinear16_be(void *v, u_char *p, int cc)
320 {
321 u_char *q = p;
322
323 p += cc;
324 q += cc << 1;
325 while (--cc >= 0) {
326 --p;
327 q -= 2;
328 q[0] = mulawtolin16[*p][0] ^ 0x80;
329 q[1] = mulawtolin16[*p][1];
330 }
331 }
332
333 void
334 slinear16_to_mulaw_le(void *v, u_char* p, int cc)
335 {
336 u_char *q = p + 1; /* q points higher byte. */
337
338 while (--cc >= 0) {
339 *p++ = lintomulaw[*q ^ 0x80];
340 q +=2 ;
341 }
342 }
343
344 void
345 ulinear8_to_mulaw(void *v, u_char *p, int cc)
346 {
347 while (--cc >= 0) {
348 *p = lintomulaw[*p];
349 ++p;
350 }
351 }
352
353 void
354 slinear8_to_mulaw(void *v, u_char *p, int cc)
355 {
356 while (--cc >= 0) {
357 *p = lintomulaw[*p ^ 0x80];
358 ++p;
359 }
360 }
361
362 void
363 alaw_to_ulinear8(void *v, u_char *p, int cc)
364 {
365 /* Use the 16 bit table for 8 bits too. */
366 while (--cc >= 0) {
367 *p = alawtolin16[*p][0];
368 ++p;
369 }
370 }
371
372 void
373 alaw_to_slinear8(void *v, u_char *p, int cc)
374 {
375 /* Use the 16 bit table for 8 bits too. */
376 while (--cc >= 0) {
377 *p = alawtolin16[*p][0] ^ 0x80;
378 ++p;
379 }
380 }
381
382 void
383 alaw_to_ulinear16_le(void *v, u_char *p, int cc)
384 {
385 u_char *q = p;
386
387 p += cc;
388 q += cc << 1;
389 while (--cc >= 0) {
390 --p;
391 q -= 2;
392 q[1] = alawtolin16[*p][0];
393 q[0] = alawtolin16[*p][1];
394 }
395 }
396
397 void
398 alaw_to_ulinear16_be(void *v, u_char *p, int cc)
399 {
400 u_char *q = p;
401
402 p += cc;
403 q += cc << 1;
404 while (--cc >= 0) {
405 --p;
406 q -= 2;
407 q[0] = alawtolin16[*p][0];
408 q[1] = alawtolin16[*p][1];
409 }
410 }
411
412 void
413 alaw_to_slinear16_le(void *v, u_char *p, int cc)
414 {
415 u_char *q = p;
416
417 p += cc;
418 q += cc << 1;
419 while (--cc >= 0) {
420 --p;
421 q -= 2;
422 q[1] = alawtolin16[*p][0] ^ 0x80;
423 q[0] = alawtolin16[*p][1];
424 }
425 }
426
427 void
428 alaw_to_slinear16_be(void *v, u_char *p, int cc)
429 {
430 u_char *q = p;
431
432 p += cc;
433 q += cc << 1;
434 while (--cc >= 0) {
435 --p;
436 q -= 2;
437 q[0] = alawtolin16[*p][0] ^ 0x80;
438 q[1] = alawtolin16[*p][1];
439 }
440 }
441
442 void
443 ulinear8_to_alaw(void *v, u_char *p, int cc)
444 {
445 while (--cc >= 0) {
446 *p = lintoalaw[*p];
447 ++p;
448 }
449 }
450
451 void
452 slinear8_to_alaw(void *v, u_char *p, int cc)
453 {
454 while (--cc >= 0) {
455 *p = lintoalaw[*p ^ 0x80];
456 ++p;
457 }
458 }
459
460 void
461 slinear16_to_alaw_le(void *v, u_char *p, int cc)
462 {
463 u_char *q = p;
464
465 while (--cc >= 0) {
466 *p = lintoalaw[q[1] ^ 0x80];
467 ++p;
468 q += 2;
469 }
470 }
471
472
473 void
474 slinear16_to_alaw_be(void *v, u_char *p, int cc)
475 {
476 u_char *q = p;
477
478 while (--cc >= 0) {
479 *p = lintoalaw[q[0] ^ 0x80];
480 ++p;
481 q += 2;
482 }
483 }
Cache object: 808e6e8a94deab9ffe2d53389995fb7a
|