xref: /openbmc/linux/drivers/isdn/mISDN/l1oip_codec.c (revision 293d5b43)
1 /*
2 
3  * l1oip_codec.c  generic codec using lookup table
4  *  -> conversion from a-Law to u-Law
5  *  -> conversion from u-Law to a-Law
6  *  -> compression by reducing the number of sample resolution to 4
7  *
8  * NOTE: It is not compatible with any standard codec like ADPCM.
9  *
10  * Author	Andreas Eversberg (jolly@eversberg.eu)
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2, or (at your option)
15  * any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 
26  */
27 
28 /*
29 
30   How the codec works:
31   --------------------
32 
33   The volume is increased to increase the dynamic range of the audio signal.
34   Each sample is converted to a-LAW with only 16 steps of level resolution.
35   A pair of two samples are stored in one byte.
36 
37   The first byte is stored in the upper bits, the second byte is stored in the
38   lower bits.
39 
40   To speed up compression and decompression, two lookup tables are formed:
41 
42   - 16 bits index for two samples (law encoded) with 8 bit compressed result.
43   - 8 bits index for one compressed data with 16 bits decompressed result.
44 
45   NOTE: The bytes are handled as they are law-encoded.
46 
47 */
48 
49 #include <linux/vmalloc.h>
50 #include <linux/mISDNif.h>
51 #include <linux/in.h>
52 #include "core.h"
53 #include "l1oip.h"
54 
55 /* definitions of codec. don't use calculations, code may run slower. */
56 
57 static u8 *table_com;
58 static u16 *table_dec;
59 
60 
61 /* alaw -> ulaw */
62 static u8 alaw_to_ulaw[256] =
63 {
64 	0xab, 0x2b, 0xe3, 0x63, 0x8b, 0x0b, 0xc9, 0x49,
65 	0xba, 0x3a, 0xf6, 0x76, 0x9b, 0x1b, 0xd7, 0x57,
66 	0xa3, 0x23, 0xdd, 0x5d, 0x83, 0x03, 0xc1, 0x41,
67 	0xb2, 0x32, 0xeb, 0x6b, 0x93, 0x13, 0xcf, 0x4f,
68 	0xaf, 0x2f, 0xe7, 0x67, 0x8f, 0x0f, 0xcd, 0x4d,
69 	0xbe, 0x3e, 0xfe, 0x7e, 0x9f, 0x1f, 0xdb, 0x5b,
70 	0xa7, 0x27, 0xdf, 0x5f, 0x87, 0x07, 0xc5, 0x45,
71 	0xb6, 0x36, 0xef, 0x6f, 0x97, 0x17, 0xd3, 0x53,
72 	0xa9, 0x29, 0xe1, 0x61, 0x89, 0x09, 0xc7, 0x47,
73 	0xb8, 0x38, 0xf2, 0x72, 0x99, 0x19, 0xd5, 0x55,
74 	0xa1, 0x21, 0xdc, 0x5c, 0x81, 0x01, 0xbf, 0x3f,
75 	0xb0, 0x30, 0xe9, 0x69, 0x91, 0x11, 0xce, 0x4e,
76 	0xad, 0x2d, 0xe5, 0x65, 0x8d, 0x0d, 0xcb, 0x4b,
77 	0xbc, 0x3c, 0xfa, 0x7a, 0x9d, 0x1d, 0xd9, 0x59,
78 	0xa5, 0x25, 0xde, 0x5e, 0x85, 0x05, 0xc3, 0x43,
79 	0xb4, 0x34, 0xed, 0x6d, 0x95, 0x15, 0xd1, 0x51,
80 	0xac, 0x2c, 0xe4, 0x64, 0x8c, 0x0c, 0xca, 0x4a,
81 	0xbb, 0x3b, 0xf8, 0x78, 0x9c, 0x1c, 0xd8, 0x58,
82 	0xa4, 0x24, 0xde, 0x5e, 0x84, 0x04, 0xc2, 0x42,
83 	0xb3, 0x33, 0xec, 0x6c, 0x94, 0x14, 0xd0, 0x50,
84 	0xb0, 0x30, 0xe8, 0x68, 0x90, 0x10, 0xce, 0x4e,
85 	0xbf, 0x3f, 0xfe, 0x7e, 0xa0, 0x20, 0xdc, 0x5c,
86 	0xa8, 0x28, 0xe0, 0x60, 0x88, 0x08, 0xc6, 0x46,
87 	0xb7, 0x37, 0xf0, 0x70, 0x98, 0x18, 0xd4, 0x54,
88 	0xaa, 0x2a, 0xe2, 0x62, 0x8a, 0x0a, 0xc8, 0x48,
89 	0xb9, 0x39, 0xf4, 0x74, 0x9a, 0x1a, 0xd6, 0x56,
90 	0xa2, 0x22, 0xdd, 0x5d, 0x82, 0x02, 0xc0, 0x40,
91 	0xb1, 0x31, 0xea, 0x6a, 0x92, 0x12, 0xcf, 0x4f,
92 	0xae, 0x2e, 0xe6, 0x66, 0x8e, 0x0e, 0xcc, 0x4c,
93 	0xbd, 0x3d, 0xfc, 0x7c, 0x9e, 0x1e, 0xda, 0x5a,
94 	0xa6, 0x26, 0xdf, 0x5f, 0x86, 0x06, 0xc4, 0x44,
95 	0xb5, 0x35, 0xee, 0x6e, 0x96, 0x16, 0xd2, 0x52
96 };
97 
98 /* ulaw -> alaw */
99 static u8 ulaw_to_alaw[256] =
100 {
101 	0xab, 0x55, 0xd5, 0x15, 0x95, 0x75, 0xf5, 0x35,
102 	0xb5, 0x45, 0xc5, 0x05, 0x85, 0x65, 0xe5, 0x25,
103 	0xa5, 0x5d, 0xdd, 0x1d, 0x9d, 0x7d, 0xfd, 0x3d,
104 	0xbd, 0x4d, 0xcd, 0x0d, 0x8d, 0x6d, 0xed, 0x2d,
105 	0xad, 0x51, 0xd1, 0x11, 0x91, 0x71, 0xf1, 0x31,
106 	0xb1, 0x41, 0xc1, 0x01, 0x81, 0x61, 0xe1, 0x21,
107 	0x59, 0xd9, 0x19, 0x99, 0x79, 0xf9, 0x39, 0xb9,
108 	0x49, 0xc9, 0x09, 0x89, 0x69, 0xe9, 0x29, 0xa9,
109 	0xd7, 0x17, 0x97, 0x77, 0xf7, 0x37, 0xb7, 0x47,
110 	0xc7, 0x07, 0x87, 0x67, 0xe7, 0x27, 0xa7, 0xdf,
111 	0x9f, 0x7f, 0xff, 0x3f, 0xbf, 0x4f, 0xcf, 0x0f,
112 	0x8f, 0x6f, 0xef, 0x2f, 0x53, 0x13, 0x73, 0x33,
113 	0xb3, 0x43, 0xc3, 0x03, 0x83, 0x63, 0xe3, 0x23,
114 	0xa3, 0x5b, 0xdb, 0x1b, 0x9b, 0x7b, 0xfb, 0x3b,
115 	0xbb, 0xbb, 0x4b, 0x4b, 0xcb, 0xcb, 0x0b, 0x0b,
116 	0x8b, 0x8b, 0x6b, 0x6b, 0xeb, 0xeb, 0x2b, 0x2b,
117 	0xab, 0x54, 0xd4, 0x14, 0x94, 0x74, 0xf4, 0x34,
118 	0xb4, 0x44, 0xc4, 0x04, 0x84, 0x64, 0xe4, 0x24,
119 	0xa4, 0x5c, 0xdc, 0x1c, 0x9c, 0x7c, 0xfc, 0x3c,
120 	0xbc, 0x4c, 0xcc, 0x0c, 0x8c, 0x6c, 0xec, 0x2c,
121 	0xac, 0x50, 0xd0, 0x10, 0x90, 0x70, 0xf0, 0x30,
122 	0xb0, 0x40, 0xc0, 0x00, 0x80, 0x60, 0xe0, 0x20,
123 	0x58, 0xd8, 0x18, 0x98, 0x78, 0xf8, 0x38, 0xb8,
124 	0x48, 0xc8, 0x08, 0x88, 0x68, 0xe8, 0x28, 0xa8,
125 	0xd6, 0x16, 0x96, 0x76, 0xf6, 0x36, 0xb6, 0x46,
126 	0xc6, 0x06, 0x86, 0x66, 0xe6, 0x26, 0xa6, 0xde,
127 	0x9e, 0x7e, 0xfe, 0x3e, 0xbe, 0x4e, 0xce, 0x0e,
128 	0x8e, 0x6e, 0xee, 0x2e, 0x52, 0x12, 0x72, 0x32,
129 	0xb2, 0x42, 0xc2, 0x02, 0x82, 0x62, 0xe2, 0x22,
130 	0xa2, 0x5a, 0xda, 0x1a, 0x9a, 0x7a, 0xfa, 0x3a,
131 	0xba, 0xba, 0x4a, 0x4a, 0xca, 0xca, 0x0a, 0x0a,
132 	0x8a, 0x8a, 0x6a, 0x6a, 0xea, 0xea, 0x2a, 0x2a
133 };
134 
135 /* alaw -> 4bit compression */
136 static u8 alaw_to_4bit[256] = {
137 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
138 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
139 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
140 	0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
141 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
142 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
143 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
144 	0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
145 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
146 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
147 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0d, 0x02,
148 	0x0e, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
149 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
150 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
151 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
152 	0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
153 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
154 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
155 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
156 	0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
157 	0x0e, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
158 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x01, 0x0a, 0x05,
159 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
160 	0x0d, 0x02, 0x09, 0x07, 0x0f, 0x00, 0x0b, 0x04,
161 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
162 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
163 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
164 	0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
165 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
166 	0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
167 	0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
168 	0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
169 };
170 
171 /* 4bit -> alaw decompression */
172 static u8 _4bit_to_alaw[16] = {
173 	0x5d, 0x51, 0xd9, 0xd7, 0x5f, 0x53, 0xa3, 0x4b,
174 	0x2a, 0x3a, 0x22, 0x2e, 0x26, 0x56, 0x20, 0x2c,
175 };
176 
177 /* ulaw -> 4bit compression */
178 static u8 ulaw_to_4bit[256] = {
179 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
180 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
181 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
182 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
183 	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
184 	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
185 	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
186 	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
187 	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
188 	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04,
189 	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
190 	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
191 	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
192 	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
193 	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
194 	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08,
195 	0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
196 	0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
197 	0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
198 	0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
199 	0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
200 	0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
201 	0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
202 	0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
203 	0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
204 	0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b,
205 	0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
206 	0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a,
207 	0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
208 	0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
209 	0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
210 	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
211 };
212 
213 /* 4bit -> ulaw decompression */
214 static u8 _4bit_to_ulaw[16] = {
215 	0x11, 0x21, 0x31, 0x40, 0x4e, 0x5c, 0x68, 0x71,
216 	0xfe, 0xef, 0xe7, 0xdb, 0xcd, 0xbf, 0xaf, 0x9f,
217 };
218 
219 
220 /*
221  * Compresses data to the result buffer
222  * The result size must be at least half of the input buffer.
223  * The number of samples also must be even!
224  */
225 int
226 l1oip_law_to_4bit(u8 *data, int len, u8 *result, u32 *state)
227 {
228 	int ii, i = 0, o = 0;
229 
230 	if (!len)
231 		return 0;
232 
233 	/* send saved byte and first input byte */
234 	if (*state) {
235 		*result++ = table_com[(((*state) << 8) & 0xff00) | (*data++)];
236 		len--;
237 		o++;
238 	}
239 
240 	ii = len >> 1;
241 
242 	while (i < ii) {
243 		*result++ = table_com[(data[0]<<8) | (data[1])];
244 		data += 2;
245 		i++;
246 		o++;
247 	}
248 
249 	/* if len has an odd number, we save byte for next call */
250 	if (len & 1)
251 		*state = 0x100 + *data;
252 	else
253 		*state = 0;
254 
255 	return o;
256 }
257 
258 /* Decompress data to the result buffer
259  * The result size must be the number of sample in packet. (2 * input data)
260  * The number of samples in the result are even!
261  */
262 int
263 l1oip_4bit_to_law(u8 *data, int len, u8 *result)
264 {
265 	int i = 0;
266 	u16 r;
267 
268 	while (i < len) {
269 		r = table_dec[*data++];
270 		*result++ = r >> 8;
271 		*result++ = r;
272 		i++;
273 	}
274 
275 	return len << 1;
276 }
277 
278 
279 /*
280  * law conversion
281  */
282 int
283 l1oip_alaw_to_ulaw(u8 *data, int len, u8 *result)
284 {
285 	int i = 0;
286 
287 	while (i < len) {
288 		*result++ = alaw_to_ulaw[*data++];
289 		i++;
290 	}
291 
292 	return len;
293 }
294 
295 int
296 l1oip_ulaw_to_alaw(u8 *data, int len, u8 *result)
297 {
298 	int i = 0;
299 
300 	while (i < len) {
301 		*result++ = ulaw_to_alaw[*data++];
302 		i++;
303 	}
304 
305 	return len;
306 }
307 
308 
309 /*
310  * generate/free compression and decompression table
311  */
312 void
313 l1oip_4bit_free(void)
314 {
315 	vfree(table_dec);
316 	vfree(table_com);
317 	table_com = NULL;
318 	table_dec = NULL;
319 }
320 
321 int
322 l1oip_4bit_alloc(int ulaw)
323 {
324 	int i1, i2, c, sample;
325 
326 	/* in case, it is called again */
327 	if (table_dec)
328 		return 0;
329 
330 	/* alloc conversion tables */
331 	table_com = vzalloc(65536);
332 	table_dec = vzalloc(512);
333 	if (!table_com || !table_dec) {
334 		l1oip_4bit_free();
335 		return -ENOMEM;
336 	}
337 	/* generate compression table */
338 	i1 = 0;
339 	while (i1 < 256) {
340 		if (ulaw)
341 			c = ulaw_to_4bit[i1];
342 		else
343 			c = alaw_to_4bit[i1];
344 		i2 = 0;
345 		while (i2 < 256) {
346 			table_com[(i1 << 8) | i2] |= (c << 4);
347 			table_com[(i2 << 8) | i1] |= c;
348 			i2++;
349 		}
350 		i1++;
351 	}
352 
353 	/* generate decompression table */
354 	i1 = 0;
355 	while (i1 < 16) {
356 		if (ulaw)
357 			sample = _4bit_to_ulaw[i1];
358 		else
359 			sample = _4bit_to_alaw[i1];
360 		i2 = 0;
361 		while (i2 < 16) {
362 			table_dec[(i1 << 4) | i2] |= (sample << 8);
363 			table_dec[(i2 << 4) | i1] |= sample;
364 			i2++;
365 		}
366 		i1++;
367 	}
368 
369 	return 0;
370 }
371