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.5 2005/11/25 00:58:52 swildner Exp $
  74  *
  75  *---------------------------------------------------------------------------*/
  76
  77 #include <stdio.h>
  78 #include <unistd.h>
  79 #include <i4b_machine/i4b_ioctl.h>
  80
  81 /* copy from CCITT G.711 specifications */
  82
  83 /* u- to A-law conversions */
  84
  85 unsigned char _u2a[128] = {
  86         1,      1,      2,      2,      3,      3,      4,      4,
  87         5,      5,      6,      6,      7,      7,      8,      8,
  88         9,      10,     11,     12,     13,     14,     15,     16,
  89         17,     18,     19,     20,     21,     22,     23,     24,
  90         25,     27,     29,     31,     33,     34,     35,     36,
  91         37,     38,     39,     40,     41,     42,     43,     44,
  92         46,     48,     49,     50,     51,     52,     53,     54,
  93         55,     56,     57,     58,     59,     60,     61,     62,
  94         64,     65,     66,     67,     68,     69,     70,     71,
  95         72,     73,     74,     75,     76,     77,     78,     79,
  96         81,     82,     83,     84,     85,     86,     87,     88,
  97         89,     90,     91,     92,     93,     94,     95,     96,
  98         97,     98,     99,     100,    101,    102,    103,    104,
  99         105,    106,    107,    108,    109,    110,    111,    112,
 100         113,    114,    115,    116,    117,    118,    119,    120,
 101         121,    122,    123,    124,    125,    126,    127,    128
 102 };
 103
 104 /* A- to u-law conversions */
 105
 106 unsigned char _a2u[128] = {
 107         1,      3,      5,      7,      9,      11,     13,     15,
 108         16,     17,     18,     19,     20,     21,     22,     23,
 109         24,     25,     26,     27,     28,     29,     30,     31,
 110         32,     32,     33,     33,     34,     34,     35,     35,
 111         36,     37,     38,     39,     40,     41,     42,     43,
 112         44,     45,     46,     47,     48,     48,     49,     49,
 113         50,     51,     52,     53,     54,     55,     56,     57,
 114         58,     59,     60,     61,     62,     63,     64,     64,
 115         65,     66,     67,     68,     69,     70,     71,     72,
 116         73,     74,     75,     76,     77,     78,     79,     79,
 117         80,     81,     82,     83,     84,     85,     86,     87,
 118         88,     89,     90,     91,     92,     93,     94,     95,
 119         96,     97,     98,     99,     100,    101,    102,    103,
 120         104,    105,    106,    107,    108,    109,    110,    111,
 121         112,    113,    114,    115,    116,    117,    118,    119,
 122         120,    121,    122,    123,    124,    125,    126,    127
 123 };
 124
 125 /* reverse bits (7->0, 6->1, 5->2 etc) for tx to / rx from ISDN */
 126
 127 unsigned char bitreverse[256] = {
 128         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
 129         0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
 130         0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
 131         0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
 132         0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
 133         0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 134         0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
 135         0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
 136         0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 137         0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
 138         0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
 139         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 140         0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
 141         0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
 142         0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 143         0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
 144 };
 145
 146 /* A-law to u-law conversion */
 147
 148 unsigned char
 149 alaw2ulaw(unsigned char aval)
 150 {
 151         aval &= 0xff;
 152         return ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
 153                                 (0x7F ^ _a2u[aval ^ 0x55]));
 154 }
 155
 156 /* u-law to A-law conversion */
 157
 158 unsigned char
 159 ulaw2alaw(unsigned char uval)
 160 {
 161         uval &= 0xff;
 162         return ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
 163                                 (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
 164 }
 165
 166 void
 167 usage(void)
 168 {
 169         fprintf(stderr, "\n");
 170         fprintf(stderr, "g711conv - do conversions according to ITU G.711, (version %d.%d.%d)\n",VERSION, REL, STEP);
 171         fprintf(stderr, "usage: g711conv -a -r -R -u -P\n");
 172         fprintf(stderr, "       -a      A-law to u-law conversion\n");
 173         fprintf(stderr, "       -r      reverse bits before conversion\n");
 174         fprintf(stderr, "       -R      reverse bits after conversion\n");
 175         fprintf(stderr, "       -u      u-law to A-law conversion\n");
 176         fprintf(stderr, "       -P      print conversion table as C source\n");
 177         fprintf(stderr, "\n");
 178         exit(1);
 179 }
 180
 181 int
 182 main(int argc, char **argv)
 183 {
 184         int i;
 185         int c;
 186         int opt_a = 0;
 187         int opt_u = 0;
 188         int opt_r = 0;
 189         int opt_P = 0;
 190         int opt_R = 0;
 191         unsigned char uc;
 192
 193         while ((c = getopt(argc, argv, "aurPR")) != -1)
 194         {
 195                 switch(c)
 196                 {
 197                         case 'a':
 198                                 opt_a = 1;
 199                                 break;
 200
 201                         case 'u':
 202                                 opt_u = 1;
 203                                 break;
 204
 205                         case 'r':
 206                                 opt_r = 1;
 207                                 break;
 208
 209                         case 'R':
 210                                 opt_R = 1;
 211                                 break;
 212
 213                         case 'P':
 214                                 opt_P = 1;
 215                                 break;
 216
 217                         default:
 218                                 usage();
 219                                 break;
 220                 }
 221         }
 222
 223         if((opt_a + opt_u) > 1)
 224                 usage();
 225
 226         if(opt_P)
 227         {
 228                 printf("\n/* ");
 229
 230                 if((opt_a + opt_u) == 0)
 231                         printf("No Conversion");
 232
 233                 if(opt_a)
 234                         printf("A-law to u-law conversion");
 235
 236                 if(opt_u)
 237                         printf("u-law to A-law conversion");
 238
 239                 if(opt_r)
 240                         printf(", reverse bits BEFORE conversion");
 241
 242                 if(opt_R)
 243                         printf(", reverse bits AFTER conversion");
 244
 245                 if(opt_a)
 246                 {
 247                         printf(" */\n\nunsigned char a2u_tab[256] = {");
 248                 }
 249                 else if(opt_u)
 250                 {
 251                         printf(" */\n\nunsigned char u2a_tab[256] = {");
 252                 }
 253                 else
 254                 {
 255                         printf(" */\n\nunsigned char table[256] = {");
 256                 }
 257
 258                 for(i=0; i < 256; i++)
 259                 {
 260                         uc = i;
 261
 262                         if(!(i % 8))
 263                                 printf("\n/* %02x */\t", i);
 264
 265                         if(opt_r)
 266                                 uc = bitreverse[uc];
 267
 268                         if(opt_u)
 269                                 uc = ulaw2alaw(uc);
 270
 271                         if(opt_a)
 272                                 uc = alaw2ulaw(uc);
 273
 274                         if(opt_R)
 275                                 uc = bitreverse[uc];
 276
 277                         if(i == 255)
 278                                 printf("0x%02x", uc);
 279                         else
 280                                 printf("0x%02x, ", uc);
 281                 }
 282                 printf("\n};\n");
 283         }
 284         else
 285         {
 286                 unsigned char ib[1];
 287
 288                 while(fread(ib, 1, 1, stdin) == 1)
 289                 {
 290                         if(opt_r)
 291                                 ib[0] = bitreverse[ib[0]];
 292
 293                         if(opt_u)
 294                                 ib[0] = ulaw2alaw(ib[0]);
 295
 296                         if(opt_a)
 297                                 ib[0] = alaw2ulaw(ib[0]);
 298
 299                         if(opt_R)
 300                                 ib[0] = bitreverse[ib[0]];
 301
 302                         fwrite(ib, 1, 1, stdout);
 303                 }
 304         }
 305         return(0);
 306 }
 307
 308 /* EOF */