sys/dev/sound/pcm/pcm.h

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