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_chain.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  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2008-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 
   29 #ifdef HAVE_KERNEL_OPTION_HEADERS
   30 #include "opt_snd.h"
   31 #endif
   32 
   33 #include <dev/sound/pcm/sound.h>
   34 
   35 #include "feeder_if.h"
   36 
   37 SND_DECLARE_FILE("$FreeBSD: stable/12/sys/dev/sound/pcm/feeder_chain.c 326255 2017-11-27 14:52:40Z pfg $");
   38 
   39 /* chain state */
   40 struct feeder_chain_state {
   41         uint32_t afmt;                          /* audio format */
   42         uint32_t rate;                          /* sampling rate */
   43         struct pcmchan_matrix *matrix;          /* matrix map */
   44 };
   45 
   46 /*
   47  * chain descriptor that will be passed around from the beginning until the
   48  * end of chain process.
   49  */
   50 struct feeder_chain_desc {
   51         struct feeder_chain_state origin;       /* original state */
   52         struct feeder_chain_state current;      /* current state */
   53         struct feeder_chain_state target;       /* target state */
   54         struct pcm_feederdesc desc;             /* feeder descriptor */
   55         uint32_t afmt_ne;                       /* prefered native endian */
   56         int mode;                               /* chain mode */
   57         int use_eq;                             /* need EQ? */
   58         int use_matrix;                         /* need channel matrixing? */
   59         int use_volume;                         /* need softpcmvol? */
   60         int dummy;                              /* dummy passthrough */
   61         int expensive;                          /* possibly expensive */
   62 };
   63 
   64 #define FEEDER_CHAIN_LEAN               0
   65 #define FEEDER_CHAIN_16                 1
   66 #define FEEDER_CHAIN_32                 2
   67 #define FEEDER_CHAIN_MULTI              3
   68 #define FEEDER_CHAIN_FULLMULTI          4
   69 #define FEEDER_CHAIN_LAST               5
   70 
   71 #if defined(SND_FEEDER_FULL_MULTIFORMAT)
   72 #define FEEDER_CHAIN_DEFAULT            FEEDER_CHAIN_FULLMULTI
   73 #elif defined(SND_FEEDER_MULTIFORMAT)
   74 #define FEEDER_CHAIN_DEFAULT            FEEDER_CHAIN_MULTI
   75 #else
   76 #define FEEDER_CHAIN_DEFAULT            FEEDER_CHAIN_LEAN
   77 #endif
   78 
   79 /*
   80  * List of prefered formats that might be required during
   81  * processing. It will be decided through snd_fmtbest().
   82  */
   83 
   84 /* 'Lean' mode, signed 16 or 32 bit native endian. */
   85 static uint32_t feeder_chain_formats_lean[] = {
   86         AFMT_S16_NE, AFMT_S32_NE,
   87         0
   88 };
   89 
   90 /* Force everything to signed 16 bit native endian. */
   91 static uint32_t feeder_chain_formats_16[] = {
   92         AFMT_S16_NE,
   93         0
   94 };
   95 
   96 /* Force everything to signed 32 bit native endian. */
   97 static uint32_t feeder_chain_formats_32[] = {
   98         AFMT_S32_NE,
   99         0
  100 };
  101 
  102 /* Multiple choices, all except 8 bit. */
  103 static uint32_t feeder_chain_formats_multi[] = {
  104         AFMT_S16_LE, AFMT_S16_BE, AFMT_U16_LE, AFMT_U16_BE,
  105         AFMT_S24_LE, AFMT_S24_BE, AFMT_U24_LE, AFMT_U24_BE,
  106         AFMT_S32_LE, AFMT_S32_BE, AFMT_U32_LE, AFMT_U32_BE,
  107         0
  108 };
  109 
  110 /* Everything that is convertible. */
  111 static uint32_t feeder_chain_formats_fullmulti[] = {
  112         AFMT_S8, AFMT_U8,
  113         AFMT_S16_LE, AFMT_S16_BE, AFMT_U16_LE, AFMT_U16_BE,
  114         AFMT_S24_LE, AFMT_S24_BE, AFMT_U24_LE, AFMT_U24_BE,
  115         AFMT_S32_LE, AFMT_S32_BE, AFMT_U32_LE, AFMT_U32_BE,
  116         0
  117 };
  118 
  119 static uint32_t *feeder_chain_formats[FEEDER_CHAIN_LAST] = {
  120         [FEEDER_CHAIN_LEAN]      = feeder_chain_formats_lean,
  121         [FEEDER_CHAIN_16]        = feeder_chain_formats_16,
  122         [FEEDER_CHAIN_32]        = feeder_chain_formats_32,
  123         [FEEDER_CHAIN_MULTI]     = feeder_chain_formats_multi,
  124         [FEEDER_CHAIN_FULLMULTI] = feeder_chain_formats_fullmulti
  125 };
  126 
  127 static int feeder_chain_mode = FEEDER_CHAIN_DEFAULT;
  128 
  129 #if defined(_KERNEL) && defined(SND_DEBUG) && defined(SND_FEEDER_FULL_MULTIFORMAT)
  130 SYSCTL_INT(_hw_snd, OID_AUTO, feeder_chain_mode, CTLFLAG_RWTUN,
  131     &feeder_chain_mode, 0,
  132     "feeder chain mode "
  133     "(0=lean, 1=16bit, 2=32bit, 3=multiformat, 4=fullmultiformat)");
  134 #endif
  135 
  136 /*
  137  * feeder_build_format(): Chain any format converter.
  138  */
  139 static int
  140 feeder_build_format(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  141 {
  142         struct feeder_class *fc;
  143         struct pcm_feederdesc *desc;
  144         int ret;
  145 
  146         desc = &(cdesc->desc);
  147         desc->type = FEEDER_FORMAT;
  148         desc->in = 0;
  149         desc->out = 0;
  150         desc->flags = 0;
  151 
  152         fc = feeder_getclass(desc);
  153         if (fc == NULL) {
  154                 device_printf(c->dev,
  155                     "%s(): can't find feeder_format\n", __func__);
  156                 return (ENOTSUP);
  157         }
  158 
  159         desc->in = cdesc->current.afmt;
  160         desc->out = cdesc->target.afmt;
  161 
  162         ret = chn_addfeeder(c, fc, desc);
  163         if (ret != 0) {
  164                 device_printf(c->dev,
  165                     "%s(): can't add feeder_format\n", __func__);
  166                 return (ret);
  167         }
  168 
  169         c->feederflags |= 1 << FEEDER_FORMAT;
  170 
  171         cdesc->current.afmt = cdesc->target.afmt;
  172 
  173         return (0);
  174 }
  175 
  176 /*
  177  * feeder_build_formatne(): Chain format converter that suite best for native
  178  *                          endian format.
  179  */
  180 static int
  181 feeder_build_formatne(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  182 {
  183         struct feeder_chain_state otarget;
  184         int ret;
  185 
  186         if (cdesc->afmt_ne == 0 ||
  187             AFMT_ENCODING(cdesc->current.afmt) == cdesc->afmt_ne)
  188                 return (0);
  189 
  190         otarget = cdesc->target;
  191         cdesc->target = cdesc->current;
  192         cdesc->target.afmt = SND_FORMAT(cdesc->afmt_ne,
  193             cdesc->current.matrix->channels, cdesc->current.matrix->ext);
  194 
  195         ret = feeder_build_format(c, cdesc);
  196         if (ret != 0)
  197                 return (ret);
  198 
  199         cdesc->target = otarget;
  200 
  201         return (0);
  202 }
  203 
  204 /*
  205  * feeder_build_rate(): Chain sample rate converter.
  206  */
  207 static int
  208 feeder_build_rate(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  209 {
  210         struct feeder_class *fc;
  211         struct pcm_feeder *f;
  212         struct pcm_feederdesc *desc;
  213         int ret;
  214 
  215         ret = feeder_build_formatne(c, cdesc);
  216         if (ret != 0)
  217                 return (ret);
  218 
  219         desc = &(cdesc->desc);
  220         desc->type = FEEDER_RATE;
  221         desc->in = 0;
  222         desc->out = 0;
  223         desc->flags = 0;
  224 
  225         fc = feeder_getclass(desc);
  226         if (fc == NULL) {
  227                 device_printf(c->dev,
  228                     "%s(): can't find feeder_rate\n", __func__);
  229                 return (ENOTSUP);
  230         }
  231 
  232         desc->in = cdesc->current.afmt;
  233         desc->out = desc->in;
  234 
  235         ret = chn_addfeeder(c, fc, desc);
  236         if (ret != 0) {
  237                 device_printf(c->dev,
  238                     "%s(): can't add feeder_rate\n", __func__);
  239                 return (ret);
  240         }
  241 
  242         f = c->feeder;
  243 
  244         /*
  245          * If in 'dummy' mode (possibly due to passthrough mode), set the
  246          * conversion quality to the lowest possible (should be fastest) since
  247          * listener won't be hearing anything. Theoretically we can just
  248          * disable it, but that will cause weird runtime behaviour:
  249          * application appear to play something that is either too fast or too
  250          * slow.
  251          */
  252         if (cdesc->dummy != 0) {
  253                 ret = FEEDER_SET(f, FEEDRATE_QUALITY, 0);
  254                 if (ret != 0) {
  255                         device_printf(c->dev,
  256                             "%s(): can't set resampling quality\n", __func__);
  257                         return (ret);
  258                 }
  259         }
  260 
  261         ret = FEEDER_SET(f, FEEDRATE_SRC, cdesc->current.rate);
  262         if (ret != 0) {
  263                 device_printf(c->dev,
  264                     "%s(): can't set source rate\n", __func__);
  265                 return (ret);
  266         }
  267 
  268         ret = FEEDER_SET(f, FEEDRATE_DST, cdesc->target.rate);
  269         if (ret != 0) {
  270                 device_printf(c->dev,
  271                     "%s(): can't set destination rate\n", __func__);
  272                 return (ret);
  273         }
  274 
  275         c->feederflags |= 1 << FEEDER_RATE;
  276 
  277         cdesc->current.rate = cdesc->target.rate;
  278 
  279         return (0);
  280 }
  281 
  282 /*
  283  * feeder_build_matrix(): Chain channel matrixing converter.
  284  */
  285 static int
  286 feeder_build_matrix(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  287 {
  288         struct feeder_class *fc;
  289         struct pcm_feeder *f;
  290         struct pcm_feederdesc *desc;
  291         int ret;
  292 
  293         ret = feeder_build_formatne(c, cdesc);
  294         if (ret != 0)
  295                 return (ret);
  296 
  297         desc = &(cdesc->desc);
  298         desc->type = FEEDER_MATRIX;
  299         desc->in = 0;
  300         desc->out = 0;
  301         desc->flags = 0;
  302 
  303         fc = feeder_getclass(desc);
  304         if (fc == NULL) {
  305                 device_printf(c->dev,
  306                     "%s(): can't find feeder_matrix\n", __func__);
  307                 return (ENOTSUP);
  308         }
  309 
  310         desc->in = cdesc->current.afmt;
  311         desc->out = SND_FORMAT(cdesc->current.afmt,
  312             cdesc->target.matrix->channels, cdesc->target.matrix->ext);
  313 
  314         ret = chn_addfeeder(c, fc, desc);
  315         if (ret != 0) {
  316                 device_printf(c->dev,
  317                     "%s(): can't add feeder_matrix\n", __func__);
  318                 return (ret);
  319         }
  320 
  321         f = c->feeder;
  322         ret = feeder_matrix_setup(f, cdesc->current.matrix,
  323             cdesc->target.matrix);
  324         if (ret != 0) {
  325                 device_printf(c->dev,
  326                     "%s(): feeder_matrix_setup() failed\n", __func__);
  327                 return (ret);
  328         }
  329 
  330         c->feederflags |= 1 << FEEDER_MATRIX;
  331 
  332         cdesc->current.afmt = desc->out;
  333         cdesc->current.matrix = cdesc->target.matrix;
  334         cdesc->use_matrix = 0;
  335 
  336         return (0);
  337 }
  338 
  339 /*
  340  * feeder_build_volume(): Chain soft volume.
  341  */
  342 static int
  343 feeder_build_volume(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  344 {
  345         struct feeder_class *fc;
  346         struct pcm_feeder *f;
  347         struct pcm_feederdesc *desc;
  348         int ret;
  349 
  350         ret = feeder_build_formatne(c, cdesc);
  351         if (ret != 0)
  352                 return (ret);
  353 
  354         desc = &(cdesc->desc);
  355         desc->type = FEEDER_VOLUME;
  356         desc->in = 0;
  357         desc->out = 0;
  358         desc->flags = 0;
  359 
  360         fc = feeder_getclass(desc);
  361         if (fc == NULL) {
  362                 device_printf(c->dev,
  363                     "%s(): can't find feeder_volume\n", __func__);
  364                 return (ENOTSUP);
  365         }
  366 
  367         desc->in = cdesc->current.afmt;
  368         desc->out = desc->in;
  369 
  370         ret = chn_addfeeder(c, fc, desc);
  371         if (ret != 0) {
  372                 device_printf(c->dev,
  373                     "%s(): can't add feeder_volume\n", __func__);
  374                 return (ret);
  375         }
  376 
  377         f = c->feeder;
  378 
  379         /*
  380          * If in 'dummy' mode (possibly due to passthrough mode), set BYPASS
  381          * mode since listener won't be hearing anything. Theoretically we can
  382          * just disable it, but that will confuse volume per channel mixer.
  383          */
  384         if (cdesc->dummy != 0) {
  385                 ret = FEEDER_SET(f, FEEDVOLUME_STATE, FEEDVOLUME_BYPASS);
  386                 if (ret != 0) {
  387                         device_printf(c->dev,
  388                             "%s(): can't set volume bypass\n", __func__);
  389                         return (ret);
  390                 }
  391         }
  392 
  393         ret = feeder_volume_apply_matrix(f, cdesc->current.matrix);
  394         if (ret != 0) {
  395                 device_printf(c->dev,
  396                     "%s(): feeder_volume_apply_matrix() failed\n", __func__);
  397                 return (ret);
  398         }
  399 
  400         c->feederflags |= 1 << FEEDER_VOLUME;
  401 
  402         cdesc->use_volume = 0;
  403 
  404         return (0);
  405 }
  406 
  407 /*
  408  * feeder_build_eq(): Chain parametric software equalizer.
  409  */
  410 static int
  411 feeder_build_eq(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  412 {
  413         struct feeder_class *fc;
  414         struct pcm_feeder *f;
  415         struct pcm_feederdesc *desc;
  416         int ret;
  417 
  418         ret = feeder_build_formatne(c, cdesc);
  419         if (ret != 0)
  420                 return (ret);
  421 
  422         desc = &(cdesc->desc);
  423         desc->type = FEEDER_EQ;
  424         desc->in = 0;
  425         desc->out = 0;
  426         desc->flags = 0;
  427 
  428         fc = feeder_getclass(desc);
  429         if (fc == NULL) {
  430                 device_printf(c->dev,
  431                     "%s(): can't find feeder_eq\n", __func__);
  432                 return (ENOTSUP);
  433         }
  434 
  435         desc->in = cdesc->current.afmt;
  436         desc->out = desc->in;
  437 
  438         ret = chn_addfeeder(c, fc, desc);
  439         if (ret != 0) {
  440                 device_printf(c->dev,
  441                     "%s(): can't add feeder_eq\n", __func__);
  442                 return (ret);
  443         }
  444 
  445         f = c->feeder;
  446 
  447         ret = FEEDER_SET(f, FEEDEQ_RATE, cdesc->current.rate);
  448         if (ret != 0) {
  449                 device_printf(c->dev,
  450                     "%s(): can't set rate on feeder_eq\n", __func__);
  451                 return (ret);
  452         }
  453 
  454         c->feederflags |= 1 << FEEDER_EQ;
  455 
  456         cdesc->use_eq = 0;
  457 
  458         return (0);
  459 }
  460 
  461 /*
  462  * feeder_build_root(): Chain root feeder, the top, father of all.
  463  */
  464 static int
  465 feeder_build_root(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  466 {
  467         struct feeder_class *fc;
  468         int ret;
  469 
  470         fc = feeder_getclass(NULL);
  471         if (fc == NULL) {
  472                 device_printf(c->dev,
  473                     "%s(): can't find feeder_root\n", __func__);
  474                 return (ENOTSUP);
  475         }
  476 
  477         ret = chn_addfeeder(c, fc, NULL);
  478         if (ret != 0) {
  479                 device_printf(c->dev,
  480                     "%s(): can't add feeder_root\n", __func__);
  481                 return (ret);
  482         }
  483 
  484         c->feederflags |= 1 << FEEDER_ROOT;
  485 
  486         c->feeder->desc->in = cdesc->current.afmt;
  487         c->feeder->desc->out = cdesc->current.afmt;
  488 
  489         return (0);
  490 }
  491 
  492 /*
  493  * feeder_build_mixer(): Chain software mixer for virtual channels.
  494  */
  495 static int
  496 feeder_build_mixer(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
  497 {
  498         struct feeder_class *fc;
  499         struct pcm_feederdesc *desc;
  500         int ret;
  501 
  502         desc = &(cdesc->desc);
  503         desc->type = FEEDER_MIXER;
  504         desc->in = 0;
  505         desc->out = 0;
  506         desc->flags = 0;
  507 
  508         fc = feeder_getclass(desc);
  509         if (fc == NULL) {
  510                 device_printf(c->dev,
  511                     "%s(): can't find feeder_mixer\n", __func__);
  512                 return (ENOTSUP);
  513         }
  514 
  515         desc->in = cdesc->current.afmt;
  516         desc->out = desc->in;
  517 
  518         ret = chn_addfeeder(c, fc, desc);
  519         if (ret != 0) {
  520                 device_printf(c->dev,
  521                     "%s(): can't add feeder_mixer\n", __func__);
  522                 return (ret);
  523         }
  524 
  525         c->feederflags |= 1 << FEEDER_MIXER;
  526 
  527         return (0);
  528 }
  529 
  530 /* Macrosses to ease our job doing stuffs later. */
  531 #define FEEDER_BW(c, t)         ((c)->t.matrix->channels * (c)->t.rate)
  532 
  533 #define FEEDRATE_UP(c)          ((c)->target.rate > (c)->current.rate)
  534 #define FEEDRATE_DOWN(c)        ((c)->target.rate < (c)->current.rate)
  535 #define FEEDRATE_REQUIRED(c)    (FEEDRATE_UP(c) || FEEDRATE_DOWN(c))
  536 
  537 #define FEEDMATRIX_UP(c)        ((c)->target.matrix->channels >         \
  538                                  (c)->current.matrix->channels)
  539 #define FEEDMATRIX_DOWN(c)      ((c)->target.matrix->channels <         \
  540                                  (c)->current.matrix->channels)
  541 #define FEEDMATRIX_REQUIRED(c)  (FEEDMATRIX_UP(c) ||                    \
  542                                  FEEDMATRIX_DOWN(c) || (c)->use_matrix != 0)
  543 
  544 #define FEEDFORMAT_REQUIRED(c)  (AFMT_ENCODING((c)->current.afmt) !=    \
  545                                  AFMT_ENCODING((c)->target.afmt))
  546 
  547 #define FEEDVOLUME_REQUIRED(c)  ((c)->use_volume != 0)
  548 
  549 #define FEEDEQ_VALIDRATE(c, t)  (feeder_eq_validrate((c)->t.rate) != 0)
  550 #define FEEDEQ_ECONOMY(c)       (FEEDER_BW(c, current) < FEEDER_BW(c, target))
  551 #define FEEDEQ_REQUIRED(c)      ((c)->use_eq != 0 &&                    \
  552                                  FEEDEQ_VALIDRATE(c, current))
  553 
  554 #define FEEDFORMAT_NE_REQUIRED(c)                                       \
  555         ((c)->afmt_ne != AFMT_S32_NE &&                                 \
  556         (((c)->mode == FEEDER_CHAIN_16 &&                               \
  557         AFMT_ENCODING((c)->current.afmt) != AFMT_S16_NE) ||             \
  558         ((c)->mode == FEEDER_CHAIN_32 &&                                \
  559         AFMT_ENCODING((c)->current.afmt) != AFMT_S32_NE) ||             \
  560         (c)->mode == FEEDER_CHAIN_FULLMULTI ||                          \
  561         ((c)->mode == FEEDER_CHAIN_MULTI &&                             \
  562         ((c)->current.afmt & AFMT_8BIT)) ||                             \
  563         ((c)->mode == FEEDER_CHAIN_LEAN &&                              \
  564         !((c)->current.afmt & (AFMT_S16_NE | AFMT_S32_NE)))))
  565 
  566 static void
  567 feeder_default_matrix(struct pcmchan_matrix *m, uint32_t fmt, int id)
  568 {
  569         int x;
  570 
  571         memset(m, 0, sizeof(*m));
  572 
  573         m->id = id;
  574         m->channels = AFMT_CHANNEL(fmt);
  575         m->ext = AFMT_EXTCHANNEL(fmt);
  576         for (x = 0; x != SND_CHN_T_MAX; x++)
  577                 m->offset[x] = -1;
  578 }
  579 
  580 int
  581 feeder_chain(struct pcm_channel *c)
  582 {
  583         struct snddev_info *d;
  584         struct pcmchan_caps *caps;
  585         struct feeder_chain_desc cdesc;
  586         struct pcmchan_matrix *hwmatrix, *softmatrix;
  587         uint32_t hwfmt, softfmt;
  588         int ret;
  589 
  590         CHN_LOCKASSERT(c);
  591 
  592         /* Remove everything first. */
  593         while (chn_removefeeder(c) == 0)
  594                 ;
  595 
  596         KASSERT(c->feeder == NULL, ("feeder chain not empty"));
  597 
  598         /* clear and populate chain descriptor. */
  599         bzero(&cdesc, sizeof(cdesc));
  600 
  601         switch (feeder_chain_mode) {
  602         case FEEDER_CHAIN_LEAN:
  603         case FEEDER_CHAIN_16:
  604         case FEEDER_CHAIN_32:
  605 #if defined(SND_FEEDER_MULTIFORMAT) || defined(SND_FEEDER_FULL_MULTIFORMAT)
  606         case FEEDER_CHAIN_MULTI:
  607 #endif
  608 #if defined(SND_FEEDER_FULL_MULTIFORMAT)
  609         case FEEDER_CHAIN_FULLMULTI:
  610 #endif
  611                 break;
  612         default:
  613                 feeder_chain_mode = FEEDER_CHAIN_DEFAULT;
  614                 break;
  615         }
  616 
  617         cdesc.mode = feeder_chain_mode;
  618         cdesc.expensive = 1;    /* XXX faster.. */
  619 
  620 #define VCHAN_PASSTHROUGH(c)    (((c)->flags & (CHN_F_VIRTUAL |         \
  621                                  CHN_F_PASSTHROUGH)) ==                 \
  622                                  (CHN_F_VIRTUAL | CHN_F_PASSTHROUGH))
  623 
  624         /* Get the best possible hardware format. */
  625         if (VCHAN_PASSTHROUGH(c))
  626                 hwfmt = c->parentchannel->format;
  627         else {
  628                 caps = chn_getcaps(c);
  629                 if (caps == NULL || caps->fmtlist == NULL) {
  630                         device_printf(c->dev,
  631                             "%s(): failed to get channel caps\n", __func__);
  632                         return (ENODEV);
  633                 }
  634 
  635                 if ((c->format & AFMT_PASSTHROUGH) &&
  636                     !snd_fmtvalid(c->format, caps->fmtlist))
  637                         return (ENODEV);
  638 
  639                 hwfmt = snd_fmtbest(c->format, caps->fmtlist);
  640                 if (hwfmt == 0 || !snd_fmtvalid(hwfmt, caps->fmtlist)) {
  641                         device_printf(c->dev,
  642                             "%s(): invalid hardware format 0x%08x\n",
  643                             __func__, hwfmt);
  644                         {
  645                                 int i;
  646                                 for (i = 0; caps->fmtlist[i] != 0; i++)
  647                                         printf("0x%08x\n", caps->fmtlist[i]);
  648                                 printf("Req: 0x%08x\n", c->format);
  649                         }
  650                         return (ENODEV);
  651                 }
  652         }
  653 
  654         /*
  655          * The 'hardware' possibly have different intepretation of channel
  656          * matrixing, so get it first .....
  657          */
  658         hwmatrix = CHANNEL_GETMATRIX(c->methods, c->devinfo, hwfmt);
  659         if (hwmatrix == NULL) {
  660                 /* setup a default matrix */
  661                 hwmatrix = &c->matrix_scratch;
  662                 feeder_default_matrix(hwmatrix, hwfmt,
  663                     SND_CHN_MATRIX_UNKNOWN);
  664         }
  665         /* ..... and rebuild hwfmt. */
  666         hwfmt = SND_FORMAT(hwfmt, hwmatrix->channels, hwmatrix->ext);
  667 
  668         /* Reset and rebuild default channel format/matrix map. */
  669         softfmt = c->format;
  670         softmatrix = &c->matrix;
  671         if (softmatrix->channels != AFMT_CHANNEL(softfmt) ||
  672             softmatrix->ext != AFMT_EXTCHANNEL(softfmt)) {
  673                 softmatrix = feeder_matrix_format_map(softfmt);
  674                 if (softmatrix == NULL) {
  675                         /* setup a default matrix */
  676                         softmatrix = &c->matrix;
  677                         feeder_default_matrix(softmatrix, softfmt,
  678                             SND_CHN_MATRIX_PCMCHANNEL);
  679                 } else {
  680                         c->matrix = *softmatrix;
  681                         c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL;
  682                 }
  683         }
  684         softfmt = SND_FORMAT(softfmt, softmatrix->channels, softmatrix->ext);
  685         if (softfmt != c->format)
  686                 device_printf(c->dev,
  687                     "%s(): WARNING: %s Soft format 0x%08x -> 0x%08x\n",
  688                     __func__, CHN_DIRSTR(c), c->format, softfmt);
  689 
  690         /*
  691          * PLAY and REC are opposite.
  692          */
  693         if (c->direction == PCMDIR_PLAY) {
  694                 cdesc.origin.afmt    = softfmt;
  695                 cdesc.origin.matrix  = softmatrix;
  696                 cdesc.origin.rate    = c->speed;
  697                 cdesc.target.afmt    = hwfmt;
  698                 cdesc.target.matrix  = hwmatrix;
  699                 cdesc.target.rate    = sndbuf_getspd(c->bufhard);
  700         } else {
  701                 cdesc.origin.afmt    = hwfmt;
  702                 cdesc.origin.matrix  = hwmatrix;
  703                 cdesc.origin.rate    = sndbuf_getspd(c->bufhard);
  704                 cdesc.target.afmt    = softfmt;
  705                 cdesc.target.matrix  = softmatrix;
  706                 cdesc.target.rate    = c->speed;
  707         }
  708 
  709         d = c->parentsnddev;
  710 
  711         /*
  712          * If channel is in bitperfect or passthrough mode, make it appear
  713          * that 'origin' and 'target' identical, skipping mostly chain
  714          * procedures.
  715          */
  716         if (CHN_BITPERFECT(c) || (c->format & AFMT_PASSTHROUGH)) {
  717                 if (c->direction == PCMDIR_PLAY)
  718                         cdesc.origin = cdesc.target;
  719                 else
  720                         cdesc.target = cdesc.origin;
  721                 c->format = cdesc.target.afmt;
  722                 c->speed  = cdesc.target.rate;
  723         } else {
  724                 /* hwfmt is not convertible, so 'dummy' it. */
  725                 if (hwfmt & AFMT_PASSTHROUGH)
  726                         cdesc.dummy = 1;
  727 
  728                 if ((softfmt & AFMT_CONVERTIBLE) &&
  729                     (((d->flags & SD_F_VPC) && !(c->flags & CHN_F_HAS_VCHAN)) ||
  730                     (!(d->flags & SD_F_VPC) && (d->flags & SD_F_SOFTPCMVOL) &&
  731                     !(c->flags & CHN_F_VIRTUAL))))
  732                         cdesc.use_volume = 1;
  733 
  734                 if (feeder_matrix_compare(cdesc.origin.matrix,
  735                     cdesc.target.matrix) != 0)
  736                         cdesc.use_matrix = 1;
  737 
  738                 /* Soft EQ only applicable for PLAY. */
  739                 if (cdesc.dummy == 0 &&
  740                     c->direction == PCMDIR_PLAY && (d->flags & SD_F_EQ) &&
  741                     (((d->flags & SD_F_EQ_PC) &&
  742                     !(c->flags & CHN_F_HAS_VCHAN)) ||
  743                     (!(d->flags & SD_F_EQ_PC) && !(c->flags & CHN_F_VIRTUAL))))
  744                         cdesc.use_eq = 1;
  745 
  746                 if (FEEDFORMAT_NE_REQUIRED(&cdesc)) {
  747                         cdesc.afmt_ne =
  748                             (cdesc.dummy != 0) ?
  749                             snd_fmtbest(AFMT_ENCODING(softfmt),
  750                             feeder_chain_formats[cdesc.mode]) :
  751                             snd_fmtbest(AFMT_ENCODING(cdesc.target.afmt),
  752                             feeder_chain_formats[cdesc.mode]);
  753                         if (cdesc.afmt_ne == 0) {
  754                                 device_printf(c->dev,
  755                                     "%s(): snd_fmtbest failed!\n", __func__);
  756                                 cdesc.afmt_ne =
  757                                     (((cdesc.dummy != 0) ? softfmt :
  758                                     cdesc.target.afmt) &
  759                                     (AFMT_24BIT | AFMT_32BIT)) ?
  760                                     AFMT_S32_NE : AFMT_S16_NE;
  761                         }
  762                 }
  763         }
  764 
  765         cdesc.current = cdesc.origin;
  766 
  767         /* Build everything. */
  768 
  769         c->feederflags = 0;
  770 
  771 #define FEEDER_BUILD(t) do {                                            \
  772         ret = feeder_build_##t(c, &cdesc);                              \
  773         if (ret != 0)                                                   \
  774                 return (ret);                                           \
  775         } while (0)
  776 
  777         if (!(c->flags & CHN_F_HAS_VCHAN) || c->direction == PCMDIR_REC)
  778                 FEEDER_BUILD(root);
  779         else if (c->direction == PCMDIR_PLAY && (c->flags & CHN_F_HAS_VCHAN))
  780                 FEEDER_BUILD(mixer);
  781         else
  782                 return (ENOTSUP);
  783 
  784         /*
  785          * The basic idea is: The smaller the bandwidth, the cheaper the
  786          * conversion process, with following constraints:-
  787          *
  788          * 1) Almost all feeders work best in 16/32 native endian.
  789          * 2) Try to avoid 8bit feeders due to poor dynamic range.
  790          * 3) Avoid volume, format, matrix and rate in BITPERFECT or
  791          *    PASSTHROUGH mode.
  792          * 4) Try putting volume before EQ or rate. Should help to
  793          *    avoid/reduce possible clipping.
  794          * 5) EQ require specific, valid rate, unless it allow sloppy
  795          *    conversion.
  796          */
  797         if (FEEDMATRIX_UP(&cdesc)) {
  798                 if (FEEDEQ_REQUIRED(&cdesc) &&
  799                     (!FEEDEQ_VALIDRATE(&cdesc, target) ||
  800                     (cdesc.expensive == 0 && FEEDEQ_ECONOMY(&cdesc))))
  801                         FEEDER_BUILD(eq);
  802                 if (FEEDRATE_REQUIRED(&cdesc))
  803                         FEEDER_BUILD(rate);
  804                 FEEDER_BUILD(matrix);
  805                 if (FEEDVOLUME_REQUIRED(&cdesc))
  806                         FEEDER_BUILD(volume);
  807                 if (FEEDEQ_REQUIRED(&cdesc))
  808                         FEEDER_BUILD(eq);
  809         } else if (FEEDMATRIX_DOWN(&cdesc)) {
  810                 FEEDER_BUILD(matrix);
  811                 if (FEEDVOLUME_REQUIRED(&cdesc))
  812                         FEEDER_BUILD(volume);
  813                 if (FEEDEQ_REQUIRED(&cdesc) &&
  814                     (!FEEDEQ_VALIDRATE(&cdesc, target) ||
  815                     FEEDEQ_ECONOMY(&cdesc)))
  816                         FEEDER_BUILD(eq);
  817                 if (FEEDRATE_REQUIRED(&cdesc))
  818                         FEEDER_BUILD(rate);
  819                 if (FEEDEQ_REQUIRED(&cdesc))
  820                         FEEDER_BUILD(eq);
  821         } else {
  822                 if (FEEDRATE_DOWN(&cdesc)) {
  823                         if (FEEDEQ_REQUIRED(&cdesc) &&
  824                             !FEEDEQ_VALIDRATE(&cdesc, target)) {
  825                                 if (FEEDVOLUME_REQUIRED(&cdesc))
  826                                         FEEDER_BUILD(volume);
  827                                 FEEDER_BUILD(eq);
  828                         }
  829                         FEEDER_BUILD(rate);
  830                 }
  831                 if (FEEDMATRIX_REQUIRED(&cdesc))
  832                         FEEDER_BUILD(matrix);
  833                 if (FEEDVOLUME_REQUIRED(&cdesc))
  834                         FEEDER_BUILD(volume);
  835                 if (FEEDRATE_UP(&cdesc)) {
  836                         if (FEEDEQ_REQUIRED(&cdesc) &&
  837                             !FEEDEQ_VALIDRATE(&cdesc, target))
  838                                 FEEDER_BUILD(eq);
  839                         FEEDER_BUILD(rate);
  840                 }
  841                 if (FEEDEQ_REQUIRED(&cdesc))
  842                         FEEDER_BUILD(eq);
  843         }
  844 
  845         if (FEEDFORMAT_REQUIRED(&cdesc))
  846                 FEEDER_BUILD(format);
  847 
  848         if (c->direction == PCMDIR_REC && (c->flags & CHN_F_HAS_VCHAN))
  849                 FEEDER_BUILD(mixer);
  850 
  851         sndbuf_setfmt(c->bufsoft, c->format);
  852         sndbuf_setspd(c->bufsoft, c->speed);
  853 
  854         sndbuf_setfmt(c->bufhard, hwfmt);
  855 
  856         chn_syncstate(c);
  857 
  858         return (0);
  859 }

Cache object: 8a37938d0dfc3e33340bd67be85f1a16


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