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