l1oip_codec.c (10468B)
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 45static u8 *table_com; 46static u16 *table_dec; 47 48 49/* alaw -> ulaw */ 50static 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 */ 87static 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 */ 124static 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 */ 160static 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 */ 166static 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 */ 202static 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 */ 213int 214l1oip_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 */ 250int 251l1oip_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 */ 270int 271l1oip_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 283int 284l1oip_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 */ 300void 301l1oip_4bit_free(void) 302{ 303 vfree(table_dec); 304 vfree(table_com); 305 table_com = NULL; 306 table_dec = NULL; 307} 308 309int 310l1oip_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}