root/dev/mulaw.c

DEFINITIONS

1. mulaw_to_ulinear8
2. mulaw_to_slinear8
3. mulaw_to_ulinear16_le
4. mulaw_to_ulinear16_be
5. mulaw_to_slinear16_le
6. mulaw_to_slinear16_le_mts
7. mulaw_to_slinear16_be
8. mulaw_to_slinear16_be_mts
9. slinear16_to_mulaw_le
10. ulinear8_to_mulaw
11. slinear8_to_mulaw
12. alaw_to_ulinear8
13. alaw_to_slinear8
14. alaw_to_ulinear16_le
15. alaw_to_ulinear16_be
16. alaw_to_slinear16_le
17. alaw_to_slinear16_be
18. ulinear8_to_alaw
19. slinear8_to_alaw
20. slinear16_to_alaw_le
21. slinear16_to_alaw_be
22. mulaw_to_ulinear16_le_mts
23. mulaw_to_ulinear16_be_mts
24. alaw_to_slinear16_le_mts
25. alaw_to_slinear16_be_mts
26. alaw_to_mulaw
27. mulaw_to_alaw

    1 /*      $OpenBSD: mulaw.c,v 1.13 2007/07/17 08:35:33 jakemsr Exp $ */
    2 /*      $NetBSD: mulaw.c,v 1.15 2001/01/18 20:28:20 jdolecek Exp $      */
    4 /*
    5  * Copyright (c) 1991-1993 Regents of the University of California.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. All advertising materials mentioning features or use of this software
   17  *    must display the following acknowledgement:
   18  *      This product includes software developed by the Computer Systems
   19  *      Engineering Group at Lawrence Berkeley Laboratory.
   20  * 4. Neither the name of the University nor of the Laboratory may be used
   21  *    to endorse or promote products derived from this software without
   22  *    specific prior written permission.
   23  *
   24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   34  * SUCH DAMAGE.
   35  *
   36  */
   38 #include <sys/types.h>
   39 #include <sys/audioio.h>
   40 #include <dev/mulaw.h>
   42 /*
   43  * This table converts a (8 bit) mu-law value two a 16 bit value.
   44  * The 16 bits are represented as an array of two bytes for easier access
   45  * to the individual bytes.
   46  */
   47 static const u_char mulawtolin16[256][2] = {
   48         {0x02,0x84}, {0x06,0x84}, {0x0a,0x84}, {0x0e,0x84},
   49         {0x12,0x84}, {0x16,0x84}, {0x1a,0x84}, {0x1e,0x84},
   50         {0x22,0x84}, {0x26,0x84}, {0x2a,0x84}, {0x2e,0x84},
   51         {0x32,0x84}, {0x36,0x84}, {0x3a,0x84}, {0x3e,0x84},
   52         {0x41,0x84}, {0x43,0x84}, {0x45,0x84}, {0x47,0x84},
   53         {0x49,0x84}, {0x4b,0x84}, {0x4d,0x84}, {0x4f,0x84},
   54         {0x51,0x84}, {0x53,0x84}, {0x55,0x84}, {0x57,0x84},
   55         {0x59,0x84}, {0x5b,0x84}, {0x5d,0x84}, {0x5f,0x84},
   56         {0x61,0x04}, {0x62,0x04}, {0x63,0x04}, {0x64,0x04},
   57         {0x65,0x04}, {0x66,0x04}, {0x67,0x04}, {0x68,0x04},
   58         {0x69,0x04}, {0x6a,0x04}, {0x6b,0x04}, {0x6c,0x04},
   59         {0x6d,0x04}, {0x6e,0x04}, {0x6f,0x04}, {0x70,0x04},
   60         {0x70,0xc4}, {0x71,0x44}, {0x71,0xc4}, {0x72,0x44},
   61         {0x72,0xc4}, {0x73,0x44}, {0x73,0xc4}, {0x74,0x44},
   62         {0x74,0xc4}, {0x75,0x44}, {0x75,0xc4}, {0x76,0x44},
   63         {0x76,0xc4}, {0x77,0x44}, {0x77,0xc4}, {0x78,0x44},
   64         {0x78,0xa4}, {0x78,0xe4}, {0x79,0x24}, {0x79,0x64},
   65         {0x79,0xa4}, {0x79,0xe4}, {0x7a,0x24}, {0x7a,0x64},
   66         {0x7a,0xa4}, {0x7a,0xe4}, {0x7b,0x24}, {0x7b,0x64},
   67         {0x7b,0xa4}, {0x7b,0xe4}, {0x7c,0x24}, {0x7c,0x64},
   68         {0x7c,0x94}, {0x7c,0xb4}, {0x7c,0xd4}, {0x7c,0xf4},
   69         {0x7d,0x14}, {0x7d,0x34}, {0x7d,0x54}, {0x7d,0x74},
   70         {0x7d,0x94}, {0x7d,0xb4}, {0x7d,0xd4}, {0x7d,0xf4},
   71         {0x7e,0x14}, {0x7e,0x34}, {0x7e,0x54}, {0x7e,0x74},
   72         {0x7e,0x8c}, {0x7e,0x9c}, {0x7e,0xac}, {0x7e,0xbc},
   73         {0x7e,0xcc}, {0x7e,0xdc}, {0x7e,0xec}, {0x7e,0xfc},
   74         {0x7f,0x0c}, {0x7f,0x1c}, {0x7f,0x2c}, {0x7f,0x3c},
   75         {0x7f,0x4c}, {0x7f,0x5c}, {0x7f,0x6c}, {0x7f,0x7c},
   76         {0x7f,0x88}, {0x7f,0x90}, {0x7f,0x98}, {0x7f,0xa0},
   77         {0x7f,0xa8}, {0x7f,0xb0}, {0x7f,0xb8}, {0x7f,0xc0},
   78         {0x7f,0xc8}, {0x7f,0xd0}, {0x7f,0xd8}, {0x7f,0xe0},
   79         {0x7f,0xe8}, {0x7f,0xf0}, {0x7f,0xf8}, {0x80,0x00},
   80         {0xfd,0x7c}, {0xf9,0x7c}, {0xf5,0x7c}, {0xf1,0x7c},
   81         {0xed,0x7c}, {0xe9,0x7c}, {0xe5,0x7c}, {0xe1,0x7c},
   82         {0xdd,0x7c}, {0xd9,0x7c}, {0xd5,0x7c}, {0xd1,0x7c},
   83         {0xcd,0x7c}, {0xc9,0x7c}, {0xc5,0x7c}, {0xc1,0x7c},
   84         {0xbe,0x7c}, {0xbc,0x7c}, {0xba,0x7c}, {0xb8,0x7c},
   85         {0xb6,0x7c}, {0xb4,0x7c}, {0xb2,0x7c}, {0xb0,0x7c},
   86         {0xae,0x7c}, {0xac,0x7c}, {0xaa,0x7c}, {0xa8,0x7c},
   87         {0xa6,0x7c}, {0xa4,0x7c}, {0xa2,0x7c}, {0xa0,0x7c},
   88         {0x9e,0xfc}, {0x9d,0xfc}, {0x9c,0xfc}, {0x9b,0xfc},
   89         {0x9a,0xfc}, {0x99,0xfc}, {0x98,0xfc}, {0x97,0xfc},
   90         {0x96,0xfc}, {0x95,0xfc}, {0x94,0xfc}, {0x93,0xfc},
   91         {0x92,0xfc}, {0x91,0xfc}, {0x90,0xfc}, {0x8f,0xfc},
   92         {0x8f,0x3c}, {0x8e,0xbc}, {0x8e,0x3c}, {0x8d,0xbc},
   93         {0x8d,0x3c}, {0x8c,0xbc}, {0x8c,0x3c}, {0x8b,0xbc},
   94         {0x8b,0x3c}, {0x8a,0xbc}, {0x8a,0x3c}, {0x89,0xbc},
   95         {0x89,0x3c}, {0x88,0xbc}, {0x88,0x3c}, {0x87,0xbc},
   96         {0x87,0x5c}, {0x87,0x1c}, {0x86,0xdc}, {0x86,0x9c},
   97         {0x86,0x5c}, {0x86,0x1c}, {0x85,0xdc}, {0x85,0x9c},
   98         {0x85,0x5c}, {0x85,0x1c}, {0x84,0xdc}, {0x84,0x9c},
   99         {0x84,0x5c}, {0x84,0x1c}, {0x83,0xdc}, {0x83,0x9c},
  100         {0x83,0x6c}, {0x83,0x4c}, {0x83,0x2c}, {0x83,0x0c},
  101         {0x82,0xec}, {0x82,0xcc}, {0x82,0xac}, {0x82,0x8c},
  102         {0x82,0x6c}, {0x82,0x4c}, {0x82,0x2c}, {0x82,0x0c},
  103         {0x81,0xec}, {0x81,0xcc}, {0x81,0xac}, {0x81,0x8c},
  104         {0x81,0x74}, {0x81,0x64}, {0x81,0x54}, {0x81,0x44},
  105         {0x81,0x34}, {0x81,0x24}, {0x81,0x14}, {0x81,0x04},
  106         {0x80,0xf4}, {0x80,0xe4}, {0x80,0xd4}, {0x80,0xc4},
  107         {0x80,0xb4}, {0x80,0xa4}, {0x80,0x94}, {0x80,0x84},
  108         {0x80,0x78}, {0x80,0x70}, {0x80,0x68}, {0x80,0x60},
  109         {0x80,0x58}, {0x80,0x50}, {0x80,0x48}, {0x80,0x40},
  110         {0x80,0x38}, {0x80,0x30}, {0x80,0x28}, {0x80,0x20},
  111         {0x80,0x18}, {0x80,0x10}, {0x80,0x08}, {0x80,0x00},
  112 };
  114 static const u_char lintomulaw[256] = {
  115         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
  116         0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,
  117         0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05,
  118         0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07,
  119         0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
  120         0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b,
  121         0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d,
  122         0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f,
  123         0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13,
  124         0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17,
  125         0x17, 0x18, 0x18, 0x19, 0x19, 0x1a, 0x1a, 0x1b,
  126         0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f,
  127         0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
  128         0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
  129         0x2f, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c,
  130         0x3e, 0x41, 0x45, 0x49, 0x4d, 0x53, 0x5b, 0x67,
  131         0xff, 0xe7, 0xdb, 0xd3, 0xcd, 0xc9, 0xc5, 0xc1,
  132         0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, 0xb2, 0xb0,
  133         0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
  134         0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
  135         0x9f, 0x9f, 0x9e, 0x9e, 0x9d, 0x9d, 0x9c, 0x9c,
  136         0x9b, 0x9b, 0x9a, 0x9a, 0x99, 0x99, 0x98, 0x98,
  137         0x97, 0x97, 0x96, 0x96, 0x95, 0x95, 0x94, 0x94,
  138         0x93, 0x93, 0x92, 0x92, 0x91, 0x91, 0x90, 0x90,
  139         0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e,
  140         0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c,
  141         0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a,
  142         0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88,
  143         0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86,
  144         0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84,
  145         0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
  146         0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80,
  147 };
  149 static const u_char alawtolin16[256][2] = {
  150         {0x6a,0x80}, {0x6b,0x80}, {0x68,0x80}, {0x69,0x80},
  151         {0x6e,0x80}, {0x6f,0x80}, {0x6c,0x80}, {0x6d,0x80},
  152         {0x62,0x80}, {0x63,0x80}, {0x60,0x80}, {0x61,0x80},
  153         {0x66,0x80}, {0x67,0x80}, {0x64,0x80}, {0x65,0x80},
  154         {0x75,0x40}, {0x75,0xc0}, {0x74,0x40}, {0x74,0xc0},
  155         {0x77,0x40}, {0x77,0xc0}, {0x76,0x40}, {0x76,0xc0},
  156         {0x71,0x40}, {0x71,0xc0}, {0x70,0x40}, {0x70,0xc0},
  157         {0x73,0x40}, {0x73,0xc0}, {0x72,0x40}, {0x72,0xc0},
  158         {0x2a,0x00}, {0x2e,0x00}, {0x22,0x00}, {0x26,0x00},
  159         {0x3a,0x00}, {0x3e,0x00}, {0x32,0x00}, {0x36,0x00},
  160         {0x0a,0x00}, {0x0e,0x00}, {0x02,0x00}, {0x06,0x00},
  161         {0x1a,0x00}, {0x1e,0x00}, {0x12,0x00}, {0x16,0x00},
  162         {0x55,0x00}, {0x57,0x00}, {0x51,0x00}, {0x53,0x00},
  163         {0x5d,0x00}, {0x5f,0x00}, {0x59,0x00}, {0x5b,0x00},
  164         {0x45,0x00}, {0x47,0x00}, {0x41,0x00}, {0x43,0x00},
  165         {0x4d,0x00}, {0x4f,0x00}, {0x49,0x00}, {0x4b,0x00},
  166         {0x7e,0xa8}, {0x7e,0xb8}, {0x7e,0x88}, {0x7e,0x98},
  167         {0x7e,0xe8}, {0x7e,0xf8}, {0x7e,0xc8}, {0x7e,0xd8},
  168         {0x7e,0x28}, {0x7e,0x38}, {0x7e,0x08}, {0x7e,0x18},
  169         {0x7e,0x68}, {0x7e,0x78}, {0x7e,0x48}, {0x7e,0x58},
  170         {0x7f,0xa8}, {0x7f,0xb8}, {0x7f,0x88}, {0x7f,0x98},
  171         {0x7f,0xe8}, {0x7f,0xf8}, {0x7f,0xc8}, {0x7f,0xd8},
  172         {0x7f,0x28}, {0x7f,0x38}, {0x7f,0x08}, {0x7f,0x18},
  173         {0x7f,0x68}, {0x7f,0x78}, {0x7f,0x48}, {0x7f,0x58},
  174         {0x7a,0xa0}, {0x7a,0xe0}, {0x7a,0x20}, {0x7a,0x60},
  175         {0x7b,0xa0}, {0x7b,0xe0}, {0x7b,0x20}, {0x7b,0x60},
  176         {0x78,0xa0}, {0x78,0xe0}, {0x78,0x20}, {0x78,0x60},
  177         {0x79,0xa0}, {0x79,0xe0}, {0x79,0x20}, {0x79,0x60},
  178         {0x7d,0x50}, {0x7d,0x70}, {0x7d,0x10}, {0x7d,0x30},
  179         {0x7d,0xd0}, {0x7d,0xf0}, {0x7d,0x90}, {0x7d,0xb0},
  180         {0x7c,0x50}, {0x7c,0x70}, {0x7c,0x10}, {0x7c,0x30},
  181         {0x7c,0xd0}, {0x7c,0xf0}, {0x7c,0x90}, {0x7c,0xb0},
  182         {0x95,0x80}, {0x94,0x80}, {0x97,0x80}, {0x96,0x80},
  183         {0x91,0x80}, {0x90,0x80}, {0x93,0x80}, {0x92,0x80},
  184         {0x9d,0x80}, {0x9c,0x80}, {0x9f,0x80}, {0x9e,0x80},
  185         {0x99,0x80}, {0x98,0x80}, {0x9b,0x80}, {0x9a,0x80},
  186         {0x8a,0xc0}, {0x8a,0x40}, {0x8b,0xc0}, {0x8b,0x40},
  187         {0x88,0xc0}, {0x88,0x40}, {0x89,0xc0}, {0x89,0x40},
  188         {0x8e,0xc0}, {0x8e,0x40}, {0x8f,0xc0}, {0x8f,0x40},
  189         {0x8c,0xc0}, {0x8c,0x40}, {0x8d,0xc0}, {0x8d,0x40},
  190         {0xd6,0x00}, {0xd2,0x00}, {0xde,0x00}, {0xda,0x00},
  191         {0xc6,0x00}, {0xc2,0x00}, {0xce,0x00}, {0xca,0x00},
  192         {0xf6,0x00}, {0xf2,0x00}, {0xfe,0x00}, {0xfa,0x00},
  193         {0xe6,0x00}, {0xe2,0x00}, {0xee,0x00}, {0xea,0x00},
  194         {0xab,0x00}, {0xa9,0x00}, {0xaf,0x00}, {0xad,0x00},
  195         {0xa3,0x00}, {0xa1,0x00}, {0xa7,0x00}, {0xa5,0x00},
  196         {0xbb,0x00}, {0xb9,0x00}, {0xbf,0x00}, {0xbd,0x00},
  197         {0xb3,0x00}, {0xb1,0x00}, {0xb7,0x00}, {0xb5,0x00},
  198         {0x81,0x58}, {0x81,0x48}, {0x81,0x78}, {0x81,0x68},
  199         {0x81,0x18}, {0x81,0x08}, {0x81,0x38}, {0x81,0x28},
  200         {0x81,0xd8}, {0x81,0xc8}, {0x81,0xf8}, {0x81,0xe8},
  201         {0x81,0x98}, {0x81,0x88}, {0x81,0xb8}, {0x81,0xa8},
  202         {0x80,0x58}, {0x80,0x48}, {0x80,0x78}, {0x80,0x68},
  203         {0x80,0x18}, {0x80,0x08}, {0x80,0x38}, {0x80,0x28},
  204         {0x80,0xd8}, {0x80,0xc8}, {0x80,0xf8}, {0x80,0xe8},
  205         {0x80,0x98}, {0x80,0x88}, {0x80,0xb8}, {0x80,0xa8},
  206         {0x85,0x60}, {0x85,0x20}, {0x85,0xe0}, {0x85,0xa0},
  207         {0x84,0x60}, {0x84,0x20}, {0x84,0xe0}, {0x84,0xa0},
  208         {0x87,0x60}, {0x87,0x20}, {0x87,0xe0}, {0x87,0xa0},
  209         {0x86,0x60}, {0x86,0x20}, {0x86,0xe0}, {0x86,0xa0},
  210         {0x82,0xb0}, {0x82,0x90}, {0x82,0xf0}, {0x82,0xd0},
  211         {0x82,0x30}, {0x82,0x10}, {0x82,0x70}, {0x82,0x50},
  212         {0x83,0xb0}, {0x83,0x90}, {0x83,0xf0}, {0x83,0xd0},
  213         {0x83,0x30}, {0x83,0x10}, {0x83,0x70}, {0x83,0x50},
  214 };
  216 static const u_char lintoalaw[256] = {
  217         0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b,
  218         0x28, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29,
  219         0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f,
  220         0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d,
  221         0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23,
  222         0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21,
  223         0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27,
  224         0x24, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x25,
  225         0x3a, 0x3a, 0x3b, 0x3b, 0x38, 0x38, 0x39, 0x39,
  226         0x3e, 0x3e, 0x3f, 0x3f, 0x3c, 0x3c, 0x3d, 0x3d,
  227         0x32, 0x32, 0x33, 0x33, 0x30, 0x30, 0x31, 0x31,
  228         0x36, 0x36, 0x37, 0x37, 0x34, 0x34, 0x35, 0x35,
  229         0x0a, 0x0b, 0x08, 0x09, 0x0e, 0x0f, 0x0c, 0x0d,
  230         0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
  231         0x1a, 0x18, 0x1e, 0x1c, 0x12, 0x10, 0x16, 0x14,
  232         0x6a, 0x6e, 0x62, 0x66, 0x7a, 0x72, 0x4a, 0x5a,
  233         0xd5, 0xc5, 0xf5, 0xfd, 0xe5, 0xe1, 0xed, 0xe9,
  234         0x95, 0x97, 0x91, 0x93, 0x9d, 0x9f, 0x99, 0x9b,
  235         0x85, 0x84, 0x87, 0x86, 0x81, 0x80, 0x83, 0x82,
  236         0x8d, 0x8c, 0x8f, 0x8e, 0x89, 0x88, 0x8b, 0x8a,
  237         0xb5, 0xb5, 0xb4, 0xb4, 0xb7, 0xb7, 0xb6, 0xb6,
  238         0xb1, 0xb1, 0xb0, 0xb0, 0xb3, 0xb3, 0xb2, 0xb2,
  239         0xbd, 0xbd, 0xbc, 0xbc, 0xbf, 0xbf, 0xbe, 0xbe,
  240         0xb9, 0xb9, 0xb8, 0xb8, 0xbb, 0xbb, 0xba, 0xba,
  241         0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4,
  242         0xa7, 0xa7, 0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6,
  243         0xa1, 0xa1, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, 0xa0,
  244         0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2,
  245         0xad, 0xad, 0xad, 0xad, 0xac, 0xac, 0xac, 0xac,
  246         0xaf, 0xaf, 0xaf, 0xaf, 0xae, 0xae, 0xae, 0xae,
  247         0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8,
  248         0xab, 0xab, 0xab, 0xab, 0xaa, 0xaa, 0xaa, 0xaa,
  249 };
  251 void
mulaw_to_ulinear8(void *v, u_char *p, int cc)
  253 {
  254         /* Use the 16 bit table for 8 bits too. */
  255         while (--cc >= 0) {
  256                 *p = mulawtolin16[*p][0];
  257                 ++p;
  258         }
  259 }
  261 void
mulaw_to_slinear8(void *v, u_char *p, int cc)
  263 {
  264         /* Use the 16 bit table for 8 bits too. */
  265         while (--cc >= 0) {
  266                 *p = mulawtolin16[*p][0] ^ 0x80;
  267                 ++p;
  268         }
  269 }
  271 void
mulaw_to_ulinear16_le(void *v, u_char *p, int cc)
  273 {
u_char *q = p;
p += cc;
q += cc << 1;
  278         while (--cc >= 0) {
  279                 --p;
q -= 2;
q[1] = mulawtolin16[*p][0];
q[0] = mulawtolin16[*p][1];
  283         }
  284 }
  286 void
mulaw_to_ulinear16_be(void *v, u_char *p, int cc)
  288 {
u_char *q = p;
p += cc;
q += cc << 1;
  293         while (--cc >= 0) {
  294                 --p;
q -= 2;
q[0] = mulawtolin16[*p][0];
q[1] = mulawtolin16[*p][1];
  298         }
  299 }
  301 void
mulaw_to_slinear16_le(void *v, u_char *p, int cc)
  303 {
u_char *q = p;
p += cc;
q += cc << 1;
  308         while (--cc >= 0) {
  309                 --p;
q -= 2;
q[1] = mulawtolin16[*p][0] ^ 0x80;
q[0] = mulawtolin16[*p][1];
  313         }
  314 }
  316 void
mulaw_to_slinear16_le_mts(void *v, u_char *p, int cc)
  318 {
u_char *q = p;
p += cc;
q += cc * 4;
  323         while (--cc >= 0) {
  324                 --p;
q -= 4;
q[1] = q[3] = mulawtolin16[*p][0] ^ 0x80;
q[0] = q[2] = mulawtolin16[*p][1];
  328         }
  329 }
  331 void
mulaw_to_slinear16_be(void *v, u_char *p, int cc)
  333 {
u_char *q = p;
p += cc;
q += cc << 1;
  338         while (--cc >= 0) {
  339                 --p;
q -= 2;
q[0] = mulawtolin16[*p][0] ^ 0x80;
q[1] = mulawtolin16[*p][1];
  343         }
  344 }
  346 void
mulaw_to_slinear16_be_mts(void *v, u_char *p, int cc)
  348 {
u_char *q = p;
p += cc;
q += cc * 4;
  353         while (--cc >= 0) {
  354                 --p;
q -= 4;
q[0] = q[2] = mulawtolin16[*p][0] ^ 0x80;
q[1] = q[3] = mulawtolin16[*p][1];
  358         }
  359 }
  361 void
slinear16_to_mulaw_le(void *v, u_char* p, int cc)
  363 {
u_char *q = p + 1;      /* q points higher byte. */
  366         while ((cc-= 2) >= 0) {
  367                 *p++ = lintomulaw[*q ^ 0x80];
q +=2 ;
  369         }
  370 }
  372 void
ulinear8_to_mulaw(void *v, u_char *p, int cc)
  374 {
  375         while (--cc >= 0) {
  376                 *p = lintomulaw[*p];
  377                 ++p;
  378         }
  379 }
  381 void
slinear8_to_mulaw(void *v, u_char *p, int cc)
  383 {
  384         while (--cc >= 0) {
  385                 *p = lintomulaw[*p ^ 0x80];
  386                 ++p;
  387         }
  388 }
  390 void
alaw_to_ulinear8(void *v, u_char *p, int cc)
  392 {
  393         /* Use the 16 bit table for 8 bits too. */
  394         while (--cc >= 0) {
  395                 *p = alawtolin16[*p][0];
  396                 ++p;
  397         }
  398 }
  400 void
alaw_to_slinear8(void *v, u_char *p, int cc)
  402 {
  403         /* Use the 16 bit table for 8 bits too. */
  404         while (--cc >= 0) {
  405                 *p = alawtolin16[*p][0] ^ 0x80;
  406                 ++p;
  407         }
  408 }
  410 void
alaw_to_ulinear16_le(void *v, u_char *p, int cc)
  412 {
u_char *q = p;
p += cc;
q += cc << 1;
  417         while (--cc >= 0) {
  418                 --p;
q -= 2;
q[1] = alawtolin16[*p][0];
q[0] = alawtolin16[*p][1];
  422         }
  423 }
  425 void
alaw_to_ulinear16_be(void *v, u_char *p, int cc)
  427 {
u_char *q = p;
p += cc;
q += cc << 1;
  432         while (--cc >= 0) {
  433                 --p;
q -= 2;
q[0] = alawtolin16[*p][0];
q[1] = alawtolin16[*p][1];
  437         }
  438 }
  440 void
alaw_to_slinear16_le(void *v, u_char *p, int cc)
  442 {
u_char *q = p;
p += cc;
q += cc << 1;
  447         while (--cc >= 0) {
  448                 --p;
q -= 2;
q[1] = alawtolin16[*p][0] ^ 0x80;
q[0] = alawtolin16[*p][1];
  452         }
  453 }
  455 void
alaw_to_slinear16_be(void *v, u_char *p, int cc)
  457 {
u_char *q = p;
p += cc;
q += cc << 1;
  462         while (--cc >= 0) {
  463                 --p;
q -= 2;
q[0] = alawtolin16[*p][0] ^ 0x80;
q[1] = alawtolin16[*p][1];
  467         }
  468 }
  470 void
ulinear8_to_alaw(void *v, u_char *p, int cc)
  472 {
  473         while (--cc >= 0) {
  474                 *p = lintoalaw[*p];
  475                 ++p;
  476         }
  477 }
  479 void
slinear8_to_alaw(void *v, u_char *p, int cc)
  481 {
  482         while (--cc >= 0) {
  483                 *p = lintoalaw[*p ^ 0x80];
  484                 ++p;
  485         }
  486 }
  488 void
slinear16_to_alaw_le(void *v, u_char *p, int cc)
  490 {
u_char *q = p;
  493         while ((cc -= 2) >= 0) {
  494                 *p = lintoalaw[q[1] ^ 0x80];
  495                 ++p;
q += 2;
  497         }
  498 }
  501 void
slinear16_to_alaw_be(void *v, u_char *p, int cc)
  503 {
u_char *q = p;
  506         while ((cc -= 2) >= 0) {
  507                 *p = lintoalaw[q[0] ^ 0x80];
  508                 ++p;
q += 2;
  510         }
  511 }
  513 /*
  514  * same as mulaw_to_ulinear16_le(), plus expand mono to stereo
  515  */
  516 void
mulaw_to_ulinear16_le_mts(void *v, u_char *p, int cc)
  518 {
u_char *q = p;
p += cc;
q += cc * 4;
  523         while (--cc >= 0) {
  524                 --p;
q -= 4;
q[1] = q[3] = mulawtolin16[*p][0];
q[0] = q[2] = mulawtolin16[*p][1];
  528         }
  529 }
  531 /*
  532  * same as mulaw_to_ulinear16_be(), plus expand mono to stereo
  533  */
  534 void
mulaw_to_ulinear16_be_mts(void *v, u_char *p, int cc)
  536 {
u_char *q = p;
p += cc;
q += cc * 4;
  541         while (--cc >= 0) {
  542                 --p;
q -= 4;
q[0] = q[2] = mulawtolin16[*p][0];
q[1] = q[3] = mulawtolin16[*p][1];
  546         }
  547 }
  549 /*
  550  * same as alaw_to_slinear16_le(), plus expand mono to stereo
  551  */
  552 void
alaw_to_slinear16_le_mts(void *v, u_char *p, int cc)
  554 {
u_char *q = p;
p += cc;
q += cc * 4;
  559         while (--cc >= 0) {
  560                 --p;
q -= 4;
q[1] = q[3] = alawtolin16[*p][0] ^ 0x80;
q[0] = q[2] = alawtolin16[*p][1];
  564         }
  565 }
  567 /*
  568  * same as alaw_to_slinear16_be(), plus expand mono to stereo
  569  */
  570 void
alaw_to_slinear16_be_mts(void *v, u_char *p, int cc)
  572 {
u_char *q = p;
p += cc;
q += cc * 4;
  577         while (--cc >= 0) {
  578                 --p;
q -= 4;
q[0] = q[2] = alawtolin16[*p][0] ^ 0x80;
q[1] = q[3] = alawtolin16[*p][1];
  582         }
  583 }
  585 void
alaw_to_mulaw(void *v, u_char *p, int cc)
  587 {
  588         while (--cc >= 0) {
  589                 *p = lintomulaw[alawtolin16[*p][0]];
  590                 ++p;
  591         }
  592 }
  594 void
mulaw_to_alaw(void *v, u_char *p, int cc)
  596 {
  597         while (--cc >= 0) {
  598                 *p = lintoalaw[mulawtolin16[*p][0]];
  599                 ++p;
  600         }
  601 }