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/feeder_volume.c

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) 2005-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 
   27 /* feeder_volume, a long 'Lost Technology' rather than a new feature. */
   28 
   29 #ifdef _KERNEL
   30 #ifdef HAVE_KERNEL_OPTION_HEADERS
   31 #include "opt_snd.h"
   32 #endif
   33 #include <dev/sound/pcm/sound.h>
   34 #include <dev/sound/pcm/pcm.h>
   35 #include "feeder_if.h"
   36 
   37 #define SND_USE_FXDIV
   38 #include "snd_fxdiv_gen.h"
   39 
   40 SND_DECLARE_FILE("$FreeBSD: releng/11.2/sys/dev/sound/pcm/feeder_volume.c 331722 2018-03-29 02:50:57Z eadler $");
   41 #endif
   42 
   43 typedef void (*feed_volume_t)(int *, int *, uint32_t, uint8_t *, uint32_t);
   44 
   45 #define FEEDVOLUME_CALC8(s, v)  (SND_VOL_CALC_SAMPLE((intpcm_t)         \
   46                                  (s) << 8, v) >> 8)
   47 #define FEEDVOLUME_CALC16(s, v) SND_VOL_CALC_SAMPLE((intpcm_t)(s), v)
   48 #define FEEDVOLUME_CALC24(s, v) SND_VOL_CALC_SAMPLE((intpcm64_t)(s), v)
   49 #define FEEDVOLUME_CALC32(s, v) SND_VOL_CALC_SAMPLE((intpcm64_t)(s), v)
   50 
   51 #define FEEDVOLUME_DECLARE(SIGN, BIT, ENDIAN)                           \
   52 static void                                                             \
   53 feed_volume_##SIGN##BIT##ENDIAN(int *vol, int *matrix,                  \
   54     uint32_t channels, uint8_t *dst, uint32_t count)                    \
   55 {                                                                       \
   56         intpcm##BIT##_t v;                                              \
   57         intpcm_t x;                                                     \
   58         uint32_t i;                                                     \
   59                                                                         \
   60         dst += count * PCM_##BIT##_BPS * channels;                      \
   61         do {                                                            \
   62                 i = channels;                                           \
   63                 do {                                                    \
   64                         dst -= PCM_##BIT##_BPS;                         \
   65                         i--;                                            \
   66                         x = PCM_READ_##SIGN##BIT##_##ENDIAN(dst);       \
   67                         v = FEEDVOLUME_CALC##BIT(x, vol[matrix[i]]);    \
   68                         x = PCM_CLAMP_##SIGN##BIT(v);                   \
   69                         _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x);      \
   70                 } while (i != 0);                                       \
   71         } while (--count != 0);                                         \
   72 }
   73 
   74 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
   75 FEEDVOLUME_DECLARE(S, 16, LE)
   76 FEEDVOLUME_DECLARE(S, 32, LE)
   77 #endif
   78 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
   79 FEEDVOLUME_DECLARE(S, 16, BE)
   80 FEEDVOLUME_DECLARE(S, 32, BE)
   81 #endif
   82 #ifdef SND_FEEDER_MULTIFORMAT
   83 FEEDVOLUME_DECLARE(S,  8, NE)
   84 FEEDVOLUME_DECLARE(S, 24, LE)
   85 FEEDVOLUME_DECLARE(S, 24, BE)
   86 FEEDVOLUME_DECLARE(U,  8, NE)
   87 FEEDVOLUME_DECLARE(U, 16, LE)
   88 FEEDVOLUME_DECLARE(U, 24, LE)
   89 FEEDVOLUME_DECLARE(U, 32, LE)
   90 FEEDVOLUME_DECLARE(U, 16, BE)
   91 FEEDVOLUME_DECLARE(U, 24, BE)
   92 FEEDVOLUME_DECLARE(U, 32, BE)
   93 #endif
   94 
   95 struct feed_volume_info {
   96         uint32_t bps, channels;
   97         feed_volume_t apply;
   98         int volume_class;
   99         int state;
  100         int matrix[SND_CHN_MAX];
  101 };
  102 
  103 #define FEEDVOLUME_ENTRY(SIGN, BIT, ENDIAN)                             \
  104         {                                                               \
  105                 AFMT_##SIGN##BIT##_##ENDIAN,                            \
  106                 feed_volume_##SIGN##BIT##ENDIAN                         \
  107         }
  108 
  109 static const struct {
  110         uint32_t format;
  111         feed_volume_t apply;
  112 } feed_volume_info_tab[] = {
  113 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
  114         FEEDVOLUME_ENTRY(S, 16, LE),
  115         FEEDVOLUME_ENTRY(S, 32, LE),
  116 #endif
  117 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
  118         FEEDVOLUME_ENTRY(S, 16, BE),
  119         FEEDVOLUME_ENTRY(S, 32, BE),
  120 #endif
  121 #ifdef SND_FEEDER_MULTIFORMAT
  122         FEEDVOLUME_ENTRY(S,  8, NE),
  123         FEEDVOLUME_ENTRY(S, 24, LE),
  124         FEEDVOLUME_ENTRY(S, 24, BE),
  125         FEEDVOLUME_ENTRY(U,  8, NE),
  126         FEEDVOLUME_ENTRY(U, 16, LE),
  127         FEEDVOLUME_ENTRY(U, 24, LE),
  128         FEEDVOLUME_ENTRY(U, 32, LE),
  129         FEEDVOLUME_ENTRY(U, 16, BE),
  130         FEEDVOLUME_ENTRY(U, 24, BE),
  131         FEEDVOLUME_ENTRY(U, 32, BE)
  132 #endif
  133 };
  134 
  135 #define FEEDVOLUME_TAB_SIZE     ((int32_t)                              \
  136                                  (sizeof(feed_volume_info_tab) /        \
  137                                   sizeof(feed_volume_info_tab[0])))
  138 
  139 static int
  140 feed_volume_init(struct pcm_feeder *f)
  141 {
  142         struct feed_volume_info *info;
  143         struct pcmchan_matrix *m;
  144         uint32_t i;
  145         int ret;
  146 
  147         if (f->desc->in != f->desc->out ||
  148             AFMT_CHANNEL(f->desc->in) > SND_CHN_MAX)
  149                 return (EINVAL);
  150 
  151         for (i = 0; i < FEEDVOLUME_TAB_SIZE; i++) {
  152                 if (AFMT_ENCODING(f->desc->in) ==
  153                     feed_volume_info_tab[i].format) {
  154                         info = malloc(sizeof(*info), M_DEVBUF,
  155                             M_NOWAIT | M_ZERO);
  156                         if (info == NULL)
  157                                 return (ENOMEM);
  158 
  159                         info->bps = AFMT_BPS(f->desc->in);
  160                         info->channels = AFMT_CHANNEL(f->desc->in);
  161                         info->apply = feed_volume_info_tab[i].apply;
  162                         info->volume_class = SND_VOL_C_PCM;
  163                         info->state = FEEDVOLUME_ENABLE;
  164 
  165                         f->data = info;
  166                         m = feeder_matrix_default_channel_map(info->channels);
  167                         if (m == NULL) {
  168                                 free(info, M_DEVBUF);
  169                                 return (EINVAL);
  170                         }
  171 
  172                         ret = feeder_volume_apply_matrix(f, m);
  173                         if (ret != 0)
  174                                 free(info, M_DEVBUF);
  175 
  176                         return (ret);
  177                 }
  178         }
  179 
  180         return (EINVAL);
  181 }
  182 
  183 static int
  184 feed_volume_free(struct pcm_feeder *f)
  185 {
  186         struct feed_volume_info *info;
  187 
  188         info = f->data;
  189         if (info != NULL)
  190                 free(info, M_DEVBUF);
  191 
  192         f->data = NULL;
  193 
  194         return (0);
  195 }
  196 
  197 static int
  198 feed_volume_set(struct pcm_feeder *f, int what, int value)
  199 {
  200         struct feed_volume_info *info;
  201         struct pcmchan_matrix *m;
  202         int ret;
  203 
  204         info = f->data;
  205         ret = 0;
  206 
  207         switch (what) {
  208         case FEEDVOLUME_CLASS:
  209                 if (value < SND_VOL_C_BEGIN || value > SND_VOL_C_END)
  210                         return (EINVAL);
  211                 info->volume_class = value;
  212                 break;
  213         case FEEDVOLUME_CHANNELS:
  214                 if (value < SND_CHN_MIN || value > SND_CHN_MAX)
  215                         return (EINVAL);
  216                 m = feeder_matrix_default_channel_map(value);
  217                 if (m == NULL)
  218                         return (EINVAL);
  219                 ret = feeder_volume_apply_matrix(f, m);
  220                 break;
  221         case FEEDVOLUME_STATE:
  222                 if (!(value == FEEDVOLUME_ENABLE || value == FEEDVOLUME_BYPASS))
  223                         return (EINVAL);
  224                 info->state = value;
  225                 break;
  226         default:
  227                 return (EINVAL);
  228                 break;
  229         }
  230 
  231         return (ret);
  232 }
  233 
  234 static int
  235 feed_volume_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
  236     uint32_t count, void *source)
  237 {
  238         struct feed_volume_info *info;
  239         uint32_t j, align;
  240         int i, *vol, *matrix;
  241         uint8_t *dst;
  242 
  243         /*
  244          * Fetch filter data operation.
  245          */
  246         info = f->data;
  247 
  248         if (info->state == FEEDVOLUME_BYPASS)
  249                 return (FEEDER_FEED(f->source, c, b, count, source));
  250 
  251         vol = c->volume[SND_VOL_C_VAL(info->volume_class)];
  252         matrix = info->matrix;
  253 
  254         /*
  255          * First, let see if we really need to apply gain at all.
  256          */
  257         j = 0;
  258         i = info->channels;
  259         do {
  260                 if (vol[matrix[--i]] != SND_VOL_FLAT) {
  261                         j = 1;
  262                         break;
  263                 }
  264         } while (i != 0);
  265 
  266         /* Nope, just bypass entirely. */
  267         if (j == 0)
  268                 return (FEEDER_FEED(f->source, c, b, count, source));
  269 
  270         dst = b;
  271         align = info->bps * info->channels;
  272 
  273         do {
  274                 if (count < align)
  275                         break;
  276 
  277                 j = SND_FXDIV(FEEDER_FEED(f->source, c, dst, count, source),
  278                     align);
  279                 if (j == 0)
  280                         break;
  281 
  282                 info->apply(vol, matrix, info->channels, dst, j);
  283 
  284                 j *= align;
  285                 dst += j;
  286                 count -= j;
  287 
  288         } while (count != 0);
  289 
  290         return (dst - b);
  291 }
  292 
  293 static struct pcm_feederdesc feeder_volume_desc[] = {
  294         { FEEDER_VOLUME, 0, 0, 0, 0 },
  295         { 0, 0, 0, 0, 0 }
  296 };
  297 
  298 static kobj_method_t feeder_volume_methods[] = {
  299         KOBJMETHOD(feeder_init,         feed_volume_init),
  300         KOBJMETHOD(feeder_free,         feed_volume_free),
  301         KOBJMETHOD(feeder_set,          feed_volume_set),
  302         KOBJMETHOD(feeder_feed,         feed_volume_feed),
  303         KOBJMETHOD_END
  304 };
  305 
  306 FEEDER_DECLARE(feeder_volume, NULL);
  307 
  308 /* Extern */
  309 
  310 /*
  311  * feeder_volume_apply_matrix(): For given matrix map, apply its configuration
  312  *                               to feeder_volume matrix structure. There are
  313  *                               possibilites that feeder_volume be inserted
  314  *                               before or after feeder_matrix, which in this
  315  *                               case feeder_volume must be in a good terms
  316  *                               with _current_ matrix.
  317  */
  318 int
  319 feeder_volume_apply_matrix(struct pcm_feeder *f, struct pcmchan_matrix *m)
  320 {
  321         struct feed_volume_info *info;
  322         uint32_t i;
  323 
  324         if (f == NULL || f->desc == NULL || f->desc->type != FEEDER_VOLUME ||
  325             f->data == NULL || m == NULL || m->channels < SND_CHN_MIN ||
  326             m->channels > SND_CHN_MAX)
  327                 return (EINVAL);
  328 
  329         info = f->data;
  330 
  331         for (i = 0; i < (sizeof(info->matrix) / sizeof(info->matrix[0])); i++) {
  332                 if (i < m->channels)
  333                         info->matrix[i] = m->map[i].type;
  334                 else
  335                         info->matrix[i] = SND_CHN_T_FL;
  336         }
  337 
  338         info->channels = m->channels;
  339 
  340         return (0);
  341 }

Cache object: 8a2266fc2b644298fcd54adeea8d4508


[ 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.