1 /* $OpenBSD: mulaw.c,v 1.7 2001/05/01 01:54:43 aaron Exp $ */ 2 /* $NetBSD: mulaw.c,v 1.15 2001/01/18 20:28:20 jdolecek Exp $ */ 3 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 */ 37 38 #include <sys/types.h> 39 #include <sys/audioio.h> 40 #include <dev/mulaw.h> 41 42 /* 43 * This table converts a (8 bit) mulaw 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 }; 113 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 }; 148 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 }; 215 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 }; 250 251 void 252 mulaw_to_ulinear8(v, p, cc) 253 void *v; 254 u_char *p; 255 int cc; 256 { 257 /* Use the 16 bit table for 8 bits too. */ 258 while (--cc >= 0) { 259 *p = mulawtolin16[*p][0]; 260 ++p; 261 } 262 } 263 264 void 265 mulaw_to_slinear8(v, p, cc) 266 void *v; 267 u_char *p; 268 int cc; 269 { 270 /* Use the 16 bit table for 8 bits too. */ 271 while (--cc >= 0) { 272 *p = mulawtolin16[*p][0] ^ 0x80; 273 ++p; 274 } 275 } 276 277 void 278 mulaw_to_ulinear16_le(v, p, cc) 279 void *v; 280 u_char *p; 281 int cc; 282 { 283 u_char *q = p; 284 285 p += cc; 286 q += cc << 1; 287 while (--cc >= 0) { 288 --p; 289 q -= 2; 290 q[1] = mulawtolin16[*p][0]; 291 q[0] = mulawtolin16[*p][1]; 292 } 293 } 294 295 void 296 mulaw_to_ulinear16_be(v, p, cc) 297 void *v; 298 u_char *p; 299 int cc; 300 { 301 u_char *q = p; 302 303 p += cc; 304 q += cc << 1; 305 while (--cc >= 0) { 306 --p; 307 q -= 2; 308 q[0] = mulawtolin16[*p][0]; 309 q[1] = mulawtolin16[*p][1]; 310 } 311 } 312 313 void 314 mulaw_to_slinear16_le(v, p, cc) 315 void *v; 316 u_char *p; 317 int cc; 318 { 319 u_char *q = p; 320 321 p += cc; 322 q += cc << 1; 323 while (--cc >= 0) { 324 --p; 325 q -= 2; 326 q[1] = mulawtolin16[*p][0] ^ 0x80; 327 q[0] = mulawtolin16[*p][1]; 328 } 329 } 330 331 void 332 mulaw_to_slinear16_be(v, p, cc) 333 void *v; 334 u_char *p; 335 int cc; 336 { 337 u_char *q = p; 338 339 p += cc; 340 q += cc << 1; 341 while (--cc >= 0) { 342 --p; 343 q -= 2; 344 q[0] = mulawtolin16[*p][0] ^ 0x80; 345 q[1] = mulawtolin16[*p][1]; 346 } 347 } 348 349 void 350 ulinear8_to_mulaw(v, p, cc) 351 void *v; 352 u_char *p; 353 int cc; 354 { 355 while (--cc >= 0) { 356 *p = lintomulaw[*p]; 357 ++p; 358 } 359 } 360 361 void 362 slinear8_to_mulaw(v, p, cc) 363 void *v; 364 u_char *p; 365 int cc; 366 { 367 while (--cc >= 0) { 368 *p = lintomulaw[*p ^ 0x80]; 369 ++p; 370 } 371 } 372 373 void 374 alaw_to_ulinear8(v, p, cc) 375 void *v; 376 u_char *p; 377 int cc; 378 { 379 /* Use the 16 bit table for 8 bits too. */ 380 while (--cc >= 0) { 381 *p = alawtolin16[*p][0]; 382 ++p; 383 } 384 } 385 386 void 387 alaw_to_slinear8(v, p, cc) 388 void *v; 389 u_char *p; 390 int cc; 391 { 392 /* Use the 16 bit table for 8 bits too. */ 393 while (--cc >= 0) { 394 *p = alawtolin16[*p][0] ^ 0x80; 395 ++p; 396 } 397 } 398 399 void 400 alaw_to_ulinear16_le(v, p, cc) 401 void *v; 402 u_char *p; 403 int cc; 404 { 405 u_char *q = p; 406 407 p += cc; 408 q += cc << 1; 409 while (--cc >= 0) { 410 --p; 411 q -= 2; 412 q[1] = alawtolin16[*p][0]; 413 q[0] = alawtolin16[*p][1]; 414 } 415 } 416 417 void 418 alaw_to_ulinear16_be(v, p, cc) 419 void *v; 420 u_char *p; 421 int cc; 422 { 423 u_char *q = p; 424 425 p += cc; 426 q += cc << 1; 427 while (--cc >= 0) { 428 --p; 429 q -= 2; 430 q[0] = alawtolin16[*p][0]; 431 q[1] = alawtolin16[*p][1]; 432 } 433 } 434 435 void 436 alaw_to_slinear16_le(v, p, cc) 437 void *v; 438 u_char *p; 439 int cc; 440 { 441 u_char *q = p; 442 443 p += cc; 444 q += cc << 1; 445 while (--cc >= 0) { 446 --p; 447 q -= 2; 448 q[1] = alawtolin16[*p][0] ^ 0x80; 449 q[0] = alawtolin16[*p][1]; 450 } 451 } 452 453 void 454 alaw_to_slinear16_be(v, p, cc) 455 void *v; 456 u_char *p; 457 int cc; 458 { 459 u_char *q = p; 460 461 p += cc; 462 q += cc << 1; 463 while (--cc >= 0) { 464 --p; 465 q -= 2; 466 q[0] = alawtolin16[*p][0] ^ 0x80; 467 q[1] = alawtolin16[*p][1]; 468 } 469 } 470 471 void 472 ulinear8_to_alaw(v, p, cc) 473 void *v; 474 u_char *p; 475 int cc; 476 { 477 while (--cc >= 0) { 478 *p = lintoalaw[*p]; 479 ++p; 480 } 481 } 482 483 void 484 slinear8_to_alaw(v, p, cc) 485 void *v; 486 u_char *p; 487 int cc; 488 { 489 while (--cc >= 0) { 490 *p = lintoalaw[*p ^ 0x80]; 491 ++p; 492 } 493 } 494