usr.sbin/i4b/g711conv/g711conv.c

   1 /*
   2  *   Copyright (c) 1999 Hellmuth Michaelis. All rights reserved.
   3  *
   4  *   Redistribution and use in source and binary forms, with or without
   5  *   modification, are permitted provided that the following conditions
   6  *   are met:
   7  *
   8  *   1. Redistributions of source code must retain the above copyright
   9  *      notice, this list of conditions and the following disclaimer.
  10  *   2. Redistributions in binary form must reproduce the above copyright
  11  *      notice, this list of conditions and the following disclaimer in the
  12  *      documentation and/or other materials provided with the distribution.
  13  *
  14  *   THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  *   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  *   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  *   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  *   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  *   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  *   SUCH DAMAGE.
  25  *
  26  *   ---
  27  *
  28  *   The A-law to u-law and u-law to A-law conversion routines and tables
  29  *   were taken from the G.711 reference implementation from Sun and freely
  30  *   available as http://www.itu.int/itudoc/itu-t/rec/g/g700-799/refimpl.txt.
  31  *
  32  *   Therefore for that part of the code, the following restrictions apply:
  33  *
  34  *
  35  *   This source code is a product of Sun Microsystems, Inc. and is provided
  36  *   for unrestricted use.  Users may copy or modify this source code without
  37  *   charge.
  38  *
  39  *   SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
  40  *   THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  41  *   PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  42  *
  43  *   Sun source code is provided with no support and without any obligation on
  44  *   the part of Sun Microsystems, Inc. to assist in its use, correction,
  45  *   modification or enhancement.
  46  *
  47  *   SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  48  *   INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
  49  *   OR ANY PART THEREOF.
  50  *
  51  *   In no event will Sun Microsystems, Inc. be liable for any lost revenue
  52  *   or profits or other special, indirect and consequential damages, even if
  53  *   Sun has been advised of the possibility of such damages.
  54  *
  55  *   Sun Microsystems, Inc.
  56  *   2550 Garcia Avenue
  57  *   Mountain View, California  94043
  58  *
  59  *   ---
  60  *
  61  *   The bitreverse table was contributed by Stefan Bethke.
  62  *
  63  *---------------------------------------------------------------------------
  64  *
  65  *      A-law / u-law conversions as specified in G.711
  66  *      -----------------------------------------------
  67  *
  68  *      last edit-date: [Mon Dec 13 21:44:01 1999]
  69  *
  70  *      $Id: g711conv.c,v 1.5 1999/12/13 21:25:24 hm Exp $
  71  *
  72  * $FreeBSD: src/usr.sbin/i4b/g711conv/g711conv.c,v 1.4.2.1 2001/08/01 17:45:02 obrien Exp $
  73  * $DragonFly: src/usr.sbin/i4b/g711conv/g711conv.c,v 1.6 2007/11/25 01:28:24 swildner Exp $
  74  *
  75  *---------------------------------------------------------------------------*/
  76
  77 #include <stdio.h>
  78 #include <stdlib.h>
  79 #include <unistd.h>
  80 #include <i4b_machine/i4b_ioctl.h>
  81
  82 /* copy from CCITT G.711 specifications */
  83
  84 /* u- to A-law conversions */
  85
  86 unsigned char _u2a[128] = {
  87         1,      1,      2,      2,      3,      3,      4,      4,
  88         5,      5,      6,      6,      7,      7,      8,      8,
  89         9,      10,     11,     12,     13,     14,     15,     16,
  90         17,     18,     19,     20,     21,     22,     23,     24,
  91         25,     27,     29,     31,     33,     34,     35,     36,
  92         37,     38,     39,     40,     41,     42,     43,     44,
  93         46,     48,     49,     50,     51,     52,     53,     54,
  94         55,     56,     57,     58,     59,     60,     61,     62,
  95         64,     65,     66,     67,     68,     69,     70,     71,
  96         72,     73,     74,     75,     76,     77,     78,     79,
  97         81,     82,     83,     84,     85,     86,     87,     88,
  98         89,     90,     91,     92,     93,     94,     95,     96,
  99         97,     98,     99,     100,    101,    102,    103,    104,
 100         105,    106,    107,    108,    109,    110,    111,    112,
 101         113,    114,    115,    116,    117,    118,    119,    120,
 102         121,    122,    123,    124,    125,    126,    127,    128
 103 };
 104
 105 /* A- to u-law conversions */
 106
 107 unsigned char _a2u[128] = {
 108         1,      3,      5,      7,      9,      11,     13,     15,
 109         16,     17,     18,     19,     20,     21,     22,     23,
 110         24,     25,     26,     27,     28,     29,     30,     31,
 111         32,     32,     33,     33,     34,     34,     35,     35,
 112         36,     37,     38,     39,     40,     41,     42,     43,
 113         44,     45,     46,     47,     48,     48,     49,     49,
 114         50,     51,     52,     53,     54,     55,     56,     57,
 115         58,     59,     60,     61,     62,     63,     64,     64,
 116         65,     66,     67,     68,     69,     70,     71,     72,
 117         73,     74,     75,     76,     77,     78,     79,     79,
 118         80,     81,     82,     83,     84,     85,     86,     87,
 119         88,     89,     90,     91,     92,     93,     94,     95,
 120         96,     97,     98,     99,     100,    101,    102,    103,
 121         104,    105,    106,    107,    108,    109,    110,    111,
 122         112,    113,    114,    115,    116,    117,    118,    119,
 123         120,    121,    122,    123,    124,    125,    126,    127
 124 };
 125
 126 /* reverse bits (7->0, 6->1, 5->2 etc) for tx to / rx from ISDN */
 127
 128 unsigned char bitreverse[256] = {
 129         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
 130         0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
 131         0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
 132         0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
 133         0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
 134         0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 135         0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
 136         0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
 137         0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 138         0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
 139         0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
 140         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 141         0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
 142         0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
 143         0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 144         0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
 145 };
 146
 147 /* A-law to u-law conversion */
 148
 149 unsigned char
 150 alaw2ulaw(unsigned char aval)
 151 {
 152         aval &= 0xff;
 153         return ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
 154                                 (0x7F ^ _a2u[aval ^ 0x55]));
 155 }
 156
 157 /* u-law to A-law conversion */
 158
 159 unsigned char
 160 ulaw2alaw(unsigned char uval)
 161 {
 162         uval &= 0xff;
 163         return ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
 164                                 (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
 165 }
 166
 167 void
 168 usage(void)
 169 {
 170         fprintf(stderr, "\n");
 171         fprintf(stderr, "g711conv - do conversions according to ITU G.711, (version %d.%d.%d)\n",VERSION, REL, STEP);
 172         fprintf(stderr, "usage: g711conv -a -r -R -u -P\n");
 173         fprintf(stderr, "       -a      A-law to u-law conversion\n");
 174         fprintf(stderr, "       -r      reverse bits before conversion\n");
 175         fprintf(stderr, "       -R      reverse bits after conversion\n");
 176         fprintf(stderr, "       -u      u-law to A-law conversion\n");
 177         fprintf(stderr, "       -P      print conversion table as C source\n");
 178         fprintf(stderr, "\n");
 179         exit(1);
 180 }
 181
 182 int
 183 main(int argc, char **argv)
 184 {
 185         int i;
 186         int c;
 187         int opt_a = 0;
 188         int opt_u = 0;
 189         int opt_r = 0;
 190         int opt_P = 0;
 191         int opt_R = 0;
 192         unsigned char uc;
 193
 194         while ((c = getopt(argc, argv, "aurPR")) != -1)
 195         {
 196                 switch(c)
 197                 {
 198                         case 'a':
 199                                 opt_a = 1;
 200                                 break;
 201
 202                         case 'u':
 203                                 opt_u = 1;
 204                                 break;
 205
 206                         case 'r':
 207                                 opt_r = 1;
 208                                 break;
 209
 210                         case 'R':
 211                                 opt_R = 1;
 212                                 break;
 213
 214                         case 'P':
 215                                 opt_P = 1;
 216                                 break;
 217
 218                         default:
 219                                 usage();
 220                                 break;
 221                 }
 222         }
 223
 224         if((opt_a + opt_u) > 1)
 225                 usage();
 226
 227         if(opt_P)
 228         {
 229                 printf("\n/* ");
 230
 231                 if((opt_a + opt_u) == 0)
 232                         printf("No Conversion");
 233
 234                 if(opt_a)
 235                         printf("A-law to u-law conversion");
 236
 237                 if(opt_u)
 238                         printf("u-law to A-law conversion");
 239
 240                 if(opt_r)
 241                         printf(", reverse bits BEFORE conversion");
 242
 243                 if(opt_R)
 244                         printf(", reverse bits AFTER conversion");
 245
 246                 if(opt_a)
 247                 {
 248                         printf(" */\n\nunsigned char a2u_tab[256] = {");
 249                 }
 250                 else if(opt_u)
 251                 {
 252                         printf(" */\n\nunsigned char u2a_tab[256] = {");
 253                 }
 254                 else
 255                 {
 256                         printf(" */\n\nunsigned char table[256] = {");
 257                 }
 258
 259                 for(i=0; i < 256; i++)
 260                 {
 261                         uc = i;
 262
 263                         if(!(i % 8))
 264                                 printf("\n/* %02x */\t", i);
 265
 266                         if(opt_r)
 267                                 uc = bitreverse[uc];
 268
 269                         if(opt_u)
 270                                 uc = ulaw2alaw(uc);
 271
 272                         if(opt_a)
 273                                 uc = alaw2ulaw(uc);
 274
 275                         if(opt_R)
 276                                 uc = bitreverse[uc];
 277
 278                         if(i == 255)
 279                                 printf("0x%02x", uc);
 280                         else
 281                                 printf("0x%02x, ", uc);
 282                 }
 283                 printf("\n};\n");
 284         }
 285         else
 286         {
 287                 unsigned char ib[1];
 288
 289                 while(fread(ib, 1, 1, stdin) == 1)
 290                 {
 291                         if(opt_r)
 292                                 ib[0] = bitreverse[ib[0]];
 293
 294                         if(opt_u)
 295                                 ib[0] = ulaw2alaw(ib[0]);
 296
 297                         if(opt_a)
 298                                 ib[0] = alaw2ulaw(ib[0]);
 299
 300                         if(opt_R)
 301                                 ib[0] = bitreverse[ib[0]];
 302
 303                         fwrite(ib, 1, 1, stdout);
 304                 }
 305         }
 306         return(0);
 307 }
 308
 309 /* EOF */