The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/pcm/pcm.h

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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: releng/11.2/sys/dev/sound/pcm/pcm.h 331722 2018-03-29 02:50:57Z eadler $
   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_ */

Cache object: ee0060f2c145663481126c501d6ddb6e


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.