sys/dev/sound/pcm/feeder_fmt.c

   1 /*
   2  * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
   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 #include <dev/sound/pcm/sound.h>
  28
  29 #include "feeder_if.h"
  30
  31 SND_DECLARE_FILE("$FreeBSD: src/sys/dev/sound/pcm/feeder_fmt.c,v 1.1.2.5 2002/04/22 15:49:36 cg Exp $");
  32
  33 MALLOC_DEFINE(M_FMTFEEDER, "fmtfeed", "pcm format feeder");
  34
  35 #define FEEDBUFSZ       8192
  36
  37 static unsigned char ulaw_to_u8[] = {
  38      3,    7,   11,   15,   19,   23,   27,   31,
  39     35,   39,   43,   47,   51,   55,   59,   63,
  40     66,   68,   70,   72,   74,   76,   78,   80,
  41     82,   84,   86,   88,   90,   92,   94,   96,
  42     98,   99,  100,  101,  102,  103,  104,  105,
  43    106,  107,  108,  109,  110,  111,  112,  113,
  44    113,  114,  114,  115,  115,  116,  116,  117,
  45    117,  118,  118,  119,  119,  120,  120,  121,
  46    121,  121,  122,  122,  122,  122,  123,  123,
  47    123,  123,  124,  124,  124,  124,  125,  125,
  48    125,  125,  125,  125,  126,  126,  126,  126,
  49    126,  126,  126,  126,  127,  127,  127,  127,
  50    127,  127,  127,  127,  127,  127,  127,  127,
  51    128,  128,  128,  128,  128,  128,  128,  128,
  52    128,  128,  128,  128,  128,  128,  128,  128,
  53    128,  128,  128,  128,  128,  128,  128,  128,
  54    253,  249,  245,  241,  237,  233,  229,  225,
  55    221,  217,  213,  209,  205,  201,  197,  193,
  56    190,  188,  186,  184,  182,  180,  178,  176,
  57    174,  172,  170,  168,  166,  164,  162,  160,
  58    158,  157,  156,  155,  154,  153,  152,  151,
  59    150,  149,  148,  147,  146,  145,  144,  143,
  60    143,  142,  142,  141,  141,  140,  140,  139,
  61    139,  138,  138,  137,  137,  136,  136,  135,
  62    135,  135,  134,  134,  134,  134,  133,  133,
  63    133,  133,  132,  132,  132,  132,  131,  131,
  64    131,  131,  131,  131,  130,  130,  130,  130,
  65    130,  130,  130,  130,  129,  129,  129,  129,
  66    129,  129,  129,  129,  129,  129,  129,  129,
  67    128,  128,  128,  128,  128,  128,  128,  128,
  68    128,  128,  128,  128,  128,  128,  128,  128,
  69    128,  128,  128,  128,  128,  128,  128,  128,
  70 };
  71
  72 static unsigned char u8_to_ulaw[] = {
  73      0,    0,    0,    0,    0,    1,    1,    1,
  74      1,    2,    2,    2,    2,    3,    3,    3,
  75      3,    4,    4,    4,    4,    5,    5,    5,
  76      5,    6,    6,    6,    6,    7,    7,    7,
  77      7,    8,    8,    8,    8,    9,    9,    9,
  78      9,   10,   10,   10,   10,   11,   11,   11,
  79     11,   12,   12,   12,   12,   13,   13,   13,
  80     13,   14,   14,   14,   14,   15,   15,   15,
  81     15,   16,   16,   17,   17,   18,   18,   19,
  82     19,   20,   20,   21,   21,   22,   22,   23,
  83     23,   24,   24,   25,   25,   26,   26,   27,
  84     27,   28,   28,   29,   29,   30,   30,   31,
  85     31,   32,   33,   34,   35,   36,   37,   38,
  86     39,   40,   41,   42,   43,   44,   45,   46,
  87     47,   49,   51,   53,   55,   57,   59,   61,
  88     63,   66,   70,   74,   78,   84,   92,  104,
  89    254,  231,  219,  211,  205,  201,  197,  193,
  90    190,  188,  186,  184,  182,  180,  178,  176,
  91    175,  174,  173,  172,  171,  170,  169,  168,
  92    167,  166,  165,  164,  163,  162,  161,  160,
  93    159,  159,  158,  158,  157,  157,  156,  156,
  94    155,  155,  154,  154,  153,  153,  152,  152,
  95    151,  151,  150,  150,  149,  149,  148,  148,
  96    147,  147,  146,  146,  145,  145,  144,  144,
  97    143,  143,  143,  143,  142,  142,  142,  142,
  98    141,  141,  141,  141,  140,  140,  140,  140,
  99    139,  139,  139,  139,  138,  138,  138,  138,
 100    137,  137,  137,  137,  136,  136,  136,  136,
 101    135,  135,  135,  135,  134,  134,  134,  134,
 102    133,  133,  133,  133,  132,  132,  132,  132,
 103    131,  131,  131,  131,  130,  130,  130,  130,
 104    129,  129,  129,  129,  128,  128,  128,  128,
 105 };
 106
 107 static unsigned char alaw_to_ulaw[] = {
 108    42,   43,   40,   41,   46,   47,   44,   45,
 109    34,   35,   32,   33,   38,   39,   36,   37,
 110    57,   58,   55,   56,   61,   62,   59,   60,
 111    49,   50,   48,   48,   53,   54,   51,   52,
 112    10,   11,    8,    9,   14,   15,   12,   13,
 113     2,    3,    0,    1,    6,    7,    4,    5,
 114    26,   27,   24,   25,   30,   31,   28,   29,
 115    18,   19,   16,   17,   22,   23,   20,   21,
 116    98,   99,   96,   97,  102,  103,  100,  101,
 117    93,   93,   92,   92,   95,   95,   94,   94,
 118   116,  118,  112,  114,  124,  126,  120,  122,
 119   106,  107,  104,  105,  110,  111,  108,  109,
 120    72,   73,   70,   71,   76,   77,   74,   75,
 121    64,   65,   63,   63,   68,   69,   66,   67,
 122    86,   87,   84,   85,   90,   91,   88,   89,
 123    79,   79,   78,   78,   82,   83,   80,   81,
 124   170,  171,  168,  169,  174,  175,  172,  173,
 125   162,  163,  160,  161,  166,  167,  164,  165,
 126   185,  186,  183,  184,  189,  190,  187,  188,
 127   177,  178,  176,  176,  181,  182,  179,  180,
 128   138,  139,  136,  137,  142,  143,  140,  141,
 129   130,  131,  128,  129,  134,  135,  132,  133,
 130   154,  155,  152,  153,  158,  159,  156,  157,
 131   146,  147,  144,  145,  150,  151,  148,  149,
 132   226,  227,  224,  225,  230,  231,  228,  229,
 133   221,  221,  220,  220,  223,  223,  222,  222,
 134   244,  246,  240,  242,  252,  254,  248,  250,
 135   234,  235,  232,  233,  238,  239,  236,  237,
 136   200,  201,  198,  199,  204,  205,  202,  203,
 137   192,  193,  191,  191,  196,  197,  194,  195,
 138   214,  215,  212,  213,  218,  219,  216,  217,
 139   207,  207,  206,  206,  210,  211,  208,  209,
 140 };
 141
 142 static unsigned char ulaw_to_alaw[] = {
 143    42,   43,   40,   41,   46,   47,   44,   45,
 144    34,   35,   32,   33,   38,   39,   36,   37,
 145    58,   59,   56,   57,   62,   63,   60,   61,
 146    50,   51,   48,   49,   54,   55,   52,   53,
 147    10,   11,    8,    9,   14,   15,   12,   13,
 148     2,    3,    0,    1,    6,    7,    4,    5,
 149    27,   24,   25,   30,   31,   28,   29,   18,
 150    19,   16,   17,   22,   23,   20,   21,  106,
 151   104,  105,  110,  111,  108,  109,   98,   99,
 152    96,   97,  102,  103,  100,  101,  122,  120,
 153   126,  127,  124,  125,  114,  115,  112,  113,
 154   118,  119,  116,  117,   75,   73,   79,   77,
 155    66,   67,   64,   65,   70,   71,   68,   69,
 156    90,   91,   88,   89,   94,   95,   92,   93,
 157    82,   82,   83,   83,   80,   80,   81,   81,
 158    86,   86,   87,   87,   84,   84,   85,   85,
 159   170,  171,  168,  169,  174,  175,  172,  173,
 160   162,  163,  160,  161,  166,  167,  164,  165,
 161   186,  187,  184,  185,  190,  191,  188,  189,
 162   178,  179,  176,  177,  182,  183,  180,  181,
 163   138,  139,  136,  137,  142,  143,  140,  141,
 164   130,  131,  128,  129,  134,  135,  132,  133,
 165   155,  152,  153,  158,  159,  156,  157,  146,
 166   147,  144,  145,  150,  151,  148,  149,  234,
 167   232,  233,  238,  239,  236,  237,  226,  227,
 168   224,  225,  230,  231,  228,  229,  250,  248,
 169   254,  255,  252,  253,  242,  243,  240,  241,
 170   246,  247,  244,  245,  203,  201,  207,  205,
 171   194,  195,  192,  193,  198,  199,  196,  197,
 172   218,  219,  216,  217,  222,  223,  220,  221,
 173   210,  210,  211,  211,  208,  208,  209,  209,
 174   214,  214,  215,  215,  212,  212,  213,  213,
 175 };
 176
 177 /*****************************************************************************/
 178
 179 static int
 180 feed_8to16le(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 181 {
 182         int i, j, k;
 183
 184         k = FEEDER_FEED(f->source, c, b, count / 2, source);
 185         j = k - 1;
 186         i = j * 2 + 1;
 187         while (i > 0 && j >= 0) {
 188                 b[i--] = b[j--];
 189                 b[i--] = 0;
 190         }
 191         return k * 2;
 192 }
 193
 194 static struct pcm_feederdesc feeder_8to16le_desc[] = {
 195         {FEEDER_FMT, AFMT_U8, AFMT_U16_LE, 0},
 196         {FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
 197         {FEEDER_FMT, AFMT_S8, AFMT_S16_LE, 0},
 198         {FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
 199         {0},
 200 };
 201 static kobj_method_t feeder_8to16le_methods[] = {
 202         KOBJMETHOD(feeder_feed,         feed_8to16le),
 203         { 0, 0 }
 204 };
 205 FEEDER_DECLARE(feeder_8to16le, 0, NULL);
 206
 207 /*****************************************************************************/
 208
 209 static int
 210 feed_16to8_init(struct pcm_feeder *f)
 211 {
 212         f->data = malloc(FEEDBUFSZ, M_FMTFEEDER, M_WAITOK | M_ZERO);
 213         return (f->data)? 0 : ENOMEM;
 214 }
 215
 216 static int
 217 feed_16to8_free(struct pcm_feeder *f)
 218 {
 219         if (f->data)
 220                 free(f->data, M_FMTFEEDER);
 221         f->data = NULL;
 222         return 0;
 223 }
 224
 225 static int
 226 feed_16leto8(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 227 {
 228         u_int32_t i = 0, toget = count * 2;
 229         int j = 1, k;
 230
 231         k = FEEDER_FEED(f->source, c, f->data, min(toget, FEEDBUFSZ), source);
 232         while (j < k) {
 233                 b[i++] = ((u_int8_t *)f->data)[j];
 234                 j += 2;
 235         }
 236         return i;
 237 }
 238
 239 static struct pcm_feederdesc feeder_16leto8_desc[] = {
 240         {FEEDER_FMT, AFMT_U16_LE, AFMT_U8, 0},
 241         {FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
 242         {FEEDER_FMT, AFMT_S16_LE, AFMT_S8, 0},
 243         {FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
 244         {0},
 245 };
 246 static kobj_method_t feeder_16leto8_methods[] = {
 247         KOBJMETHOD(feeder_init,         feed_16to8_init),
 248         KOBJMETHOD(feeder_free,         feed_16to8_free),
 249         KOBJMETHOD(feeder_feed,         feed_16leto8),
 250         { 0, 0 }
 251 };
 252 FEEDER_DECLARE(feeder_16leto8, 1, NULL);
 253
 254 /*****************************************************************************/
 255
 256 static int
 257 feed_monotostereo8(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 258 {
 259         int i, j, k = FEEDER_FEED(f->source, c, b, count / 2, source);
 260
 261         j = k - 1;
 262         i = j * 2 + 1;
 263         while (i > 0 && j >= 0) {
 264                 b[i--] = b[j];
 265                 b[i--] = b[j];
 266                 j--;
 267         }
 268         return k * 2;
 269 }
 270
 271 static struct pcm_feederdesc feeder_monotostereo8_desc[] = {
 272         {FEEDER_FMT, AFMT_U8, AFMT_U8 | AFMT_STEREO, 0},
 273         {FEEDER_FMT, AFMT_S8, AFMT_S8 | AFMT_STEREO, 0},
 274         {0},
 275 };
 276 static kobj_method_t feeder_monotostereo8_methods[] = {
 277         KOBJMETHOD(feeder_feed,         feed_monotostereo8),
 278         { 0, 0 }
 279 };
 280 FEEDER_DECLARE(feeder_monotostereo8, 0, NULL);
 281
 282 /*****************************************************************************/
 283
 284 static int
 285 feed_monotostereo16(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 286 {
 287         int i, j, k = FEEDER_FEED(f->source, c, b, count / 2, source);
 288         u_int8_t x, y;
 289
 290         j = k - 1;
 291         i = j * 2 + 1;
 292         while (i > 3 && j >= 1) {
 293                 x = b[j--];
 294                 y = b[j--];
 295                 b[i--] = x;
 296                 b[i--] = y;
 297                 b[i--] = x;
 298                 b[i--] = y;
 299         }
 300         return k * 2;
 301 }
 302
 303 static struct pcm_feederdesc feeder_monotostereo16_desc[] = {
 304         {FEEDER_FMT, AFMT_U16_LE, AFMT_U16_LE | AFMT_STEREO, 0},
 305         {FEEDER_FMT, AFMT_S16_LE, AFMT_S16_LE | AFMT_STEREO, 0},
 306         {FEEDER_FMT, AFMT_U16_BE, AFMT_U16_BE | AFMT_STEREO, 0},
 307         {FEEDER_FMT, AFMT_S16_BE, AFMT_S16_BE | AFMT_STEREO, 0},
 308         {0},
 309 };
 310 static kobj_method_t feeder_monotostereo16_methods[] = {
 311         KOBJMETHOD(feeder_feed,         feed_monotostereo16),
 312         { 0, 0 }
 313 };
 314 FEEDER_DECLARE(feeder_monotostereo16, 0, NULL);
 315
 316 /*****************************************************************************/
 317
 318 static int
 319 feed_stereotomono8_init(struct pcm_feeder *f)
 320 {
 321         f->data = malloc(FEEDBUFSZ, M_FMTFEEDER, M_WAITOK | M_ZERO);
 322         return (f->data)? 0 : ENOMEM;
 323 }
 324
 325 static int
 326 feed_stereotomono8_free(struct pcm_feeder *f)
 327 {
 328         if (f->data)
 329                 free(f->data, M_FMTFEEDER);
 330         f->data = NULL;
 331         return 0;
 332 }
 333
 334 static int
 335 feed_stereotomono8(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 336 {
 337         u_int32_t i = 0, toget = count * 2;
 338         int j = 0, k;
 339
 340         k = FEEDER_FEED(f->source, c, f->data, min(toget, FEEDBUFSZ), source);
 341         while (j < k) {
 342                 b[i++] = ((u_int8_t *)f->data)[j];
 343                 j += 2;
 344         }
 345         return i;
 346 }
 347
 348 static struct pcm_feederdesc feeder_stereotomono8_desc[] = {
 349         {FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U8, 0},
 350         {FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S8, 0},
 351         {0},
 352 };
 353 static kobj_method_t feeder_stereotomono8_methods[] = {
 354         KOBJMETHOD(feeder_init,         feed_stereotomono8_init),
 355         KOBJMETHOD(feeder_free,         feed_stereotomono8_free),
 356         KOBJMETHOD(feeder_feed,         feed_stereotomono8),
 357         { 0, 0 }
 358 };
 359 FEEDER_DECLARE(feeder_stereotomono8, 1, NULL);
 360
 361 /*****************************************************************************/
 362
 363 static int
 364 feed_stereotomono16_init(struct pcm_feeder *f)
 365 {
 366         f->data = malloc(FEEDBUFSZ, M_FMTFEEDER, M_WAITOK | M_ZERO);
 367         return (f->data)? 0 : ENOMEM;
 368 }
 369
 370 static int
 371 feed_stereotomono16_free(struct pcm_feeder *f)
 372 {
 373         if (f->data)
 374                 free(f->data, M_FMTFEEDER);
 375         f->data = NULL;
 376         return 0;
 377 }
 378
 379 static int
 380 feed_stereotomono16(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 381 {
 382         u_int32_t i = 0, toget = count * 2;
 383         int j = 0, k;
 384
 385         k = FEEDER_FEED(f->source, c, f->data, min(toget, FEEDBUFSZ), source);
 386         while (j < k) {
 387                 b[i++] = ((u_int8_t *)f->data)[j];
 388                 b[i++] = ((u_int8_t *)f->data)[j + 1];
 389                 j += 4;
 390         }
 391         return i;
 392 }
 393
 394 static struct pcm_feederdesc feeder_stereotomono16_desc[] = {
 395         {FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_LE, 0},
 396         {FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_LE, 0},
 397         {FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_BE, 0},
 398         {FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_BE, 0},
 399         {0},
 400 };
 401 static kobj_method_t feeder_stereotomono16_methods[] = {
 402         KOBJMETHOD(feeder_init,         feed_stereotomono16_init),
 403         KOBJMETHOD(feeder_free,         feed_stereotomono16_free),
 404         KOBJMETHOD(feeder_feed,         feed_stereotomono16),
 405         { 0, 0 }
 406 };
 407 FEEDER_DECLARE(feeder_stereotomono16, 1, NULL);
 408
 409 /*****************************************************************************/
 410
 411 static int
 412 feed_endian(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 413 {
 414         u_int8_t t;
 415         int i = 0, j = FEEDER_FEED(f->source, c, b, count, source);
 416
 417         while (i < j) {
 418                 t = b[i];
 419                 b[i] = b[i + 1];
 420                 b[i + 1] = t;
 421                 i += 2;
 422         }
 423         return i;
 424 }
 425
 426 static struct pcm_feederdesc feeder_endian_desc[] = {
 427         {FEEDER_FMT, AFMT_U16_LE, AFMT_U16_BE, 0},
 428         {FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
 429         {FEEDER_FMT, AFMT_S16_LE, AFMT_S16_BE, 0},
 430         {FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_BE | AFMT_STEREO, 0},
 431         {FEEDER_FMT, AFMT_U16_BE, AFMT_U16_LE, 0},
 432         {FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
 433         {FEEDER_FMT, AFMT_S16_BE, AFMT_S16_LE, 0},
 434         {FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
 435         {0},
 436 };
 437 static kobj_method_t feeder_endian_methods[] = {
 438         KOBJMETHOD(feeder_feed,         feed_endian),
 439         { 0, 0 }
 440 };
 441 FEEDER_DECLARE(feeder_endian, 0, NULL);
 442
 443 /*****************************************************************************/
 444
 445 static int
 446 feed_sign(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 447 {
 448         int i = 0, j = FEEDER_FEED(f->source, c, b, count, source);
 449         intptr_t ssz = (intptr_t)f->data, ofs = ssz - 1;
 450
 451         while (i < j) {
 452                 b[i + ofs] ^= 0x80;
 453                 i += ssz;
 454         }
 455         return i;
 456 }
 457
 458 static struct pcm_feederdesc feeder_sign8_desc[] = {
 459         {FEEDER_FMT, AFMT_U8, AFMT_S8, 0},
 460         {FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
 461         {FEEDER_FMT, AFMT_S8, AFMT_U8, 0},
 462         {FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
 463         {0},
 464 };
 465 static kobj_method_t feeder_sign8_methods[] = {
 466         KOBJMETHOD(feeder_feed,         feed_sign),
 467         { 0, 0 }
 468 };
 469 FEEDER_DECLARE(feeder_sign8, 0, (void *)1);
 470
 471 static struct pcm_feederdesc feeder_sign16le_desc[] = {
 472         {FEEDER_FMT, AFMT_U16_LE, AFMT_S16_LE, 0},
 473         {FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
 474         {FEEDER_FMT, AFMT_S16_LE, AFMT_U16_LE, 0},
 475         {FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
 476         {0},
 477 };
 478 static kobj_method_t feeder_sign16le_methods[] = {
 479         KOBJMETHOD(feeder_feed,         feed_sign),
 480         { 0, 0 }
 481 };
 482 FEEDER_DECLARE(feeder_sign16le, -1, (void *)2);
 483
 484 /*****************************************************************************/
 485
 486 static int
 487 feed_table(struct pcm_feeder *f, struct pcm_channel *c, u_int8_t *b, u_int32_t count, void *source)
 488 {
 489         int i = 0, j = FEEDER_FEED(f->source, c, b, count, source);
 490
 491         while (i < j) {
 492                 b[i] = ((u_int8_t *)f->data)[b[i]];
 493                 i++;
 494         }
 495         return i;
 496 }
 497
 498 static struct pcm_feederdesc feeder_ulawtou8_desc[] = {
 499         {FEEDER_FMT, AFMT_MU_LAW, AFMT_U8, 0},
 500         {FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
 501         {0},
 502 };
 503 static kobj_method_t feeder_ulawtou8_methods[] = {
 504         KOBJMETHOD(feeder_feed,         feed_table),
 505         { 0, 0 }
 506 };
 507 FEEDER_DECLARE(feeder_ulawtou8, 0, ulaw_to_u8);
 508
 509 static struct pcm_feederdesc feeder_u8toulaw_desc[] = {
 510         {FEEDER_FMT, AFMT_U8, AFMT_MU_LAW, 0},
 511         {FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_MU_LAW | AFMT_STEREO, 0},
 512         {0},
 513 };
 514 static kobj_method_t feeder_u8toulaw_methods[] = {
 515         KOBJMETHOD(feeder_feed,         feed_table),
 516         { 0, 0 }
 517 };
 518 FEEDER_DECLARE(feeder_u8toulaw, 0, u8_to_ulaw);
 519
 520 static struct pcm_feederdesc feeder_alawtoulaw_desc[] = {
 521         {FEEDER_FMT, AFMT_A_LAW, AFMT_MU_LAW, 0},
 522         {FEEDER_FMT, AFMT_A_LAW | AFMT_STEREO, AFMT_MU_LAW | AFMT_STEREO, 0},
 523         {0},
 524 };
 525 static kobj_method_t feeder_alawtoulaw_methods[] = {
 526         KOBJMETHOD(feeder_feed,         feed_table),
 527         { 0, 0 }
 528 };
 529 FEEDER_DECLARE(feeder_alawtoulaw, 0, alaw_to_ulaw);
 530
 531 static struct pcm_feederdesc feeder_ulawtoalaw_desc[] = {
 532         {FEEDER_FMT, AFMT_MU_LAW, AFMT_A_LAW, 0},
 533         {FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_A_LAW | AFMT_STEREO, 0},
 534         {0},
 535 };
 536 static kobj_method_t feeder_ulawtoalaw_methods[] = {
 537         KOBJMETHOD(feeder_feed,         feed_table),
 538         { 0, 0 }
 539 };
 540 FEEDER_DECLARE(feeder_ulawtoalaw, 0, ulaw_to_alaw);
 541
 542
 543