1 /*- 2 * Copyright (c) 2006-2009 Ariff Abdullah <ariff@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 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 * $FreeBSD$ 27 */ 28 29 #ifndef _SND_PCM_H_ 30 #define _SND_PCM_H_ 31 32 #include <sys/param.h> 33 34 /* 35 * Macros for reading/writing PCM sample / int values from bytes array. 36 * Since every process is done using signed integer (and to make our life 37 * less miserable), unsigned sample will be converted to its signed 38 * counterpart and restored during writing back. To avoid overflow, 39 * we truncate 32bit (and only 32bit) samples down to 24bit (see below 40 * for the reason), unless SND_PCM_64 is defined. 41 */ 42 43 /* 44 * Automatically turn on 64bit arithmetic on suitable archs 45 * (amd64 64bit, etc..) for wider 32bit samples / integer processing. 46 */ 47 #if LONG_BIT >= 64 48 #undef SND_PCM_64 49 #define SND_PCM_64 1 50 #endif 51 52 typedef int32_t intpcm_t; 53 54 typedef int32_t intpcm8_t; 55 typedef int32_t intpcm16_t; 56 typedef int32_t intpcm24_t; 57 58 typedef uint32_t uintpcm_t; 59 60 typedef uint32_t uintpcm8_t; 61 typedef uint32_t uintpcm16_t; 62 typedef uint32_t uintpcm24_t; 63 64 #ifdef SND_PCM_64 65 typedef int64_t intpcm32_t; 66 typedef uint64_t uintpcm32_t; 67 #else 68 typedef int32_t intpcm32_t; 69 typedef uint32_t uintpcm32_t; 70 #endif 71 72 typedef int64_t intpcm64_t; 73 typedef uint64_t uintpcm64_t; 74 75 /* 32bit fixed point shift */ 76 #define PCM_FXSHIFT 8 77 78 #define PCM_S8_MAX 0x7f 79 #define PCM_S8_MIN -0x80 80 #define PCM_S16_MAX 0x7fff 81 #define PCM_S16_MIN -0x8000 82 #define PCM_S24_MAX 0x7fffff 83 #define PCM_S24_MIN -0x800000 84 #ifdef SND_PCM_64 85 #if LONG_BIT >= 64 86 #define PCM_S32_MAX 0x7fffffffL 87 #define PCM_S32_MIN -0x80000000L 88 #else 89 #define PCM_S32_MAX 0x7fffffffLL 90 #define PCM_S32_MIN -0x80000000LL 91 #endif 92 #else 93 #define PCM_S32_MAX 0x7fffffff 94 #define PCM_S32_MIN (-0x7fffffff - 1) 95 #endif 96 97 /* Bytes-per-sample definition */ 98 #define PCM_8_BPS 1 99 #define PCM_16_BPS 2 100 #define PCM_24_BPS 3 101 #define PCM_32_BPS 4 102 103 #define INTPCM_T(v) ((intpcm_t)(v)) 104 #define INTPCM8_T(v) ((intpcm8_t)(v)) 105 #define INTPCM16_T(v) ((intpcm16_t)(v)) 106 #define INTPCM24_T(v) ((intpcm24_t)(v)) 107 #define INTPCM32_T(v) ((intpcm32_t)(v)) 108 109 #if BYTE_ORDER == LITTLE_ENDIAN 110 #define _PCM_READ_S16_LE(b8) INTPCM_T(*((int16_t *)(b8))) 111 #define _PCM_READ_S32_LE(b8) INTPCM_T(*((int32_t *)(b8))) 112 #define _PCM_READ_S16_BE(b8) \ 113 INTPCM_T((b8)[1] | (((int8_t)((b8)[0])) << 8)) 114 #define _PCM_READ_S32_BE(b8) \ 115 INTPCM_T((b8)[3] | ((b8)[2] << 8) | ((b8)[1] << 16) | \ 116 (((int8_t)((b8)[0])) << 24)) 117 118 #define _PCM_WRITE_S16_LE(b8, val) do { \ 119 *((int16_t *)(b8)) = (val); \ 120 } while (0) 121 #define _PCM_WRITE_S32_LE(b8, val) do { \ 122 *((int32_t *)(b8)) = (val); \ 123 } while (0) 124 #define _PCM_WRITE_S16_BE(bb8, vval) do { \ 125 intpcm_t val = (vval); \ 126 uint8_t *b8 = (bb8); \ 127 b8[1] = val; \ 128 b8[0] = val >> 8; \ 129 } while (0) 130 #define _PCM_WRITE_S32_BE(bb8, vval) do { \ 131 intpcm_t val = (vval); \ 132 uint8_t *b8 = (bb8); \ 133 b8[3] = val; \ 134 b8[2] = val >> 8; \ 135 b8[1] = val >> 16; \ 136 b8[0] = val >> 24; \ 137 } while (0) 138 139 #define _PCM_READ_U16_LE(b8) \ 140 INTPCM_T((int16_t)(*((uint16_t *)(b8)) ^ 0x8000)) 141 #define _PCM_READ_U32_LE(b8) \ 142 INTPCM_T((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000)) 143 #define _PCM_READ_U16_BE(b8) \ 144 INTPCM_T((b8)[1] | (((int8_t)((b8)[0] ^ 0x80)) << 8)) 145 #define _PCM_READ_U32_BE(b8) \ 146 INTPCM_T((b8)[3] | ((b8)[2] << 8) | ((b8)[1] << 16) | \ 147 (((int8_t)((b8)[0] ^ 0x80)) << 24)) 148 149 #define _PCM_WRITE_U16_LE(b8, val) do { \ 150 *((uint16_t *)(b8)) = (val) ^ 0x8000; \ 151 } while (0) 152 #define _PCM_WRITE_U32_LE(b8, val) do { \ 153 *((uint32_t *)(b8)) = (val) ^ 0x80000000; \ 154 } while (0) 155 #define _PCM_WRITE_U16_BE(bb8, vval) do { \ 156 intpcm_t val = (vval); \ 157 uint8_t *b8 = (bb8); \ 158 b8[1] = val; \ 159 b8[0] = (val >> 8) ^ 0x80; \ 160 } while (0) 161 #define _PCM_WRITE_U32_BE(bb8, vval) do { \ 162 intpcm_t val = (vval); \ 163 uint8_t *b8 = (bb8); \ 164 b8[3] = val; \ 165 b8[2] = val >> 8; \ 166 b8[1] = val >> 16; \ 167 b8[0] = (val >> 24) ^ 0x80; \ 168 } while (0) 169 170 #define _PCM_READ_S16_NE(b8) _PCM_READ_S16_LE(b8) 171 #define _PCM_READ_U16_NE(b8) _PCM_READ_U16_LE(b8) 172 #define _PCM_READ_S32_NE(b8) _PCM_READ_S32_LE(b8) 173 #define _PCM_READ_U32_NE(b8) _PCM_READ_U32_LE(b8) 174 #define _PCM_WRITE_S16_NE(b6) _PCM_WRITE_S16_LE(b8) 175 #define _PCM_WRITE_U16_NE(b6) _PCM_WRITE_U16_LE(b8) 176 #define _PCM_WRITE_S32_NE(b6) _PCM_WRITE_S32_LE(b8) 177 #define _PCM_WRITE_U32_NE(b6) _PCM_WRITE_U32_LE(b8) 178 #else /* !LITTLE_ENDIAN */ 179 #define _PCM_READ_S16_LE(b8) \ 180 INTPCM_T((b8)[0] | (((int8_t)((b8)[1])) << 8)) 181 #define _PCM_READ_S32_LE(b8) \ 182 INTPCM_T((b8)[0] | ((b8)[1] << 8) | ((b8)[2] << 16) | \ 183 (((int8_t)((b8)[3])) << 24)) 184 #define _PCM_READ_S16_BE(b8) INTPCM_T(*((int16_t *)(b8))) 185 #define _PCM_READ_S32_BE(b8) INTPCM_T(*((int32_t *)(b8))) 186 187 #define _PCM_WRITE_S16_LE(bb8, vval) do { \ 188 intpcm_t val = (vval); \ 189 uint8_t *b8 = (bb8); \ 190 b8[0] = val; \ 191 b8[1] = val >> 8; \ 192 } while (0) 193 #define _PCM_WRITE_S32_LE(bb8, vval) do { \ 194 intpcm_t val = (vval); \ 195 uint8_t *b8 = (bb8); \ 196 b8[0] = val; \ 197 b8[1] = val >> 8; \ 198 b8[2] = val >> 16; \ 199 b8[3] = val >> 24; \ 200 } while (0) 201 #define _PCM_WRITE_S16_BE(b8, val) do { \ 202 *((int16_t *)(b8)) = (val); \ 203 } while (0) 204 #define _PCM_WRITE_S32_BE(b8, val) do { \ 205 *((int32_t *)(b8)) = (val); \ 206 } while (0) 207 208 #define _PCM_READ_U16_LE(b8) \ 209 INTPCM_T((b8)[0] | (((int8_t)((b8)[1] ^ 0x80)) << 8)) 210 #define _PCM_READ_U32_LE(b8) \ 211 INTPCM_T((b8)[0] | ((b8)[1] << 8) | ((b8)[2] << 16) | \ 212 (((int8_t)((b8)[3] ^ 0x80)) << 24)) 213 #define _PCM_READ_U16_BE(b8) \ 214 INTPCM_T((int16_t)(*((uint16_t *)(b8)) ^ 0x8000)) 215 #define _PCM_READ_U32_BE(b8) \ 216 INTPCM_T((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000)) 217 218 #define _PCM_WRITE_U16_LE(bb8, vval) do { \ 219 intpcm_t val = (vval); \ 220 uint8_t *b8 = (bb8); \ 221 b8[0] = val; \ 222 b8[1] = (val >> 8) ^ 0x80; \ 223 } while (0) 224 #define _PCM_WRITE_U32_LE(bb8, vval) do { \ 225 intpcm_t val = (vval); \ 226 uint8_t *b8 = (bb8); \ 227 b8[0] = val; \ 228 b8[1] = val >> 8; \ 229 b8[2] = val >> 16; \ 230 b8[3] = (val >> 24) ^ 0x80; \ 231 } while (0) 232 #define _PCM_WRITE_U16_BE(b8, val) do { \ 233 *((uint16_t *)(b8)) = (val) ^ 0x8000; \ 234 } while (0) 235 #define _PCM_WRITE_U32_BE(b8, val) do { \ 236 *((uint32_t *)(b8)) = (val) ^ 0x80000000; \ 237 } while (0) 238 239 #define _PCM_READ_S16_NE(b8) _PCM_READ_S16_BE(b8) 240 #define _PCM_READ_U16_NE(b8) _PCM_READ_U16_BE(b8) 241 #define _PCM_READ_S32_NE(b8) _PCM_READ_S32_BE(b8) 242 #define _PCM_READ_U32_NE(b8) _PCM_READ_U32_BE(b8) 243 #define _PCM_WRITE_S16_NE(b6) _PCM_WRITE_S16_BE(b8) 244 #define _PCM_WRITE_U16_NE(b6) _PCM_WRITE_U16_BE(b8) 245 #define _PCM_WRITE_S32_NE(b6) _PCM_WRITE_S32_BE(b8) 246 #define _PCM_WRITE_U32_NE(b6) _PCM_WRITE_U32_BE(b8) 247 #endif /* LITTLE_ENDIAN */ 248 249 #define _PCM_READ_S24_LE(b8) \ 250 INTPCM_T((b8)[0] | ((b8)[1] << 8) | (((int8_t)((b8)[2])) << 16)) 251 #define _PCM_READ_S24_BE(b8) \ 252 INTPCM_T((b8)[2] | ((b8)[1] << 8) | (((int8_t)((b8)[0])) << 16)) 253 254 #define _PCM_WRITE_S24_LE(bb8, vval) do { \ 255 intpcm_t val = (vval); \ 256 uint8_t *b8 = (bb8); \ 257 b8[0] = val; \ 258 b8[1] = val >> 8; \ 259 b8[2] = val >> 16; \ 260 } while (0) 261 #define _PCM_WRITE_S24_BE(bb8, vval) do { \ 262 intpcm_t val = (vval); \ 263 uint8_t *b8 = (bb8); \ 264 b8[2] = val; \ 265 b8[1] = val >> 8; \ 266 b8[0] = val >> 16; \ 267 } while (0) 268 269 #define _PCM_READ_U24_LE(b8) \ 270 INTPCM_T((b8)[0] | ((b8)[1] << 8) | \ 271 (((int8_t)((b8)[2] ^ 0x80)) << 16)) 272 #define _PCM_READ_U24_BE(b8) \ 273 INTPCM_T((b8)[2] | ((b8)[1] << 8) | \ 274 (((int8_t)((b8)[0] ^ 0x80)) << 16)) 275 276 #define _PCM_WRITE_U24_LE(bb8, vval) do { \ 277 intpcm_t val = (vval); \ 278 uint8_t *b8 = (bb8); \ 279 b8[0] = val; \ 280 b8[1] = val >> 8; \ 281 b8[2] = (val >> 16) ^ 0x80; \ 282 } while (0) 283 #define _PCM_WRITE_U24_BE(bb8, vval) do { \ 284 intpcm_t val = (vval); \ 285 uint8_t *b8 = (bb8); \ 286 b8[2] = val; \ 287 b8[1] = val >> 8; \ 288 b8[0] = (val >> 16) ^ 0x80; \ 289 } while (0) 290 291 #if BYTE_ORDER == LITTLE_ENDIAN 292 #define _PCM_READ_S24_NE(b8) _PCM_READ_S24_LE(b8) 293 #define _PCM_READ_U24_NE(b8) _PCM_READ_U24_LE(b8) 294 #define _PCM_WRITE_S24_NE(b6) _PCM_WRITE_S24_LE(b8) 295 #define _PCM_WRITE_U24_NE(b6) _PCM_WRITE_U24_LE(b8) 296 #else /* !LITTLE_ENDIAN */ 297 #define _PCM_READ_S24_NE(b8) _PCM_READ_S24_BE(b8) 298 #define _PCM_READ_U24_NE(b8) _PCM_READ_U24_BE(b8) 299 #define _PCM_WRITE_S24_NE(b6) _PCM_WRITE_S24_BE(b8) 300 #define _PCM_WRITE_U24_NE(b6) _PCM_WRITE_U24_BE(b8) 301 #endif /* LITTLE_ENDIAN */ 302 /* 303 * 8bit sample is pretty much useless since it doesn't provide 304 * sufficient dynamic range throughout our filtering process. 305 * For the sake of completeness, declare it anyway. 306 */ 307 #define _PCM_READ_S8_NE(b8) INTPCM_T(*((int8_t *)(b8))) 308 #define _PCM_READ_U8_NE(b8) \ 309 INTPCM_T((int8_t)(*((uint8_t *)(b8)) ^ 0x80)) 310 311 #define _PCM_WRITE_S8_NE(b8, val) do { \ 312 *((int8_t *)(b8)) = (val); \ 313 } while (0) 314 #define _PCM_WRITE_U8_NE(b8, val) do { \ 315 *((uint8_t *)(b8)) = (val) ^ 0x80; \ 316 } while (0) 317 318 /* 319 * Common macross. Use this instead of "_", unless we want 320 * the real sample value. 321 */ 322 323 /* 8bit */ 324 #define PCM_READ_S8_NE(b8) _PCM_READ_S8_NE(b8) 325 #define PCM_READ_U8_NE(b8) _PCM_READ_U8_NE(b8) 326 #define PCM_WRITE_S8_NE(b8, val) _PCM_WRITE_S8_NE(b8, val) 327 #define PCM_WRITE_U8_NE(b8, val) _PCM_WRITE_U8_NE(b8, val) 328 329 /* 16bit */ 330 #define PCM_READ_S16_LE(b8) _PCM_READ_S16_LE(b8) 331 #define PCM_READ_S16_BE(b8) _PCM_READ_S16_BE(b8) 332 #define PCM_READ_U16_LE(b8) _PCM_READ_U16_LE(b8) 333 #define PCM_READ_U16_BE(b8) _PCM_READ_U16_BE(b8) 334 335 #define PCM_WRITE_S16_LE(b8, val) _PCM_WRITE_S16_LE(b8, val) 336 #define PCM_WRITE_S16_BE(b8, val) _PCM_WRITE_S16_BE(b8, val) 337 #define PCM_WRITE_U16_LE(b8, val) _PCM_WRITE_U16_LE(b8, val) 338 #define PCM_WRITE_U16_BE(b8, val) _PCM_WRITE_U16_BE(b8, val) 339 340 #define PCM_READ_S16_NE(b8) _PCM_READ_S16_NE(b8) 341 #define PCM_READ_U16_NE(b8) _PCM_READ_U16_NE(b8) 342 #define PCM_WRITE_S16_NE(b8) _PCM_WRITE_S16_NE(b8) 343 #define PCM_WRITE_U16_NE(b8) _PCM_WRITE_U16_NE(b8) 344 345 /* 24bit */ 346 #define PCM_READ_S24_LE(b8) _PCM_READ_S24_LE(b8) 347 #define PCM_READ_S24_BE(b8) _PCM_READ_S24_BE(b8) 348 #define PCM_READ_U24_LE(b8) _PCM_READ_U24_LE(b8) 349 #define PCM_READ_U24_BE(b8) _PCM_READ_U24_BE(b8) 350 351 #define PCM_WRITE_S24_LE(b8, val) _PCM_WRITE_S24_LE(b8, val) 352 #define PCM_WRITE_S24_BE(b8, val) _PCM_WRITE_S24_BE(b8, val) 353 #define PCM_WRITE_U24_LE(b8, val) _PCM_WRITE_U24_LE(b8, val) 354 #define PCM_WRITE_U24_BE(b8, val) _PCM_WRITE_U24_BE(b8, val) 355 356 #define PCM_READ_S24_NE(b8) _PCM_READ_S24_NE(b8) 357 #define PCM_READ_U24_NE(b8) _PCM_READ_U24_NE(b8) 358 #define PCM_WRITE_S24_NE(b8) _PCM_WRITE_S24_NE(b8) 359 #define PCM_WRITE_U24_NE(b8) _PCM_WRITE_U24_NE(b8) 360 361 /* 32bit */ 362 #ifdef SND_PCM_64 363 #define PCM_READ_S32_LE(b8) _PCM_READ_S32_LE(b8) 364 #define PCM_READ_S32_BE(b8) _PCM_READ_S32_BE(b8) 365 #define PCM_READ_U32_LE(b8) _PCM_READ_U32_LE(b8) 366 #define PCM_READ_U32_BE(b8) _PCM_READ_U32_BE(b8) 367 368 #define PCM_WRITE_S32_LE(b8, val) _PCM_WRITE_S32_LE(b8, val) 369 #define PCM_WRITE_S32_BE(b8, val) _PCM_WRITE_S32_BE(b8, val) 370 #define PCM_WRITE_U32_LE(b8, val) _PCM_WRITE_U32_LE(b8, val) 371 #define PCM_WRITE_U32_BE(b8, val) _PCM_WRITE_U32_BE(b8, val) 372 373 #define PCM_READ_S32_NE(b8) _PCM_READ_S32_NE(b8) 374 #define PCM_READ_U32_NE(b8) _PCM_READ_U32_NE(b8) 375 #define PCM_WRITE_S32_NE(b8) _PCM_WRITE_S32_NE(b8) 376 #define PCM_WRITE_U32_NE(b8) _PCM_WRITE_U32_NE(b8) 377 #else /* !SND_PCM_64 */ 378 /* 379 * 24bit integer ?!? This is quite unfortunate, eh? Get the fact straight: 380 * Dynamic range for: 381 * 1) Human =~ 140db 382 * 2) 16bit = 96db (close enough) 383 * 3) 24bit = 144db (perfect) 384 * 4) 32bit = 196db (way too much) 385 * 5) Bugs Bunny = Gazillion!@%$Erbzzztt-EINVAL db 386 * Since we're not Bugs Bunny ..uh..err.. avoiding 64bit arithmetic, 24bit 387 * is pretty much sufficient for our signed integer processing. 388 */ 389 #define PCM_READ_S32_LE(b8) (_PCM_READ_S32_LE(b8) >> PCM_FXSHIFT) 390 #define PCM_READ_S32_BE(b8) (_PCM_READ_S32_BE(b8) >> PCM_FXSHIFT) 391 #define PCM_READ_U32_LE(b8) (_PCM_READ_U32_LE(b8) >> PCM_FXSHIFT) 392 #define PCM_READ_U32_BE(b8) (_PCM_READ_U32_BE(b8) >> PCM_FXSHIFT) 393 394 #define PCM_READ_S32_NE(b8) (_PCM_READ_S32_NE(b8) >> PCM_FXSHIFT) 395 #define PCM_READ_U32_NE(b8) (_PCM_READ_U32_NE(b8) >> PCM_FXSHIFT) 396 397 #define PCM_WRITE_S32_LE(b8, val) \ 398 _PCM_WRITE_S32_LE(b8, (val) << PCM_FXSHIFT) 399 #define PCM_WRITE_S32_BE(b8, val) \ 400 _PCM_WRITE_S32_BE(b8, (val) << PCM_FXSHIFT) 401 #define PCM_WRITE_U32_LE(b8, val) \ 402 _PCM_WRITE_U32_LE(b8, (val) << PCM_FXSHIFT) 403 #define PCM_WRITE_U32_BE(b8, val) \ 404 _PCM_WRITE_U32_BE(b8, (val) << PCM_FXSHIFT) 405 406 #define PCM_WRITE_S32_NE(b8, val) \ 407 _PCM_WRITE_S32_NE(b8, (val) << PCM_FXSHIFT) 408 #define PCM_WRITE_U32_NE(b8, val) \ 409 _PCM_WRITE_U32_NE(b8, (val) << PCM_FXSHIFT) 410 #endif /* SND_PCM_64 */ 411 412 #define PCM_CLAMP_S8(val) \ 413 (((val) > PCM_S8_MAX) ? PCM_S8_MAX : \ 414 (((val) < PCM_S8_MIN) ? PCM_S8_MIN : (val))) 415 #define PCM_CLAMP_S16(val) \ 416 (((val) > PCM_S16_MAX) ? PCM_S16_MAX : \ 417 (((val) < PCM_S16_MIN) ? PCM_S16_MIN : (val))) 418 #define PCM_CLAMP_S24(val) \ 419 (((val) > PCM_S24_MAX) ? PCM_S24_MAX : \ 420 (((val) < PCM_S24_MIN) ? PCM_S24_MIN : (val))) 421 422 #ifdef SND_PCM_64 423 #define PCM_CLAMP_S32(val) \ 424 (((val) > PCM_S32_MAX) ? PCM_S32_MAX : \ 425 (((val) < PCM_S32_MIN) ? PCM_S32_MIN : (val))) 426 #else /* !SND_PCM_64 */ 427 #define PCM_CLAMP_S32(val) \ 428 (((val) > PCM_S24_MAX) ? PCM_S32_MAX : \ 429 (((val) < PCM_S24_MIN) ? PCM_S32_MIN : \ 430 ((val) << PCM_FXSHIFT))) 431 #endif /* SND_PCM_64 */ 432 433 #define PCM_CLAMP_U8(val) PCM_CLAMP_S8(val) 434 #define PCM_CLAMP_U16(val) PCM_CLAMP_S16(val) 435 #define PCM_CLAMP_U24(val) PCM_CLAMP_S24(val) 436 #define PCM_CLAMP_U32(val) PCM_CLAMP_S32(val) 437 438 #endif /* !_SND_PCM_H_ */ 439