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 "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