drivers/isdn/mISDN/l1oip_codec.c

   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         if (table_dec)
 316                 vfree(table_dec);
 317         if (table_com)
 318                 vfree(table_com);
 319         table_com = NULL;
 320         table_dec = NULL;
 321 }
 322
 323 int
 324 l1oip_4bit_alloc(int ulaw)
 325 {
 326         int i1, i2, c, sample;
 327
 328         /* in case, it is called again */
 329         if (table_dec)
 330                 return 0;
 331
 332         /* alloc conversion tables */
 333         table_com = vzalloc(65536);
 334         table_dec = vzalloc(512);
 335         if (!table_com || !table_dec) {
 336                 l1oip_4bit_free();
 337                 return -ENOMEM;
 338         }
 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