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 "core.h" 52 53 /* definitions of codec. don't use calculations, code may run slower. */ 54 55 static u8 *table_com; 56 static u16 *table_dec; 57 58 59 /* alaw -> ulaw */ 60 static u8 alaw_to_ulaw[256] = 61 { 62 0xab, 0x2b, 0xe3, 0x63, 0x8b, 0x0b, 0xc9, 0x49, 63 0xba, 0x3a, 0xf6, 0x76, 0x9b, 0x1b, 0xd7, 0x57, 64 0xa3, 0x23, 0xdd, 0x5d, 0x83, 0x03, 0xc1, 0x41, 65 0xb2, 0x32, 0xeb, 0x6b, 0x93, 0x13, 0xcf, 0x4f, 66 0xaf, 0x2f, 0xe7, 0x67, 0x8f, 0x0f, 0xcd, 0x4d, 67 0xbe, 0x3e, 0xfe, 0x7e, 0x9f, 0x1f, 0xdb, 0x5b, 68 0xa7, 0x27, 0xdf, 0x5f, 0x87, 0x07, 0xc5, 0x45, 69 0xb6, 0x36, 0xef, 0x6f, 0x97, 0x17, 0xd3, 0x53, 70 0xa9, 0x29, 0xe1, 0x61, 0x89, 0x09, 0xc7, 0x47, 71 0xb8, 0x38, 0xf2, 0x72, 0x99, 0x19, 0xd5, 0x55, 72 0xa1, 0x21, 0xdc, 0x5c, 0x81, 0x01, 0xbf, 0x3f, 73 0xb0, 0x30, 0xe9, 0x69, 0x91, 0x11, 0xce, 0x4e, 74 0xad, 0x2d, 0xe5, 0x65, 0x8d, 0x0d, 0xcb, 0x4b, 75 0xbc, 0x3c, 0xfa, 0x7a, 0x9d, 0x1d, 0xd9, 0x59, 76 0xa5, 0x25, 0xde, 0x5e, 0x85, 0x05, 0xc3, 0x43, 77 0xb4, 0x34, 0xed, 0x6d, 0x95, 0x15, 0xd1, 0x51, 78 0xac, 0x2c, 0xe4, 0x64, 0x8c, 0x0c, 0xca, 0x4a, 79 0xbb, 0x3b, 0xf8, 0x78, 0x9c, 0x1c, 0xd8, 0x58, 80 0xa4, 0x24, 0xde, 0x5e, 0x84, 0x04, 0xc2, 0x42, 81 0xb3, 0x33, 0xec, 0x6c, 0x94, 0x14, 0xd0, 0x50, 82 0xb0, 0x30, 0xe8, 0x68, 0x90, 0x10, 0xce, 0x4e, 83 0xbf, 0x3f, 0xfe, 0x7e, 0xa0, 0x20, 0xdc, 0x5c, 84 0xa8, 0x28, 0xe0, 0x60, 0x88, 0x08, 0xc6, 0x46, 85 0xb7, 0x37, 0xf0, 0x70, 0x98, 0x18, 0xd4, 0x54, 86 0xaa, 0x2a, 0xe2, 0x62, 0x8a, 0x0a, 0xc8, 0x48, 87 0xb9, 0x39, 0xf4, 0x74, 0x9a, 0x1a, 0xd6, 0x56, 88 0xa2, 0x22, 0xdd, 0x5d, 0x82, 0x02, 0xc0, 0x40, 89 0xb1, 0x31, 0xea, 0x6a, 0x92, 0x12, 0xcf, 0x4f, 90 0xae, 0x2e, 0xe6, 0x66, 0x8e, 0x0e, 0xcc, 0x4c, 91 0xbd, 0x3d, 0xfc, 0x7c, 0x9e, 0x1e, 0xda, 0x5a, 92 0xa6, 0x26, 0xdf, 0x5f, 0x86, 0x06, 0xc4, 0x44, 93 0xb5, 0x35, 0xee, 0x6e, 0x96, 0x16, 0xd2, 0x52 94 }; 95 96 /* ulaw -> alaw */ 97 static u8 ulaw_to_alaw[256] = 98 { 99 0xab, 0x55, 0xd5, 0x15, 0x95, 0x75, 0xf5, 0x35, 100 0xb5, 0x45, 0xc5, 0x05, 0x85, 0x65, 0xe5, 0x25, 101 0xa5, 0x5d, 0xdd, 0x1d, 0x9d, 0x7d, 0xfd, 0x3d, 102 0xbd, 0x4d, 0xcd, 0x0d, 0x8d, 0x6d, 0xed, 0x2d, 103 0xad, 0x51, 0xd1, 0x11, 0x91, 0x71, 0xf1, 0x31, 104 0xb1, 0x41, 0xc1, 0x01, 0x81, 0x61, 0xe1, 0x21, 105 0x59, 0xd9, 0x19, 0x99, 0x79, 0xf9, 0x39, 0xb9, 106 0x49, 0xc9, 0x09, 0x89, 0x69, 0xe9, 0x29, 0xa9, 107 0xd7, 0x17, 0x97, 0x77, 0xf7, 0x37, 0xb7, 0x47, 108 0xc7, 0x07, 0x87, 0x67, 0xe7, 0x27, 0xa7, 0xdf, 109 0x9f, 0x7f, 0xff, 0x3f, 0xbf, 0x4f, 0xcf, 0x0f, 110 0x8f, 0x6f, 0xef, 0x2f, 0x53, 0x13, 0x73, 0x33, 111 0xb3, 0x43, 0xc3, 0x03, 0x83, 0x63, 0xe3, 0x23, 112 0xa3, 0x5b, 0xdb, 0x1b, 0x9b, 0x7b, 0xfb, 0x3b, 113 0xbb, 0xbb, 0x4b, 0x4b, 0xcb, 0xcb, 0x0b, 0x0b, 114 0x8b, 0x8b, 0x6b, 0x6b, 0xeb, 0xeb, 0x2b, 0x2b, 115 0xab, 0x54, 0xd4, 0x14, 0x94, 0x74, 0xf4, 0x34, 116 0xb4, 0x44, 0xc4, 0x04, 0x84, 0x64, 0xe4, 0x24, 117 0xa4, 0x5c, 0xdc, 0x1c, 0x9c, 0x7c, 0xfc, 0x3c, 118 0xbc, 0x4c, 0xcc, 0x0c, 0x8c, 0x6c, 0xec, 0x2c, 119 0xac, 0x50, 0xd0, 0x10, 0x90, 0x70, 0xf0, 0x30, 120 0xb0, 0x40, 0xc0, 0x00, 0x80, 0x60, 0xe0, 0x20, 121 0x58, 0xd8, 0x18, 0x98, 0x78, 0xf8, 0x38, 0xb8, 122 0x48, 0xc8, 0x08, 0x88, 0x68, 0xe8, 0x28, 0xa8, 123 0xd6, 0x16, 0x96, 0x76, 0xf6, 0x36, 0xb6, 0x46, 124 0xc6, 0x06, 0x86, 0x66, 0xe6, 0x26, 0xa6, 0xde, 125 0x9e, 0x7e, 0xfe, 0x3e, 0xbe, 0x4e, 0xce, 0x0e, 126 0x8e, 0x6e, 0xee, 0x2e, 0x52, 0x12, 0x72, 0x32, 127 0xb2, 0x42, 0xc2, 0x02, 0x82, 0x62, 0xe2, 0x22, 128 0xa2, 0x5a, 0xda, 0x1a, 0x9a, 0x7a, 0xfa, 0x3a, 129 0xba, 0xba, 0x4a, 0x4a, 0xca, 0xca, 0x0a, 0x0a, 130 0x8a, 0x8a, 0x6a, 0x6a, 0xea, 0xea, 0x2a, 0x2a 131 }; 132 133 /* alaw -> 4bit compression */ 134 static u8 alaw_to_4bit[256] = { 135 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 136 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 137 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 138 0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 139 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 140 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 141 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 142 0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 143 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 144 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 145 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0d, 0x02, 146 0x0e, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 147 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 148 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 149 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 150 0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 151 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 152 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 153 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 154 0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 155 0x0e, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 156 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x01, 0x0a, 0x05, 157 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 158 0x0d, 0x02, 0x09, 0x07, 0x0f, 0x00, 0x0b, 0x04, 159 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 160 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 161 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 162 0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 163 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 164 0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04, 165 0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03, 166 0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04, 167 }; 168 169 /* 4bit -> alaw decompression */ 170 static u8 _4bit_to_alaw[16] = { 171 0x5d, 0x51, 0xd9, 0xd7, 0x5f, 0x53, 0xa3, 0x4b, 172 0x2a, 0x3a, 0x22, 0x2e, 0x26, 0x56, 0x20, 0x2c, 173 }; 174 175 /* ulaw -> 4bit compression */ 176 static u8 ulaw_to_4bit[256] = { 177 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 179 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 180 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 181 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 182 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 183 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 184 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 185 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 186 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 187 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 188 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 189 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 190 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 191 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 192 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 193 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 194 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 195 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 196 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 197 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 198 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 199 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 200 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 201 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 202 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 203 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 204 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 205 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 206 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 207 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 208 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 209 }; 210 211 /* 4bit -> ulaw decompression */ 212 static u8 _4bit_to_ulaw[16] = { 213 0x11, 0x21, 0x31, 0x40, 0x4e, 0x5c, 0x68, 0x71, 214 0xfe, 0xef, 0xe7, 0xdb, 0xcd, 0xbf, 0xaf, 0x9f, 215 }; 216 217 218 /* 219 * Compresses data to the result buffer 220 * The result size must be at least half of the input buffer. 221 * The number of samples also must be even! 222 */ 223 int 224 l1oip_law_to_4bit(u8 *data, int len, u8 *result, u32 *state) 225 { 226 int ii, i = 0, o = 0; 227 228 if (!len) 229 return 0; 230 231 /* send saved byte and first input byte */ 232 if (*state) { 233 *result++ = table_com[(((*state)<<8)&0xff00) | (*data++)]; 234 len--; 235 o++; 236 } 237 238 ii = len >> 1; 239 240 while (i < ii) { 241 *result++ = table_com[(data[0]<<8) | (data[1])]; 242 data += 2; 243 i++; 244 o++; 245 } 246 247 /* if len has an odd number, we save byte for next call */ 248 if (len & 1) 249 *state = 0x100 + *data; 250 else 251 *state = 0; 252 253 return o; 254 } 255 256 /* Decompress data to the result buffer 257 * The result size must be the number of sample in packet. (2 * input data) 258 * The number of samples in the result are even! 259 */ 260 int 261 l1oip_4bit_to_law(u8 *data, int len, u8 *result) 262 { 263 int i = 0; 264 u16 r; 265 266 while (i < len) { 267 r = table_dec[*data++]; 268 *result++ = r>>8; 269 *result++ = r; 270 i++; 271 } 272 273 return len << 1; 274 } 275 276 277 /* 278 * law conversion 279 */ 280 int 281 l1oip_alaw_to_ulaw(u8 *data, int len, u8 *result) 282 { 283 int i = 0; 284 285 while (i < len) { 286 *result++ = alaw_to_ulaw[*data++]; 287 i++; 288 } 289 290 return len; 291 } 292 293 int 294 l1oip_ulaw_to_alaw(u8 *data, int len, u8 *result) 295 { 296 int i = 0; 297 298 while (i < len) { 299 *result++ = ulaw_to_alaw[*data++]; 300 i++; 301 } 302 303 return len; 304 } 305 306 307 /* 308 * generate/free compression and decompression table 309 */ 310 void 311 l1oip_4bit_free(void) 312 { 313 if (table_dec) 314 vfree(table_dec); 315 if (table_com) 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 = vmalloc(65536); 332 table_dec = vmalloc(512); 333 if (!table_com | !table_dec) { 334 l1oip_4bit_free(); 335 return -ENOMEM; 336 } 337 memset(table_com, 0, 65536); 338 memset(table_dec, 0, 512); 339 /* generate compression table */ 340 i1 = 0; 341 while (i1 < 256) { 342 if (ulaw) 343 c = ulaw_to_4bit[i1]; 344 else 345 c = alaw_to_4bit[i1]; 346 i2 = 0; 347 while (i2 < 256) { 348 table_com[(i1<<8) | i2] |= (c<<4); 349 table_com[(i2<<8) | i1] |= c; 350 i2++; 351 } 352 i1++; 353 } 354 355 /* generate decompression table */ 356 i1 = 0; 357 while (i1 < 16) { 358 if (ulaw) 359 sample = _4bit_to_ulaw[i1]; 360 else 361 sample = _4bit_to_alaw[i1]; 362 i2 = 0; 363 while (i2 < 16) { 364 table_dec[(i1<<4) | i2] |= (sample<<8); 365 table_dec[(i2<<4) | i1] |= sample; 366 i2++; 367 } 368 i1++; 369 } 370 371 return 0; 372 } 373 374 375