feeder_format.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
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 /*
   30  * feeder_format: New generation of generic, any-to-any format converter, as
   31  *                long as the sample values can be read _and_ write.
   32  */
   33 
   34 #ifdef _KERNEL
   35 #ifdef HAVE_KERNEL_OPTION_HEADERS
   36 #include "opt_snd.h"
   37 #endif
   38 #include <dev/sound/pcm/sound.h>
   39 #include <dev/sound/pcm/pcm.h>
   40 #include <dev/sound/pcm/g711.h>
   41 #include <dev/sound/pcm/intpcm.h>
   42 #include "feeder_if.h"
   43 
   44 #define SND_USE_FXDIV
   45 #include "snd_fxdiv_gen.h"
   46 
   47 SND_DECLARE_FILE("$FreeBSD$");
   48 #endif
   49 
   50 #define FEEDFORMAT_RESERVOIR    (SND_CHN_MAX * PCM_32_BPS)
   51 
   52 INTPCM_DECLARE(intpcm_conv_tables)
   53 
   54 struct feed_format_info {
   55         uint32_t ibps, obps;
   56         uint32_t ialign, oalign, channels;
   57         intpcm_read_t *read;
   58         intpcm_write_t *write;
   59         uint8_t reservoir[FEEDFORMAT_RESERVOIR];
   60 };
   61 
   62 /*
   63  * dummy ac3/dts passthrough, etc.
   64  * XXX assume as s16le.
   65  */
   66 static __inline intpcm_t
   67 intpcm_read_null(uint8_t *src __unused)
   68 {
   69 
   70         return (0);
   71 }
   72 
   73 static __inline void
   74 intpcm_write_null(uint8_t *dst, intpcm_t v __unused)
   75 {
   76 
   77         _PCM_WRITE_S16_LE(dst, 0);
   78 }
   79 
   80 #define FEEDFORMAT_ENTRY(SIGN, BIT, ENDIAN)                             \
   81         {                                                               \
   82                 AFMT_##SIGN##BIT##_##ENDIAN,                            \
   83                 intpcm_read_##SIGN##BIT##ENDIAN,                        \
   84                 intpcm_write_##SIGN##BIT##ENDIAN                        \
   85         }
   86 
   87 static const struct {
   88         uint32_t format;
   89         intpcm_read_t *read;
   90         intpcm_write_t *write;
   91 } feed_format_ops[] = {
   92         FEEDFORMAT_ENTRY(S,  8, NE),
   93         FEEDFORMAT_ENTRY(S, 16, LE),
   94         FEEDFORMAT_ENTRY(S, 24, LE),
   95         FEEDFORMAT_ENTRY(S, 32, LE),
   96         FEEDFORMAT_ENTRY(S, 16, BE),
   97         FEEDFORMAT_ENTRY(S, 24, BE),
   98         FEEDFORMAT_ENTRY(S, 32, BE),
   99         FEEDFORMAT_ENTRY(U,  8, NE),
  100         FEEDFORMAT_ENTRY(U, 16, LE),
  101         FEEDFORMAT_ENTRY(U, 24, LE),
  102         FEEDFORMAT_ENTRY(U, 32, LE),
  103         FEEDFORMAT_ENTRY(U, 16, BE),
  104         FEEDFORMAT_ENTRY(U, 24, BE),
  105         FEEDFORMAT_ENTRY(U, 32, BE),
  106         {
  107                 AFMT_MU_LAW,
  108                 intpcm_read_ulaw, intpcm_write_ulaw
  109         },
  110         {
  111                 AFMT_A_LAW,
  112                 intpcm_read_alaw, intpcm_write_alaw
  113         },
  114         {
  115                 AFMT_AC3,
  116                 intpcm_read_null, intpcm_write_null
  117         }
  118 };
  119 
  120 #define FEEDFORMAT_TAB_SIZE                                             \
  121         ((int32_t)(sizeof(feed_format_ops) / sizeof(feed_format_ops[0])))
  122 
  123 static int
  124 feed_format_init(struct pcm_feeder *f)
  125 {
  126         struct feed_format_info *info;
  127         intpcm_read_t *rd_op;
  128         intpcm_write_t *wr_op;
  129         int i;
  130 
  131         if (f->desc->in == f->desc->out ||
  132             AFMT_CHANNEL(f->desc->in) != AFMT_CHANNEL(f->desc->out))
  133                 return (EINVAL);
  134 
  135         rd_op = NULL;
  136         wr_op = NULL;
  137 
  138         for (i = 0; i < FEEDFORMAT_TAB_SIZE &&
  139             (rd_op == NULL || wr_op == NULL); i++) {
  140                 if (rd_op == NULL &&
  141                     AFMT_ENCODING(f->desc->in) == feed_format_ops[i].format)
  142                         rd_op = feed_format_ops[i].read;
  143                 if (wr_op == NULL &&
  144                     AFMT_ENCODING(f->desc->out) == feed_format_ops[i].format)
  145                         wr_op = feed_format_ops[i].write;
  146         }
  147 
  148         if (rd_op == NULL || wr_op == NULL) {
  149                 printf("%s(): failed to initialize io ops "
  150                     "in=0x%08x out=0x%08x\n",
  151                     __func__, f->desc->in, f->desc->out);
  152                 return (EINVAL);
  153         }
  154 
  155         info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
  156         if (info == NULL)
  157                 return (ENOMEM);
  158 
  159         info->channels = AFMT_CHANNEL(f->desc->in);
  160 
  161         info->ibps = AFMT_BPS(f->desc->in);
  162         info->ialign = info->ibps * info->channels;
  163         info->read = rd_op;
  164 
  165         info->obps = AFMT_BPS(f->desc->out);
  166         info->oalign = info->obps * info->channels;
  167         info->write = wr_op;
  168 
  169         f->data = info;
  170 
  171         return (0);
  172 }
  173 
  174 static int
  175 feed_format_free(struct pcm_feeder *f)
  176 {
  177         struct feed_format_info *info;
  178 
  179         info = f->data;
  180         if (info != NULL)
  181                 free(info, M_DEVBUF);
  182 
  183         f->data = NULL;
  184 
  185         return (0);
  186 }
  187 
  188 static int
  189 feed_format_set(struct pcm_feeder *f, int what, int value)
  190 {
  191         struct feed_format_info *info;
  192 
  193         info = f->data;
  194 
  195         switch (what) {
  196         case FEEDFORMAT_CHANNELS:
  197                 if (value < SND_CHN_MIN || value > SND_CHN_MAX)
  198                         return (EINVAL);
  199                 info->channels = (uint32_t)value;
  200                 info->ialign = info->ibps * info->channels;
  201                 info->oalign = info->obps * info->channels;
  202                 break;
  203         default:
  204                 return (EINVAL);
  205                 break;
  206         }
  207 
  208         return (0);
  209 }
  210 
  211 static int
  212 feed_format_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
  213     uint32_t count, void *source)
  214 {
  215         struct feed_format_info *info;
  216         intpcm_t v;
  217         uint32_t j;
  218         uint8_t *src, *dst;
  219 
  220         info = f->data;
  221         dst = b;
  222         count = SND_FXROUND(count, info->oalign);
  223 
  224         do {
  225                 if (count < info->oalign)
  226                         break;
  227 
  228                 if (count < info->ialign) {
  229                         src = info->reservoir;
  230                         j = info->ialign;
  231                 } else {
  232                         if (info->ialign == info->oalign)
  233                                 j = count;
  234                         else if (info->ialign > info->oalign)
  235                                 j = SND_FXROUND(count, info->ialign);
  236                         else
  237                                 j = SND_FXDIV(count, info->oalign) *
  238                                     info->ialign;
  239                         src = dst + count - j;
  240                 }
  241 
  242                 j = SND_FXDIV(FEEDER_FEED(f->source, c, src, j, source),
  243                     info->ialign);
  244                 if (j == 0)
  245                         break;
  246 
  247                 j *= info->channels;
  248                 count -= j * info->obps;
  249 
  250                 do {
  251                         v = info->read(src);
  252                         info->write(dst, v);
  253                         dst += info->obps;
  254                         src += info->ibps;
  255                 } while (--j != 0);
  256 
  257         } while (count != 0);
  258 
  259         return (dst - b);
  260 }
  261 
  262 static struct pcm_feederdesc feeder_format_desc[] = {
  263         { FEEDER_FORMAT, 0, 0, 0, 0 },
  264         { 0, 0, 0, 0, 0 }
  265 };
  266 
  267 static kobj_method_t feeder_format_methods[] = {
  268         KOBJMETHOD(feeder_init,         feed_format_init),
  269         KOBJMETHOD(feeder_free,         feed_format_free),
  270         KOBJMETHOD(feeder_set,          feed_format_set),
  271         KOBJMETHOD(feeder_feed,         feed_format_feed),
  272         KOBJMETHOD_END
  273 };
  274 
  275 FEEDER_DECLARE(feeder_format, NULL);
  276 
  277 /* Extern */
  278 intpcm_read_t *
  279 feeder_format_read_op(uint32_t format)
  280 {
  281         int i;
  282 
  283         for (i = 0; i < FEEDFORMAT_TAB_SIZE; i++) {
  284                 if (AFMT_ENCODING(format) == feed_format_ops[i].format)
  285                         return (feed_format_ops[i].read);
  286         }
  287 
  288         return (NULL);
  289 }
  290 
  291 intpcm_write_t *
  292 feeder_format_write_op(uint32_t format)
  293 {
  294         int i;
  295 
  296         for (i = 0; i < FEEDFORMAT_TAB_SIZE; i++) {
  297                 if (AFMT_ENCODING(format) == feed_format_ops[i].format)
  298                         return (feed_format_ops[i].write);
  299         }
  300 
  301         return (NULL);
  302 }

Cache object: 2734b68f8242886e7caa7fb4f2580805

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

FreeBSD/Linux Kernel Cross Reference sys/dev/sound/pcm/feeder_format.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/pcm/feeder_format.c