sys/dev/sound/pcm/feeder_mixer.c

   1 /*-
   2  * Copyright (c) 2008-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 #ifdef _KERNEL
  28 #ifdef HAVE_KERNEL_OPTION_HEADERS
  29 #include "opt_snd.h"
  30 #endif
  31 #include <dev/sound/pcm/sound.h>
  32 #include <dev/sound/pcm/pcm.h>
  33 #include <dev/sound/pcm/vchan.h>
  34 #include "feeder_if.h"
  35
  36 #define SND_USE_FXDIV
  37 #include "snd_fxdiv_gen.h"
  38
  39 SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pcm/feeder_mixer.c 193640 2009-06-07 19:12:08Z ariff $");
  40 #endif
  41
  42 #undef SND_FEEDER_MULTIFORMAT
  43 #define SND_FEEDER_MULTIFORMAT  1
  44
  45 typedef void (*feed_mixer_t)(uint8_t *, uint8_t *, uint32_t);
  46
  47 #define FEEDMIXER_DECLARE(SIGN, BIT, ENDIAN)                            \
  48 static void                                                             \
  49 feed_mixer_##SIGN##BIT##ENDIAN(uint8_t *src, uint8_t *dst,              \
  50     uint32_t count)                                                     \
  51 {                                                                       \
  52         intpcm##BIT##_t z;                                              \
  53         intpcm_t x, y;                                                  \
  54                                                                         \
  55         src += count;                                                   \
  56         dst += count;                                                   \
  57                                                                         \
  58         do {                                                            \
  59                 src -= PCM_##BIT##_BPS;                                 \
  60                 dst -= PCM_##BIT##_BPS;                                 \
  61                 count -= PCM_##BIT##_BPS;                               \
  62                 x = PCM_READ_##SIGN##BIT##_##ENDIAN(src);               \
  63                 y = PCM_READ_##SIGN##BIT##_##ENDIAN(dst);               \
  64                 z = INTPCM##BIT##_T(x) + y;                             \
  65                 x = PCM_CLAMP_##SIGN##BIT(z);                           \
  66                 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x);              \
  67         } while (count != 0);                                           \
  68 }
  69
  70 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
  71 FEEDMIXER_DECLARE(S, 16, LE)
  72 FEEDMIXER_DECLARE(S, 32, LE)
  73 #endif
  74 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
  75 FEEDMIXER_DECLARE(S, 16, BE)
  76 FEEDMIXER_DECLARE(S, 32, BE)
  77 #endif
  78 #ifdef SND_FEEDER_MULTIFORMAT
  79 FEEDMIXER_DECLARE(S,  8, NE)
  80 FEEDMIXER_DECLARE(S, 24, LE)
  81 FEEDMIXER_DECLARE(S, 24, BE)
  82 FEEDMIXER_DECLARE(U,  8, NE)
  83 FEEDMIXER_DECLARE(U, 16, LE)
  84 FEEDMIXER_DECLARE(U, 24, LE)
  85 FEEDMIXER_DECLARE(U, 32, LE)
  86 FEEDMIXER_DECLARE(U, 16, BE)
  87 FEEDMIXER_DECLARE(U, 24, BE)
  88 FEEDMIXER_DECLARE(U, 32, BE)
  89 #endif
  90
  91 struct feed_mixer_info {
  92         uint32_t format;
  93         int bps;
  94         feed_mixer_t mix;
  95 };
  96
  97 #define FEEDMIXER_ENTRY(SIGN, BIT, ENDIAN)                              \
  98         {                                                               \
  99                 AFMT_##SIGN##BIT##_##ENDIAN, PCM_##BIT##_BPS,           \
 100                 feed_mixer_##SIGN##BIT##ENDIAN                          \
 101         }
 102
 103 static struct feed_mixer_info feed_mixer_info_tab[] = {
 104         FEEDMIXER_ENTRY(S,  8, NE),
 105 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
 106         FEEDMIXER_ENTRY(S, 16, LE),
 107         FEEDMIXER_ENTRY(S, 32, LE),
 108 #endif
 109 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
 110         FEEDMIXER_ENTRY(S, 16, BE),
 111         FEEDMIXER_ENTRY(S, 32, BE),
 112 #endif
 113 #ifdef SND_FEEDER_MULTIFORMAT
 114         FEEDMIXER_ENTRY(S, 24, LE),
 115         FEEDMIXER_ENTRY(S, 24, BE),
 116         FEEDMIXER_ENTRY(U,  8, NE),
 117         FEEDMIXER_ENTRY(U, 16, LE),
 118         FEEDMIXER_ENTRY(U, 24, LE),
 119         FEEDMIXER_ENTRY(U, 32, LE),
 120         FEEDMIXER_ENTRY(U, 16, BE),
 121         FEEDMIXER_ENTRY(U, 24, BE),
 122         FEEDMIXER_ENTRY(U, 32, BE),
 123 #endif
 124         {    AFMT_AC3, PCM_16_BPS, NULL },
 125         { AFMT_MU_LAW,  PCM_8_BPS, feed_mixer_U8NE },   /* dummy */
 126         {  AFMT_A_LAW,  PCM_8_BPS, feed_mixer_U8NE }    /* dummy */
 127 };
 128
 129 #define FEEDMIXER_TAB_SIZE      ((int32_t)                              \
 130                                  (sizeof(feed_mixer_info_tab) /         \
 131                                   sizeof(feed_mixer_info_tab[0])))
 132
 133 #define FEEDMIXER_DATA(i, c)    ((void *)                               \
 134                                  ((uintptr_t)((((i) & 0x1f) << 5) |     \
 135                                  ((c) & 0x1f))))
 136 #define FEEDMIXER_INFOIDX(d)    ((uint32_t)((uintptr_t)(d) >> 5) & 0x1f)
 137 #define FEEDMIXER_CHANNELS(d)   ((uint32_t)((uintptr_t)(d)) & 0x1f)
 138
 139 static int
 140 feed_mixer_init(struct pcm_feeder *f)
 141 {
 142         int i;
 143
 144         if (f->desc->in != f->desc->out)
 145                 return (EINVAL);
 146
 147         for (i = 0; i < FEEDMIXER_TAB_SIZE; i++) {
 148                 if (AFMT_ENCODING(f->desc->in) ==
 149                     feed_mixer_info_tab[i].format) {
 150                         f->data =
 151                             FEEDMIXER_DATA(i, AFMT_CHANNEL(f->desc->in));
 152                         return (0);
 153                 }
 154         }
 155
 156         return (EINVAL);
 157 }
 158
 159 static int
 160 feed_mixer_set(struct pcm_feeder *f, int what, int value)
 161 {
 162
 163         switch (what) {
 164         case FEEDMIXER_CHANNELS:
 165                 if (value < SND_CHN_MIN || value > SND_CHN_MAX)
 166                         return (EINVAL);
 167                 f->data = FEEDMIXER_DATA(FEEDMIXER_INFOIDX(f->data), value);
 168                 break;
 169         default:
 170                 return (EINVAL);
 171                 break;
 172         }
 173
 174         return (0);
 175 }
 176
 177 static __inline int
 178 feed_mixer_rec(struct pcm_channel *c)
 179 {
 180         struct pcm_channel *ch;
 181         struct snd_dbuf *b, *bs;
 182         uint32_t cnt, maxfeed;
 183         int rdy;
 184
 185         /*
 186          * Reset ready and moving pointer. We're not using bufsoft
 187          * anywhere since its sole purpose is to become the primary
 188          * distributor for the recorded buffer and also as an interrupt
 189          * threshold progress indicator.
 190          */
 191         b = c->bufsoft;
 192         b->rp = 0;
 193         b->rl = 0;
 194         cnt = sndbuf_getsize(b);
 195         maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(b));
 196
 197         do {
 198                 cnt = FEEDER_FEED(c->feeder->source, c, b->tmpbuf,
 199                     min(cnt, maxfeed), c->bufhard);
 200                 if (cnt != 0) {
 201                         sndbuf_acquire(b, b->tmpbuf, cnt);
 202                         cnt = sndbuf_getfree(b);
 203                 }
 204         } while (cnt != 0);
 205
 206         /* Not enough data */
 207         if (b->rl < sndbuf_getalign(b)) {
 208                 b->rl = 0;
 209                 return (0);
 210         }
 211
 212         /*
 213          * Keep track of ready and moving pointer since we will use
 214          * bufsoft over and over again, pretending nothing has happened.
 215          */
 216         rdy = b->rl;
 217
 218         CHN_FOREACH(ch, c, children.busy) {
 219                 CHN_LOCK(ch);
 220                 if (CHN_STOPPED(ch) || (ch->flags & CHN_F_DIRTY)) {
 221                         CHN_UNLOCK(ch);
 222                         continue;
 223                 }
 224 #ifdef SND_DEBUG
 225                 if ((c->flags & CHN_F_DIRTY) && VCHAN_SYNC_REQUIRED(ch)) {
 226                         if (vchan_sync(ch) != 0) {
 227                                 CHN_UNLOCK(ch);
 228                                 continue;
 229                         }
 230                 }
 231 #endif
 232                 bs = ch->bufsoft;
 233                 if (ch->flags & CHN_F_MMAP)
 234                         sndbuf_dispose(bs, NULL, sndbuf_getready(bs));
 235                 cnt = sndbuf_getfree(bs);
 236                 if (cnt < sndbuf_getalign(bs)) {
 237                         CHN_UNLOCK(ch);
 238                         continue;
 239                 }
 240                 maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(bs));
 241                 do {
 242                         cnt = FEEDER_FEED(ch->feeder, ch, bs->tmpbuf,
 243                             min(cnt, maxfeed), b);
 244                         if (cnt != 0) {
 245                                 sndbuf_acquire(bs, bs->tmpbuf, cnt);
 246                                 cnt = sndbuf_getfree(bs);
 247                         }
 248                 } while (cnt != 0);
 249                 /*
 250                  * Not entirely flushed out...
 251                  */
 252                 if (b->rl != 0)
 253                         ch->xruns++;
 254                 CHN_UNLOCK(ch);
 255                 /*
 256                  * Rewind buffer position for next virtual channel.
 257                  */
 258                 b->rp = 0;
 259                 b->rl = rdy;
 260         }
 261
 262         /*
 263          * Set ready pointer to indicate that our children are ready
 264          * to be woken up, also as an interrupt threshold progress
 265          * indicator.
 266          */
 267         b->rl = 1;
 268
 269         c->flags &= ~CHN_F_DIRTY;
 270
 271         /*
 272          * Return 0 to bail out early from sndbuf_feed() loop.
 273          * No need to increase feedcount counter since part of this
 274          * feeder chains already include feed_root().
 275          */
 276         return (0);
 277 }
 278
 279 static int
 280 feed_mixer_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
 281     uint32_t count, void *source)
 282 {
 283         struct feed_mixer_info *info;
 284         struct snd_dbuf *src = source;
 285         struct pcm_channel *ch;
 286         uint32_t cnt, mcnt, rcnt, sz;
 287         int passthrough;
 288         uint8_t *tmp;
 289
 290         if (c->direction == PCMDIR_REC)
 291                 return (feed_mixer_rec(c));
 292
 293         sz = sndbuf_getsize(src);
 294         if (sz < count)
 295                 count = sz;
 296
 297         info = &feed_mixer_info_tab[FEEDMIXER_INFOIDX(f->data)];
 298         sz = info->bps * FEEDMIXER_CHANNELS(f->data);
 299         count = SND_FXROUND(count, sz);
 300         if (count < sz)
 301                 return (0);
 302
 303         /*
 304          * We are going to use our source as a temporary buffer since it's
 305          * got no other purpose.  We obtain our data by traversing the channel
 306          * list of children and calling mixer function to mix count bytes from
 307          * each into our destination buffer, b.
 308          */
 309         tmp = sndbuf_getbuf(src);
 310         rcnt = 0;
 311         mcnt = 0;
 312         passthrough = 0;        /* 'passthrough' / 'exclusive' marker */
 313
 314         CHN_FOREACH(ch, c, children.busy) {
 315                 CHN_LOCK(ch);
 316                 if (CHN_STOPPED(ch) || (ch->flags & CHN_F_DIRTY)) {
 317                         CHN_UNLOCK(ch);
 318                         continue;
 319                 }
 320 #ifdef SND_DEBUG
 321                 if ((c->flags & CHN_F_DIRTY) && VCHAN_SYNC_REQUIRED(ch)) {
 322                         if (vchan_sync(ch) != 0) {
 323                                 CHN_UNLOCK(ch);
 324                                 continue;
 325                         }
 326                 }
 327 #endif
 328                 if ((ch->flags & CHN_F_MMAP) && !(ch->flags & CHN_F_CLOSING))
 329                         sndbuf_acquire(ch->bufsoft, NULL,
 330                             sndbuf_getfree(ch->bufsoft));
 331                 if (info->mix == NULL) {
 332                         /*
 333                          * Passthrough. Dump the first digital/passthrough
 334                          * channel into destination buffer, and the rest into
 335                          * nothingness (mute effect).
 336                          */
 337                         if (passthrough == 0 &&
 338                             (ch->format & AFMT_PASSTHROUGH)) {
 339                                 rcnt = SND_FXROUND(FEEDER_FEED(ch->feeder, ch,
 340                                     b, count, ch->bufsoft), sz);
 341                                 passthrough = 1;
 342                         } else
 343                                 FEEDER_FEED(ch->feeder, ch, tmp, count,
 344                                     ch->bufsoft);
 345                 } else if (c->flags & CHN_F_EXCLUSIVE) {
 346                         /*
 347                          * Exclusive. Dump the first 'exclusive' channel into
 348                          * destination buffer, and the rest into nothingness
 349                          * (mute effect).
 350                          */
 351                         if (passthrough == 0 && (ch->flags & CHN_F_EXCLUSIVE)) {
 352                                 rcnt = SND_FXROUND(FEEDER_FEED(ch->feeder, ch,
 353                                     b, count, ch->bufsoft), sz);
 354                                 passthrough = 1;
 355                         } else
 356                                 FEEDER_FEED(ch->feeder, ch, tmp, count,
 357                                     ch->bufsoft);
 358                 } else {
 359                         if (rcnt == 0) {
 360                                 rcnt = SND_FXROUND(FEEDER_FEED(ch->feeder, ch,
 361                                     b, count, ch->bufsoft), sz);
 362                                 mcnt = count - rcnt;
 363                         } else {
 364                                 cnt = SND_FXROUND(FEEDER_FEED(ch->feeder, ch,
 365                                     tmp, count, ch->bufsoft), sz);
 366                                 if (cnt != 0) {
 367                                         if (mcnt != 0) {
 368                                                 memset(b + rcnt,
 369                                                     sndbuf_zerodata(
 370                                                     f->desc->out), mcnt);
 371                                                 mcnt = 0;
 372                                         }
 373                                         info->mix(tmp, b, cnt);
 374                                         if (cnt > rcnt)
 375                                                 rcnt = cnt;
 376                                 }
 377                         }
 378                 }
 379                 CHN_UNLOCK(ch);
 380         }
 381
 382         if (++c->feedcount == 0)
 383                 c->feedcount = 2;
 384
 385         c->flags &= ~CHN_F_DIRTY;
 386
 387         return (rcnt);
 388 }
 389
 390 static struct pcm_feederdesc feeder_mixer_desc[] = {
 391         { FEEDER_MIXER, 0, 0, 0, 0 },
 392         { 0, 0, 0, 0, 0 }
 393 };
 394
 395 static kobj_method_t feeder_mixer_methods[] = {
 396         KOBJMETHOD(feeder_init,         feed_mixer_init),
 397         KOBJMETHOD(feeder_set,          feed_mixer_set),
 398         KOBJMETHOD(feeder_feed,         feed_mixer_feed),
 399         KOBJMETHOD_END
 400 };
 401
 402 FEEDER_DECLARE(feeder_mixer, NULL);