upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-02-19 02:30:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

sound: Refactor the format conversion framework

Browse source 
Merge the PCM_READ|WRITE_* macros defined in pcm/pcm.h, as well as the
intpcm_read|write_* macros defined in pcm/feeder_format.c, into six
inline functions: pcm_sample_read|write[_norm|calc](). The absence of
macro magic makes the code significantly easier to read, use and modify.

Since these functions take the input/output format as a parameter, get
rid of the read() and write() function pointers defined in struct
feed_format_info, as well as the feeder_format_read|write_op()
functions, and use the new read/write functions directly.

Sponsored by:	The FreeBSD Fondation
MFC after:	1 week
Reviewed by:	markj
Differential Revision:	https://reviews.freebsd.org/D47932

(cherry picked from commit 433e270f341cf660b2fe125c2e0f733073829188)
This commit is contained in:
Christos Margiolis 2025-03-10 21:19:15 +01:00
parent be425fcdc6
commit 33529d6ad4
11 changed files with 303 additions and 850 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
sys/dev/sound/pcm/feeder.h
View file

@ -161,13 +161,6 @@ int feeder_matrix_setup(struct pcm_feeder *, struct pcmchan_matrix *,
struct pcmchan_matrix *);
int feeder_matrix_compare(struct pcmchan_matrix *, struct pcmchan_matrix *);
/* feeder_format */
typedef intpcm_t intpcm_read_t(uint8_t *);
typedef void intpcm_write_t(uint8_t *, intpcm_t);
intpcm_read_t *feeder_format_read_op(uint32_t);
intpcm_write_t *feeder_format_write_op(uint32_t);
/* 4Front OSS stuffs */
int feeder_matrix_oss_get_channel_order(struct pcmchan_matrix *,
unsigned long long *);

12
sys/dev/sound/pcm/feeder_eq.c
View file

@ -158,9 +158,9 @@ feed_eq_biquad_##SIGN##BIT##ENDIAN(struct feed_eq_info *info, \
dst += j * PCM_##BIT##_BPS; \
do { \
dst -= PCM_##BIT##_BPS; \
v = _PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
v = pcm_sample_read(dst, AFMT_##SIGN##BIT##_##ENDIAN); \
v = ((intpcm64_t)pmul * v) >> pshift; \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, v); \
pcm_sample_write(dst, v, AFMT_##SIGN##BIT##_##ENDIAN); \
} while (--j != 0); \
\
return; \
@ -173,8 +173,8 @@ feed_eq_biquad_##SIGN##BIT##ENDIAN(struct feed_eq_info *info, \
i = 0; \
j = info->channels; \
do { \
v = _PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
v <<= 32 - BIT; \
v = pcm_sample_read_norm(dst, \
AFMT_##SIGN##BIT##_##ENDIAN); \
v = ((intpcm64_t)pmul * v) >> pshift; \
\
w = (intpcm64_t)v * treble->b0; \
@ -203,8 +203,8 @@ feed_eq_biquad_##SIGN##BIT##ENDIAN(struct feed_eq_info *info, \
v = FEEDEQ_CLAMP(w); \
info->bass.o1[i] = v; \
\
v >>= 32 - BIT; \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, v); \
pcm_sample_write_norm(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
i++; \
} while (--j != 0); \

221
sys/dev/sound/pcm/feeder_format.c
View file

@ -36,7 +36,7 @@
#include "opt_snd.h"
#endif
#include <dev/sound/pcm/sound.h>
#include <dev/sound/pcm/g711.h>
#include <dev/sound/pcm/pcm.h>
#include "feeder_if.h"
#define SND_USE_FXDIV
@ -48,202 +48,19 @@
struct feed_format_info {
uint32_t ibps, obps;
uint32_t ialign, oalign, channels;
intpcm_read_t *read;
intpcm_write_t *write;
uint32_t rdfmt, wrfmt;
uint8_t reservoir[FEEDFORMAT_RESERVOIR];
};
#define INTPCM_DECLARE_OP_WRITE(SIGN, BIT, ENDIAN, SHIFT) \
static __inline void \
intpcm_write_##SIGN##BIT##ENDIAN(uint8_t *dst, intpcm_t v) \
{ \
\
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, v >> SHIFT); \
}
#define INTPCM_DECLARE_OP_8(SIGN, ENDIAN) \
static __inline intpcm_t \
intpcm_read_##SIGN##8##ENDIAN(uint8_t *src) \
{ \
\
return (_PCM_READ_##SIGN##8##_##ENDIAN(src) << 24); \
} \
INTPCM_DECLARE_OP_WRITE(SIGN, 8, ENDIAN, 24)
#define INTPCM_DECLARE_OP_16(SIGN, ENDIAN) \
static __inline intpcm_t \
intpcm_read_##SIGN##16##ENDIAN(uint8_t *src) \
{ \
\
return (_PCM_READ_##SIGN##16##_##ENDIAN(src) << 16); \
} \
INTPCM_DECLARE_OP_WRITE(SIGN, 16, ENDIAN, 16)
#define INTPCM_DECLARE_OP_24(SIGN, ENDIAN) \
static __inline intpcm_t \
intpcm_read_##SIGN##24##ENDIAN(uint8_t *src) \
{ \
\
return (_PCM_READ_##SIGN##24##_##ENDIAN(src) << 8); \
} \
INTPCM_DECLARE_OP_WRITE(SIGN, 24, ENDIAN, 8)
#define INTPCM_DECLARE_OP_32(SIGN, ENDIAN) \
static __inline intpcm_t \
intpcm_read_##SIGN##32##ENDIAN(uint8_t *src) \
{ \
\
return (_PCM_READ_##SIGN##32##_##ENDIAN(src)); \
} \
\
static __inline void \
intpcm_write_##SIGN##32##ENDIAN(uint8_t *dst, intpcm_t v) \
{ \
\
_PCM_WRITE_##SIGN##32##_##ENDIAN(dst, v); \
}
INTPCM_DECLARE_OP_8(S, NE)
INTPCM_DECLARE_OP_16(S, LE)
INTPCM_DECLARE_OP_16(S, BE)
INTPCM_DECLARE_OP_24(S, LE)
INTPCM_DECLARE_OP_24(S, BE)
INTPCM_DECLARE_OP_32(S, LE)
INTPCM_DECLARE_OP_32(S, BE)
INTPCM_DECLARE_OP_8(U, NE)
INTPCM_DECLARE_OP_16(U, LE)
INTPCM_DECLARE_OP_16(U, BE)
INTPCM_DECLARE_OP_24(U, LE)
INTPCM_DECLARE_OP_24(U, BE)
INTPCM_DECLARE_OP_32(U, LE)
INTPCM_DECLARE_OP_32(U, BE)
static const struct {
const uint8_t ulaw_to_u8[G711_TABLE_SIZE];
const uint8_t alaw_to_u8[G711_TABLE_SIZE];
const uint8_t u8_to_ulaw[G711_TABLE_SIZE];
const uint8_t u8_to_alaw[G711_TABLE_SIZE];
} xlaw_conv_tables = {
ULAW_TO_U8,
ALAW_TO_U8,
U8_TO_ULAW,
U8_TO_ALAW
};
static __inline intpcm_t
intpcm_read_ulaw(uint8_t *src)
{
return (_G711_TO_INTPCM(xlaw_conv_tables.ulaw_to_u8, *src) << 24);
}
static __inline intpcm_t
intpcm_read_alaw(uint8_t *src)
{
return (_G711_TO_INTPCM(xlaw_conv_tables.alaw_to_u8, *src) << 24);
}
static __inline void
intpcm_write_ulaw(uint8_t *dst, intpcm_t v)
{
*dst = _INTPCM_TO_G711(xlaw_conv_tables.u8_to_ulaw, v >> 24);
}
static __inline void
intpcm_write_alaw(uint8_t *dst, intpcm_t v)
{
*dst = _INTPCM_TO_G711(xlaw_conv_tables.u8_to_alaw, v >> 24);
}
/*
* dummy ac3/dts passthrough, etc.
* XXX assume as s16le.
*/
static __inline intpcm_t
intpcm_read_null(uint8_t *src __unused)
{
return (0);
}
static __inline void
intpcm_write_null(uint8_t *dst, intpcm_t v __unused)
{
_PCM_WRITE_S16_LE(dst, 0);
}
#define FEEDFORMAT_ENTRY(SIGN, BIT, ENDIAN) \
{ \
AFMT_##SIGN##BIT##_##ENDIAN, \
intpcm_read_##SIGN##BIT##ENDIAN, \
intpcm_write_##SIGN##BIT##ENDIAN \
}
static const struct {
uint32_t format;
intpcm_read_t *read;
intpcm_write_t *write;
} feed_format_ops[] = {
FEEDFORMAT_ENTRY(S, 8, NE),
FEEDFORMAT_ENTRY(S, 16, LE),
FEEDFORMAT_ENTRY(S, 24, LE),
FEEDFORMAT_ENTRY(S, 32, LE),
FEEDFORMAT_ENTRY(S, 16, BE),
FEEDFORMAT_ENTRY(S, 24, BE),
FEEDFORMAT_ENTRY(S, 32, BE),
FEEDFORMAT_ENTRY(U, 8, NE),
FEEDFORMAT_ENTRY(U, 16, LE),
FEEDFORMAT_ENTRY(U, 24, LE),
FEEDFORMAT_ENTRY(U, 32, LE),
FEEDFORMAT_ENTRY(U, 16, BE),
FEEDFORMAT_ENTRY(U, 24, BE),
FEEDFORMAT_ENTRY(U, 32, BE),
{
AFMT_MU_LAW,
intpcm_read_ulaw, intpcm_write_ulaw
},
{
AFMT_A_LAW,
intpcm_read_alaw, intpcm_write_alaw
},
{
AFMT_AC3,
intpcm_read_null, intpcm_write_null
}
};
static int
feed_format_init(struct pcm_feeder *f)
{
struct feed_format_info *info;
intpcm_read_t *rd_op;
intpcm_write_t *wr_op;
size_t i;
if (f->desc->in == f->desc->out ||
AFMT_CHANNEL(f->desc->in) != AFMT_CHANNEL(f->desc->out))
return (EINVAL);
rd_op = NULL;
wr_op = NULL;
for (i = 0; i < nitems(feed_format_ops) &&
(rd_op == NULL || wr_op == NULL); i++) {
if (rd_op == NULL &&
AFMT_ENCODING(f->desc->in) == feed_format_ops[i].format)
rd_op = feed_format_ops[i].read;
if (wr_op == NULL &&
AFMT_ENCODING(f->desc->out) == feed_format_ops[i].format)
wr_op = feed_format_ops[i].write;
}
if (rd_op == NULL || wr_op == NULL) {
printf("%s(): failed to initialize io ops "
"in=0x%08x out=0x%08x\n",
__func__, f->desc->in, f->desc->out);
return (EINVAL);
}
info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
if (info == NULL)
return (ENOMEM);
@ -252,11 +69,11 @@ feed_format_init(struct pcm_feeder *f)
info->ibps = AFMT_BPS(f->desc->in);
info->ialign = info->ibps * info->channels;
info->read = rd_op;
info->rdfmt = AFMT_ENCODING(f->desc->in);
info->obps = AFMT_BPS(f->desc->out);
info->oalign = info->obps * info->channels;
info->write = wr_op;
info->wrfmt = AFMT_ENCODING(f->desc->out);
f->data = info;
@ -340,8 +157,8 @@ feed_format_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
count -= j * info->obps;
do {
v = info->read(src);
info->write(dst, v);
v = pcm_sample_read_norm(src, info->rdfmt);
pcm_sample_write_norm(dst, v, info->wrfmt);
dst += info->obps;
src += info->ibps;
} while (--j != 0);
@ -365,29 +182,3 @@ static kobj_method_t feeder_format_methods[] = {
};
FEEDER_DECLARE(feeder_format, NULL);
intpcm_read_t *
feeder_format_read_op(uint32_t format)
{
size_t i;
for (i = 0; i < nitems(feed_format_ops); i++) {
if (AFMT_ENCODING(format) == feed_format_ops[i].format)
return (feed_format_ops[i].read);
}
return (NULL);
}
intpcm_write_t *
feeder_format_write_op(uint32_t format)
{
size_t i;
for (i = 0; i < nitems(feed_format_ops); i++) {
if (AFMT_ENCODING(format) == feed_format_ops[i].format)
return (feed_format_ops[i].write);
}
return (NULL);
}

43
sys/dev/sound/pcm/feeder_matrix.c
View file

@ -70,10 +70,6 @@ struct feed_matrix_info {
uint32_t ialign, oalign;
uint32_t in, out;
feed_matrix_t apply;
#ifdef FEEDMATRIX_GENERIC
intpcm_read_t *rd;
intpcm_write_t *wr;
#endif
struct {
int chn[SND_CHN_T_MAX + 1];
int mul, shift;
@ -132,16 +128,17 @@ feed_matrix_##SIGN##BIT##ENDIAN(struct feed_matrix_info *info, \
for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF; \
i++) { \
if (info->matrix[i].chn[0] == SND_CHN_T_NULL) { \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, \
0); \
pcm_sample_write(dst, 0, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
continue; \
} else if (info->matrix[i].chn[1] == \
SND_CHN_T_EOF) { \
v = _PCM_READ_##SIGN##BIT##_##ENDIAN( \
src + info->matrix[i].chn[0]); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, \
v); \
v = pcm_sample_read( \
src + info->matrix[i].chn[0], \
AFMT_##SIGN##BIT##_##ENDIAN); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
continue; \
} \
@ -150,8 +147,9 @@ feed_matrix_##SIGN##BIT##ENDIAN(struct feed_matrix_info *info, \
for (j = 0; \
info->matrix[i].chn[j] != SND_CHN_T_EOF; \
j++) { \
v = _PCM_READ_##SIGN##BIT##_##ENDIAN( \
src + info->matrix[i].chn[j]); \
v = pcm_sample_read( \
src + info->matrix[i].chn[j], \
AFMT_##SIGN##BIT##_##ENDIAN); \
accum += v; \
} \
\
@ -165,7 +163,8 @@ feed_matrix_##SIGN##BIT##ENDIAN(struct feed_matrix_info *info, \
((accum < PCM_S##BIT##_MIN) ? \
PCM_S##BIT##_MIN : \
accum); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, v); \
pcm_sample_write(dst, v, \
AFMT_##SIGN##BIT##_##ENDIAN); \
dst += PCM_##BIT##_BPS; \
} \
src += info->ialign; \
@ -254,13 +253,14 @@ feed_matrix_apply_generic(struct feed_matrix_info *info,
for (i = 0; info->matrix[i].chn[0] != SND_CHN_T_EOF;
i++) {
if (info->matrix[i].chn[0] == SND_CHN_T_NULL) {
info->wr(dst, 0);
pcm_sample_write_norm(dst, 0, info->out);
dst += info->bps;
continue;
} else if (info->matrix[i].chn[1] ==
SND_CHN_T_EOF) {
v = info->rd(src + info->matrix[i].chn[0]);
info->wr(dst, v);
v = pcm_sample_read_norm(src +
info->matrix[i].chn[0], info->in);
pcm_sample_write_norm(dst, v, info->out);
dst += info->bps;
continue;
}
@ -269,7 +269,8 @@ feed_matrix_apply_generic(struct feed_matrix_info *info,
for (j = 0;
info->matrix[i].chn[j] != SND_CHN_T_EOF;
j++) {
v = info->rd(src + info->matrix[i].chn[j]);
v = pcm_sample_read_norm(src +
info->matrix[i].chn[j], info->in);
accum += v;
}
@ -280,7 +281,7 @@ feed_matrix_apply_generic(struct feed_matrix_info *info,
v = (accum > PCM_S32_MAX) ? PCM_S32_MAX :
((accum < PCM_S32_MIN) ? PCM_S32_MIN : accum);
info->wr(dst, v);
pcm_sample_write_norm(dst, v, info->out);
dst += info->bps;
}
src += info->ialign;
@ -421,12 +422,6 @@ feed_matrix_init(struct pcm_feeder *f)
if (info->apply == NULL) {
#ifdef FEEDMATRIX_GENERIC
info->rd = feeder_format_read_op(info->in);
info->wr = feeder_format_write_op(info->out);
if (info->rd == NULL || info->wr == NULL) {
free(info, M_DEVBUF);
return (EINVAL);
}
info->apply = feed_matrix_apply_generic;
#else
free(info, M_DEVBUF);

9
sys/dev/sound/pcm/feeder_mixer.c
View file

@ -59,11 +59,14 @@ feed_mixer_##SIGN##BIT##ENDIAN(uint8_t *src, uint8_t *dst, \
src -= PCM_##BIT##_BPS; \
dst -= PCM_##BIT##_BPS; \
count -= PCM_##BIT##_BPS; \
x = PCM_READ_##SIGN##BIT##_##ENDIAN(src); \
y = PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
x = pcm_sample_read_calc(src, \
AFMT_##SIGN##BIT##_##ENDIAN); \
y = pcm_sample_read_calc(dst, \
AFMT_##SIGN##BIT##_##ENDIAN); \
z = INTPCM##BIT##_T(x) + y; \
x = PCM_CLAMP_##SIGN##BIT(z); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \
pcm_sample_write(dst, x, \
AFMT_##SIGN##BIT##_##ENDIAN); \
} while (count != 0); \
}

18
sys/dev/sound/pcm/feeder_rate.c
View file

@ -471,10 +471,10 @@ z_feed_linear_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
ch = info->channels; \
\
do { \
x = _PCM_READ_##SIGN##BIT##_##ENDIAN(sx); \
y = _PCM_READ_##SIGN##BIT##_##ENDIAN(sy); \
x = pcm_sample_read(sx, AFMT_##SIGN##BIT##_##ENDIAN); \
y = pcm_sample_read(sy, AFMT_##SIGN##BIT##_##ENDIAN); \
x = Z_LINEAR_INTERPOLATE_##BIT(z, x, y); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \
pcm_sample_write(dst, x, AFMT_##SIGN##BIT##_##ENDIAN); \
sx += PCM_##BIT##_BPS; \
sy += PCM_##BIT##_BPS; \
dst += PCM_##BIT##_BPS; \
@ -516,7 +516,7 @@ z_feed_linear_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
c += z >> Z_SHIFT; \
z &= Z_MASK; \
coeff = Z_COEFF_INTERPOLATE(z, z_coeff[c], z_dcoeff[c]); \
x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
x = pcm_sample_read(p, AFMT_##SIGN##BIT##_##ENDIAN); \
v += Z_NORM_##BIT((intpcm64_t)x * coeff); \
z += info->z_dy; \
p adv##= info->channels * PCM_##BIT##_BPS
@ -574,7 +574,8 @@ z_feed_sinc_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
else \
v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \
Z_CLIP_CHECK(v, BIT); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \
pcm_sample_write(dst, Z_CLAMP(v, BIT), \
AFMT_##SIGN##BIT##_##ENDIAN); \
} while (ch != 0); \
}
@ -599,11 +600,11 @@ z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
z_pcoeff = info->z_pcoeff + \
((info->z_alpha * info->z_size) << 1); \
for (i = info->z_size; i != 0; i--) { \
x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
x = pcm_sample_read(p, AFMT_##SIGN##BIT##_##ENDIAN); \
v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \
z_pcoeff++; \
p += info->channels * PCM_##BIT##_BPS; \
x = _PCM_READ_##SIGN##BIT##_##ENDIAN(p); \
x = pcm_sample_read(p, AFMT_##SIGN##BIT##_##ENDIAN); \
v += Z_NORM_##BIT((intpcm64_t)x * *z_pcoeff); \
z_pcoeff++; \
p += info->channels * PCM_##BIT##_BPS; \
@ -613,7 +614,8 @@ z_feed_sinc_polyphase_##SIGN##BIT##ENDIAN(struct z_info *info, uint8_t *dst) \
else \
v >>= Z_COEFF_SHIFT - Z_GUARD_BIT_##BIT; \
Z_CLIP_CHECK(v, BIT); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, Z_CLAMP(v, BIT)); \
pcm_sample_write(dst, Z_CLAMP(v, BIT), \
AFMT_##SIGN##BIT##_##ENDIAN); \
} while (ch != 0); \
}

6
sys/dev/sound/pcm/feeder_volume.c
View file

@ -63,10 +63,12 @@ feed_volume_##SIGN##BIT##ENDIAN(int *vol, int *matrix, \
do { \
dst -= PCM_##BIT##_BPS; \
i--; \
x = PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
x = pcm_sample_read_calc(dst, \
AFMT_##SIGN##BIT##_##ENDIAN); \
v = FEEDVOLUME_CALC##BIT(x, vol[matrix[i]]); \
x = PCM_CLAMP_##SIGN##BIT(v); \
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \
pcm_sample_write(dst, x, \
AFMT_##SIGN##BIT##_##ENDIAN); \
} while (i != 0); \
} while (--count != 0); \
}

557
sys/dev/sound/pcm/pcm.h
View file

@ -31,14 +31,11 @@
#include <sys/param.h>
/*
* Macros for reading/writing PCM sample / int values from bytes array.
* Since every process is done using signed integer (and to make our life
* less miserable), unsigned sample will be converted to its signed
* counterpart and restored during writing back. To avoid overflow,
* we truncate 32bit (and only 32bit) samples down to 24bit (see below
* for the reason), unless SND_PCM_64 is defined.
*/
#include <dev/sound/pcm/g711.h>
#ifndef _KERNEL
#include <assert.h> /* for __assert_unreachable() */
#endif
/*
* Automatically turn on 64bit arithmetic on suitable archs
@ -106,309 +103,6 @@ typedef uint64_t uintpcm64_t;
#define INTPCM24_T(v) ((intpcm24_t)(v))
#define INTPCM32_T(v) ((intpcm32_t)(v))
#if BYTE_ORDER == LITTLE_ENDIAN
#define _PCM_READ_S16_LE(b8) INTPCM_T(*((int16_t *)(b8)))
#define _PCM_READ_S32_LE(b8) INTPCM_T(*((int32_t *)(b8)))
#define _PCM_READ_S16_BE(b8) \
INTPCM_T((b8)[1] | (((int8_t)((b8)[0])) << 8))
#define _PCM_READ_S32_BE(b8) \
INTPCM_T((b8)[3] | ((b8)[2] << 8) | ((b8)[1] << 16) | \
(((int8_t)((b8)[0])) << 24))
#define _PCM_WRITE_S16_LE(b8, val) do { \
*((int16_t *)(b8)) = (val); \
} while (0)
#define _PCM_WRITE_S32_LE(b8, val) do { \
*((int32_t *)(b8)) = (val); \
} while (0)
#define _PCM_WRITE_S16_BE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[1] = val; \
b8[0] = val >> 8; \
} while (0)
#define _PCM_WRITE_S32_BE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[3] = val; \
b8[2] = val >> 8; \
b8[1] = val >> 16; \
b8[0] = val >> 24; \
} while (0)
#define _PCM_READ_U16_LE(b8) \
INTPCM_T((int16_t)(*((uint16_t *)(b8)) ^ 0x8000))
#define _PCM_READ_U32_LE(b8) \
INTPCM_T((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000))
#define _PCM_READ_U16_BE(b8) \
INTPCM_T((b8)[1] | (((int8_t)((b8)[0] ^ 0x80)) << 8))
#define _PCM_READ_U32_BE(b8) \
INTPCM_T((b8)[3] | ((b8)[2] << 8) | ((b8)[1] << 16) | \
(((int8_t)((b8)[0] ^ 0x80)) << 24))
#define _PCM_WRITE_U16_LE(b8, val) do { \
*((uint16_t *)(b8)) = (val) ^ 0x8000; \
} while (0)
#define _PCM_WRITE_U32_LE(b8, val) do { \
*((uint32_t *)(b8)) = (val) ^ 0x80000000; \
} while (0)
#define _PCM_WRITE_U16_BE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[1] = val; \
b8[0] = (val >> 8) ^ 0x80; \
} while (0)
#define _PCM_WRITE_U32_BE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[3] = val; \
b8[2] = val >> 8; \
b8[1] = val >> 16; \
b8[0] = (val >> 24) ^ 0x80; \
} while (0)
#define _PCM_READ_S16_NE(b8) _PCM_READ_S16_LE(b8)
#define _PCM_READ_U16_NE(b8) _PCM_READ_U16_LE(b8)
#define _PCM_READ_S32_NE(b8) _PCM_READ_S32_LE(b8)
#define _PCM_READ_U32_NE(b8) _PCM_READ_U32_LE(b8)
#define _PCM_WRITE_S16_NE(b6) _PCM_WRITE_S16_LE(b8)
#define _PCM_WRITE_U16_NE(b6) _PCM_WRITE_U16_LE(b8)
#define _PCM_WRITE_S32_NE(b6) _PCM_WRITE_S32_LE(b8)
#define _PCM_WRITE_U32_NE(b6) _PCM_WRITE_U32_LE(b8)
#else /* !LITTLE_ENDIAN */
#define _PCM_READ_S16_LE(b8) \
INTPCM_T((b8)[0] | (((int8_t)((b8)[1])) << 8))
#define _PCM_READ_S32_LE(b8) \
INTPCM_T((b8)[0] | ((b8)[1] << 8) | ((b8)[2] << 16) | \
(((int8_t)((b8)[3])) << 24))
#define _PCM_READ_S16_BE(b8) INTPCM_T(*((int16_t *)(b8)))
#define _PCM_READ_S32_BE(b8) INTPCM_T(*((int32_t *)(b8)))
#define _PCM_WRITE_S16_LE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[0] = val; \
b8[1] = val >> 8; \
} while (0)
#define _PCM_WRITE_S32_LE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[0] = val; \
b8[1] = val >> 8; \
b8[2] = val >> 16; \
b8[3] = val >> 24; \
} while (0)
#define _PCM_WRITE_S16_BE(b8, val) do { \
*((int16_t *)(b8)) = (val); \
} while (0)
#define _PCM_WRITE_S32_BE(b8, val) do { \
*((int32_t *)(b8)) = (val); \
} while (0)
#define _PCM_READ_U16_LE(b8) \
INTPCM_T((b8)[0] | (((int8_t)((b8)[1] ^ 0x80)) << 8))
#define _PCM_READ_U32_LE(b8) \
INTPCM_T((b8)[0] | ((b8)[1] << 8) | ((b8)[2] << 16) | \
(((int8_t)((b8)[3] ^ 0x80)) << 24))
#define _PCM_READ_U16_BE(b8) \
INTPCM_T((int16_t)(*((uint16_t *)(b8)) ^ 0x8000))
#define _PCM_READ_U32_BE(b8) \
INTPCM_T((int32_t)(*((uint32_t *)(b8)) ^ 0x80000000))
#define _PCM_WRITE_U16_LE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[0] = val; \
b8[1] = (val >> 8) ^ 0x80; \
} while (0)
#define _PCM_WRITE_U32_LE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[0] = val; \
b8[1] = val >> 8; \
b8[2] = val >> 16; \
b8[3] = (val >> 24) ^ 0x80; \
} while (0)
#define _PCM_WRITE_U16_BE(b8, val) do { \
*((uint16_t *)(b8)) = (val) ^ 0x8000; \
} while (0)
#define _PCM_WRITE_U32_BE(b8, val) do { \
*((uint32_t *)(b8)) = (val) ^ 0x80000000; \
} while (0)
#define _PCM_READ_S16_NE(b8) _PCM_READ_S16_BE(b8)
#define _PCM_READ_U16_NE(b8) _PCM_READ_U16_BE(b8)
#define _PCM_READ_S32_NE(b8) _PCM_READ_S32_BE(b8)
#define _PCM_READ_U32_NE(b8) _PCM_READ_U32_BE(b8)
#define _PCM_WRITE_S16_NE(b6) _PCM_WRITE_S16_BE(b8)
#define _PCM_WRITE_U16_NE(b6) _PCM_WRITE_U16_BE(b8)
#define _PCM_WRITE_S32_NE(b6) _PCM_WRITE_S32_BE(b8)
#define _PCM_WRITE_U32_NE(b6) _PCM_WRITE_U32_BE(b8)
#endif /* LITTLE_ENDIAN */
#define _PCM_READ_S24_LE(b8) \
INTPCM_T((b8)[0] | ((b8)[1] << 8) | (((int8_t)((b8)[2])) << 16))
#define _PCM_READ_S24_BE(b8) \
INTPCM_T((b8)[2] | ((b8)[1] << 8) | (((int8_t)((b8)[0])) << 16))
#define _PCM_WRITE_S24_LE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[0] = val; \
b8[1] = val >> 8; \
b8[2] = val >> 16; \
} while (0)
#define _PCM_WRITE_S24_BE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[2] = val; \
b8[1] = val >> 8; \
b8[0] = val >> 16; \
} while (0)
#define _PCM_READ_U24_LE(b8) \
INTPCM_T((b8)[0] | ((b8)[1] << 8) | \
(((int8_t)((b8)[2] ^ 0x80)) << 16))
#define _PCM_READ_U24_BE(b8) \
INTPCM_T((b8)[2] | ((b8)[1] << 8) | \
(((int8_t)((b8)[0] ^ 0x80)) << 16))
#define _PCM_WRITE_U24_LE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[0] = val; \
b8[1] = val >> 8; \
b8[2] = (val >> 16) ^ 0x80; \
} while (0)
#define _PCM_WRITE_U24_BE(bb8, vval) do { \
intpcm_t val = (vval); \
uint8_t *b8 = (bb8); \
b8[2] = val; \
b8[1] = val >> 8; \
b8[0] = (val >> 16) ^ 0x80; \
} while (0)
#if BYTE_ORDER == LITTLE_ENDIAN
#define _PCM_READ_S24_NE(b8) _PCM_READ_S24_LE(b8)
#define _PCM_READ_U24_NE(b8) _PCM_READ_U24_LE(b8)
#define _PCM_WRITE_S24_NE(b6) _PCM_WRITE_S24_LE(b8)
#define _PCM_WRITE_U24_NE(b6) _PCM_WRITE_U24_LE(b8)
#else /* !LITTLE_ENDIAN */
#define _PCM_READ_S24_NE(b8) _PCM_READ_S24_BE(b8)
#define _PCM_READ_U24_NE(b8) _PCM_READ_U24_BE(b8)
#define _PCM_WRITE_S24_NE(b6) _PCM_WRITE_S24_BE(b8)
#define _PCM_WRITE_U24_NE(b6) _PCM_WRITE_U24_BE(b8)
#endif /* LITTLE_ENDIAN */
/*
* 8bit sample is pretty much useless since it doesn't provide
* sufficient dynamic range throughout our filtering process.
* For the sake of completeness, declare it anyway.
*/
#define _PCM_READ_S8_NE(b8) INTPCM_T(*((int8_t *)(b8)))
#define _PCM_READ_U8_NE(b8) \
INTPCM_T((int8_t)(*((uint8_t *)(b8)) ^ 0x80))
#define _PCM_WRITE_S8_NE(b8, val) do { \
*((int8_t *)(b8)) = (val); \
} while (0)
#define _PCM_WRITE_U8_NE(b8, val) do { \
*((uint8_t *)(b8)) = (val) ^ 0x80; \
} while (0)
/*
* Common macross. Use this instead of "_", unless we want
* the real sample value.
*/
/* 8bit */
#define PCM_READ_S8_NE(b8) _PCM_READ_S8_NE(b8)
#define PCM_READ_U8_NE(b8) _PCM_READ_U8_NE(b8)
#define PCM_WRITE_S8_NE(b8, val) _PCM_WRITE_S8_NE(b8, val)
#define PCM_WRITE_U8_NE(b8, val) _PCM_WRITE_U8_NE(b8, val)
/* 16bit */
#define PCM_READ_S16_LE(b8) _PCM_READ_S16_LE(b8)
#define PCM_READ_S16_BE(b8) _PCM_READ_S16_BE(b8)
#define PCM_READ_U16_LE(b8) _PCM_READ_U16_LE(b8)
#define PCM_READ_U16_BE(b8) _PCM_READ_U16_BE(b8)
#define PCM_WRITE_S16_LE(b8, val) _PCM_WRITE_S16_LE(b8, val)
#define PCM_WRITE_S16_BE(b8, val) _PCM_WRITE_S16_BE(b8, val)
#define PCM_WRITE_U16_LE(b8, val) _PCM_WRITE_U16_LE(b8, val)
#define PCM_WRITE_U16_BE(b8, val) _PCM_WRITE_U16_BE(b8, val)
#define PCM_READ_S16_NE(b8) _PCM_READ_S16_NE(b8)
#define PCM_READ_U16_NE(b8) _PCM_READ_U16_NE(b8)
#define PCM_WRITE_S16_NE(b8) _PCM_WRITE_S16_NE(b8)
#define PCM_WRITE_U16_NE(b8) _PCM_WRITE_U16_NE(b8)
/* 24bit */
#define PCM_READ_S24_LE(b8) _PCM_READ_S24_LE(b8)
#define PCM_READ_S24_BE(b8) _PCM_READ_S24_BE(b8)
#define PCM_READ_U24_LE(b8) _PCM_READ_U24_LE(b8)
#define PCM_READ_U24_BE(b8) _PCM_READ_U24_BE(b8)
#define PCM_WRITE_S24_LE(b8, val) _PCM_WRITE_S24_LE(b8, val)
#define PCM_WRITE_S24_BE(b8, val) _PCM_WRITE_S24_BE(b8, val)
#define PCM_WRITE_U24_LE(b8, val) _PCM_WRITE_U24_LE(b8, val)
#define PCM_WRITE_U24_BE(b8, val) _PCM_WRITE_U24_BE(b8, val)
#define PCM_READ_S24_NE(b8) _PCM_READ_S24_NE(b8)
#define PCM_READ_U24_NE(b8) _PCM_READ_U24_NE(b8)
#define PCM_WRITE_S24_NE(b8) _PCM_WRITE_S24_NE(b8)
#define PCM_WRITE_U24_NE(b8) _PCM_WRITE_U24_NE(b8)
/* 32bit */
#ifdef SND_PCM_64
#define PCM_READ_S32_LE(b8) _PCM_READ_S32_LE(b8)
#define PCM_READ_S32_BE(b8) _PCM_READ_S32_BE(b8)
#define PCM_READ_U32_LE(b8) _PCM_READ_U32_LE(b8)
#define PCM_READ_U32_BE(b8) _PCM_READ_U32_BE(b8)
#define PCM_WRITE_S32_LE(b8, val) _PCM_WRITE_S32_LE(b8, val)
#define PCM_WRITE_S32_BE(b8, val) _PCM_WRITE_S32_BE(b8, val)
#define PCM_WRITE_U32_LE(b8, val) _PCM_WRITE_U32_LE(b8, val)
#define PCM_WRITE_U32_BE(b8, val) _PCM_WRITE_U32_BE(b8, val)
#define PCM_READ_S32_NE(b8) _PCM_READ_S32_NE(b8)
#define PCM_READ_U32_NE(b8) _PCM_READ_U32_NE(b8)
#define PCM_WRITE_S32_NE(b8) _PCM_WRITE_S32_NE(b8)
#define PCM_WRITE_U32_NE(b8) _PCM_WRITE_U32_NE(b8)
#else /* !SND_PCM_64 */
/*
* 24bit integer ?!? This is quite unfortunate, eh? Get the fact straight:
* Dynamic range for:
* 1) Human =~ 140db
* 2) 16bit = 96db (close enough)
* 3) 24bit = 144db (perfect)
* 4) 32bit = 196db (way too much)
* 5) Bugs Bunny = Gazillion!@%$Erbzzztt-EINVAL db
* Since we're not Bugs Bunny ..uh..err.. avoiding 64bit arithmetic, 24bit
* is pretty much sufficient for our signed integer processing.
*/
#define PCM_READ_S32_LE(b8) (_PCM_READ_S32_LE(b8) >> PCM_FXSHIFT)
#define PCM_READ_S32_BE(b8) (_PCM_READ_S32_BE(b8) >> PCM_FXSHIFT)
#define PCM_READ_U32_LE(b8) (_PCM_READ_U32_LE(b8) >> PCM_FXSHIFT)
#define PCM_READ_U32_BE(b8) (_PCM_READ_U32_BE(b8) >> PCM_FXSHIFT)
#define PCM_READ_S32_NE(b8) (_PCM_READ_S32_NE(b8) >> PCM_FXSHIFT)
#define PCM_READ_U32_NE(b8) (_PCM_READ_U32_NE(b8) >> PCM_FXSHIFT)
#define PCM_WRITE_S32_LE(b8, val) \
_PCM_WRITE_S32_LE(b8, (val) << PCM_FXSHIFT)
#define PCM_WRITE_S32_BE(b8, val) \
_PCM_WRITE_S32_BE(b8, (val) << PCM_FXSHIFT)
#define PCM_WRITE_U32_LE(b8, val) \
_PCM_WRITE_U32_LE(b8, (val) << PCM_FXSHIFT)
#define PCM_WRITE_U32_BE(b8, val) \
_PCM_WRITE_U32_BE(b8, (val) << PCM_FXSHIFT)
#define PCM_WRITE_S32_NE(b8, val) \
_PCM_WRITE_S32_NE(b8, (val) << PCM_FXSHIFT)
#define PCM_WRITE_U32_NE(b8, val) \
_PCM_WRITE_U32_NE(b8, (val) << PCM_FXSHIFT)
#endif /* SND_PCM_64 */
#define PCM_CLAMP_S8(val) \
(((val) > PCM_S8_MAX) ? PCM_S8_MAX : \
(((val) < PCM_S8_MIN) ? PCM_S8_MIN : (val)))
@ -435,4 +129,245 @@ typedef uint64_t uintpcm64_t;
#define PCM_CLAMP_U24(val) PCM_CLAMP_S24(val)
#define PCM_CLAMP_U32(val) PCM_CLAMP_S32(val)
static const struct {
const uint8_t ulaw_to_u8[G711_TABLE_SIZE];
const uint8_t alaw_to_u8[G711_TABLE_SIZE];
const uint8_t u8_to_ulaw[G711_TABLE_SIZE];
const uint8_t u8_to_alaw[G711_TABLE_SIZE];
} xlaw_conv_tables = {
ULAW_TO_U8,
ALAW_TO_U8,
U8_TO_ULAW,
U8_TO_ALAW
};
/*
* Functions for reading/writing PCM integer sample values from bytes array.
* Since every process is done using signed integer (and to make our life less
* miserable), unsigned sample will be converted to its signed counterpart and
* restored during writing back.
*/
static __always_inline __unused intpcm_t
pcm_sample_read(const uint8_t *src, uint32_t fmt)
{
intpcm_t v;
fmt = AFMT_ENCODING(fmt);
switch (fmt) {
case AFMT_AC3:
v = 0;
break;
case AFMT_MU_LAW:
v = _G711_TO_INTPCM(xlaw_conv_tables.ulaw_to_u8, *src);
break;
case AFMT_A_LAW:
v = _G711_TO_INTPCM(xlaw_conv_tables.alaw_to_u8, *src);
break;
case AFMT_S8:
v = INTPCM_T((int8_t)*src);
break;
case AFMT_U8:
v = INTPCM_T((int8_t)(*src ^ 0x80));
break;
case AFMT_S16_LE:
v = INTPCM_T(src[0] | (int8_t)src[1] << 8);
break;
case AFMT_S16_BE:
v = INTPCM_T(src[1] | (int8_t)src[0] << 8);
break;
case AFMT_U16_LE:
v = INTPCM_T(src[0] | (int8_t)(src[1] ^ 0x80) << 8);
break;
case AFMT_U16_BE:
v = INTPCM_T(src[1] | (int8_t)(src[0] ^ 0x80) << 8);
break;
case AFMT_S24_LE:
v = INTPCM_T(src[0] | src[1] << 8 | (int8_t)src[2] << 16);
break;
case AFMT_S24_BE:
v = INTPCM_T(src[2] | src[1] << 8 | (int8_t)src[0] << 16);
break;
case AFMT_U24_LE:
v = INTPCM_T(src[0] | src[1] << 8 |
(int8_t)(src[2] ^ 0x80) << 16);
break;
case AFMT_U24_BE:
v = INTPCM_T(src[2] | src[1] << 8 |
(int8_t)(src[0] ^ 0x80) << 16);
break;
case AFMT_S32_LE:
v = INTPCM_T(src[0] | src[1] << 8 | src[2] << 16 |
(int8_t)src[3] << 24);
break;
case AFMT_S32_BE:
v = INTPCM_T(src[3] | src[2] << 8 | src[1] << 16 |
(int8_t)src[0] << 24);
break;
case AFMT_U32_LE:
v = INTPCM_T(src[0] | src[1] << 8 | src[2] << 16 |
(int8_t)(src[3] ^ 0x80) << 24);
break;
case AFMT_U32_BE:
v = INTPCM_T(src[3] | src[2] << 8 | src[1] << 16 |
(int8_t)(src[0] ^ 0x80) << 24);
break;
default:
v = 0;
printf("%s(): unknown format: 0x%08x\n", __func__, fmt);
__assert_unreachable();
}
return (v);
}
/*
* Read sample and normalize to 32-bit magnitude.
*/
static __always_inline __unused intpcm_t
pcm_sample_read_norm(const uint8_t *src, uint32_t fmt)
{
return (pcm_sample_read(src, fmt) << (32 - AFMT_BIT(fmt)));
}
/*
* Read sample and restrict magnitude to 24 bits.
*/
static __always_inline __unused intpcm_t
pcm_sample_read_calc(const uint8_t *src, uint32_t fmt)
{
intpcm_t v;
v = pcm_sample_read(src, fmt);
#ifndef SND_PCM_64
/*
* Dynamic range for humans: ~140db.
*
* 16bit = 96db (close enough)
* 24bit = 144db (perfect)
* 32bit = 196db (way too much)
*
* 24bit is pretty much sufficient for our signed integer processing.
* Also, to avoid overflow, we truncate 32bit (and only 32bit) samples
* down to 24bit (see below for the reason), unless SND_PCM_64 is
* defined.
*/
if (fmt & AFMT_32BIT)
v >>= PCM_FXSHIFT;
#endif
return (v);
}
static __always_inline __unused void
pcm_sample_write(uint8_t *dst, intpcm_t v, uint32_t fmt)
{
fmt = AFMT_ENCODING(fmt);
switch (fmt) {
case AFMT_AC3:
*(int16_t *)dst = 0;
break;
case AFMT_MU_LAW:
*dst = _INTPCM_TO_G711(xlaw_conv_tables.u8_to_ulaw, v);
break;
case AFMT_A_LAW:
*dst = _INTPCM_TO_G711(xlaw_conv_tables.u8_to_alaw, v);
break;
case AFMT_S8:
*(int8_t *)dst = v;
break;
case AFMT_U8:
*(int8_t *)dst = v ^ 0x80;
break;
case AFMT_S16_LE:
dst[0] = v;
dst[1] = v >> 8;
break;
case AFMT_S16_BE:
dst[1] = v;
dst[0] = v >> 8;
break;
case AFMT_U16_LE:
dst[0] = v;
dst[1] = (v >> 8) ^ 0x80;
break;
case AFMT_U16_BE:
dst[1] = v;
dst[0] = (v >> 8) ^ 0x80;
break;
case AFMT_S24_LE:
dst[0] = v;
dst[1] = v >> 8;
dst[2] = v >> 16;
break;
case AFMT_S24_BE:
dst[2] = v;
dst[1] = v >> 8;
dst[0] = v >> 16;
break;
case AFMT_U24_LE:
dst[0] = v;
dst[1] = v >> 8;
dst[2] = (v >> 16) ^ 0x80;
break;
case AFMT_U24_BE:
dst[2] = v;
dst[1] = v >> 8;
dst[0] = (v >> 16) ^ 0x80;
break;
case AFMT_S32_LE:
dst[0] = v;
dst[1] = v >> 8;
dst[2] = v >> 16;
dst[3] = v >> 24;
break;
case AFMT_S32_BE:
dst[3] = v;
dst[2] = v >> 8;
dst[1] = v >> 16;
dst[0] = v >> 24;
break;
case AFMT_U32_LE:
dst[0] = v;
dst[1] = v >> 8;
dst[2] = v >> 16;
dst[3] = (v >> 24) ^ 0x80;
break;
case AFMT_U32_BE:
dst[3] = v;
dst[2] = v >> 8;
dst[1] = v >> 16;
dst[0] = (v >> 24) ^ 0x80;
break;
default:
printf("%s(): unknown format: 0x%08x\n", __func__, fmt);
__assert_unreachable();
}
}
/*
* Write sample and normalize to original magnitude.
*/
static __always_inline __unused void
pcm_sample_write_norm(uint8_t *dst, intpcm_t v, uint32_t fmt)
{
pcm_sample_write(dst, v >> (32 - AFMT_BIT(fmt)), fmt);
}
/*
* To be used with pcm_sample_read_calc().
*/
static __always_inline __unused void
pcm_sample_write_calc(uint8_t *dst, intpcm_t v, uint32_t fmt)
{
#ifndef SND_PCM_64
/* Shift back to 32-bit magnitude. */
if (fmt & AFMT_32BIT)
v <<= PCM_FXSHIFT;
#endif
pcm_sample_write(dst, v, fmt);
}
#endif /* !_SND_PCM_H_ */

1
sys/dev/sound/pcm/sndstat.c
View file

@ -47,7 +47,6 @@
#include <sys/sx.h>
#include <dev/sound/pcm/sound.h>
#include <dev/sound/pcm/pcm.h>
#include "feeder_if.h"

1
sys/dev/sound/pcm/sound.h
View file

@ -84,7 +84,6 @@ struct snd_mixer;
#include <dev/sound/pcm/buffer.h>
#include <dev/sound/pcm/matrix.h>
#include <dev/sound/pcm/channel.h>
#include <dev/sound/pcm/pcm.h>
#include <dev/sound/pcm/feeder.h>
#include <dev/sound/pcm/mixer.h>
#include <dev/sound/pcm/dsp.h>

278
tests/sys/sound/pcm_read_write.c
View file

@ -115,272 +115,6 @@ local_calc_limit(intpcm_t value, int val_bits)
return value;
}
/* Lookup tables to read u-law and A-law sample formats. */
static const uint8_t ulaw_to_u8[G711_TABLE_SIZE] = ULAW_TO_U8;
static const uint8_t alaw_to_u8[G711_TABLE_SIZE] = ALAW_TO_U8;
/* Helper function to read one sample value from a buffer. */
static intpcm_t
local_pcm_read(uint8_t *src, uint32_t format)
{
intpcm_t value;
switch (format) {
case AFMT_S8:
value = _PCM_READ_S8_NE(src);
break;
case AFMT_U8:
value = _PCM_READ_U8_NE(src);
break;
case AFMT_S16_LE:
value = _PCM_READ_S16_LE(src);
break;
case AFMT_S16_BE:
value = _PCM_READ_S16_BE(src);
break;
case AFMT_U16_LE:
value = _PCM_READ_U16_LE(src);
break;
case AFMT_U16_BE:
value = _PCM_READ_U16_BE(src);
break;
case AFMT_S24_LE:
value = _PCM_READ_S24_LE(src);
break;
case AFMT_S24_BE:
value = _PCM_READ_S24_BE(src);
break;
case AFMT_U24_LE:
value = _PCM_READ_U24_LE(src);
break;
case AFMT_U24_BE:
value = _PCM_READ_U24_BE(src);
break;
case AFMT_S32_LE:
value = _PCM_READ_S32_LE(src);
break;
case AFMT_S32_BE:
value = _PCM_READ_S32_BE(src);
break;
case AFMT_U32_LE:
value = _PCM_READ_U32_LE(src);
break;
case AFMT_U32_BE:
value = _PCM_READ_U32_BE(src);
break;
case AFMT_MU_LAW:
value = _G711_TO_INTPCM(ulaw_to_u8, *src);
break;
case AFMT_A_LAW:
value = _G711_TO_INTPCM(alaw_to_u8, *src);
break;
default:
value = 0;
}
return (value);
}
/* Helper function to read one sample value from a buffer for calculations. */
static intpcm_t
local_pcm_read_calc(uint8_t *src, uint32_t format)
{
intpcm_t value;
switch (format) {
case AFMT_S8:
value = PCM_READ_S8_NE(src);
break;
case AFMT_U8:
value = PCM_READ_U8_NE(src);
break;
case AFMT_S16_LE:
value = PCM_READ_S16_LE(src);
break;
case AFMT_S16_BE:
value = PCM_READ_S16_BE(src);
break;
case AFMT_U16_LE:
value = PCM_READ_U16_LE(src);
break;
case AFMT_U16_BE:
value = PCM_READ_U16_BE(src);
break;
case AFMT_S24_LE:
value = PCM_READ_S24_LE(src);
break;
case AFMT_S24_BE:
value = PCM_READ_S24_BE(src);
break;
case AFMT_U24_LE:
value = PCM_READ_U24_LE(src);
break;
case AFMT_U24_BE:
value = PCM_READ_U24_BE(src);
break;
case AFMT_S32_LE:
value = PCM_READ_S32_LE(src);
break;
case AFMT_S32_BE:
value = PCM_READ_S32_BE(src);
break;
case AFMT_U32_LE:
value = PCM_READ_U32_LE(src);
break;
case AFMT_U32_BE:
value = PCM_READ_U32_BE(src);
break;
case AFMT_MU_LAW:
value = _G711_TO_INTPCM(ulaw_to_u8, *src);
break;
case AFMT_A_LAW:
value = _G711_TO_INTPCM(alaw_to_u8, *src);
break;
default:
value = 0;
}
return (value);
}
/* Helper function to read one normalized sample from a buffer. */
static intpcm_t
local_pcm_read_norm(uint8_t *src, uint32_t format)
{
intpcm_t value;
value = local_pcm_read(src, format);
value <<= (32 - AFMT_BIT(format));
return (value);
}
/* Lookup tables to write u-law and A-law sample formats. */
static const uint8_t u8_to_ulaw[G711_TABLE_SIZE] = U8_TO_ULAW;
static const uint8_t u8_to_alaw[G711_TABLE_SIZE] = U8_TO_ALAW;
/* Helper function to write one sample value to a buffer. */
static void
local_pcm_write(uint8_t *dst, intpcm_t value, uint32_t format)
{
switch (format) {
case AFMT_S8:
_PCM_WRITE_S8_NE(dst, value);
break;
case AFMT_U8:
_PCM_WRITE_U8_NE(dst, value);
break;
case AFMT_S16_LE:
_PCM_WRITE_S16_LE(dst, value);
break;
case AFMT_S16_BE:
_PCM_WRITE_S16_BE(dst, value);
break;
case AFMT_U16_LE:
_PCM_WRITE_U16_LE(dst, value);
break;
case AFMT_U16_BE:
_PCM_WRITE_U16_BE(dst, value);
break;
case AFMT_S24_LE:
_PCM_WRITE_S24_LE(dst, value);
break;
case AFMT_S24_BE:
_PCM_WRITE_S24_BE(dst, value);
break;
case AFMT_U24_LE:
_PCM_WRITE_U24_LE(dst, value);
break;
case AFMT_U24_BE:
_PCM_WRITE_U24_BE(dst, value);
break;
case AFMT_S32_LE:
_PCM_WRITE_S32_LE(dst, value);
break;
case AFMT_S32_BE:
_PCM_WRITE_S32_BE(dst, value);
break;
case AFMT_U32_LE:
_PCM_WRITE_U32_LE(dst, value);
break;
case AFMT_U32_BE:
_PCM_WRITE_U32_BE(dst, value);
break;
case AFMT_MU_LAW:
*dst = _INTPCM_TO_G711(u8_to_ulaw, value);
break;
case AFMT_A_LAW:
*dst = _INTPCM_TO_G711(u8_to_alaw, value);
break;
default:
value = 0;
}
}
/* Helper function to write one calculation sample value to a buffer. */
static void
local_pcm_write_calc(uint8_t *dst, intpcm_t value, uint32_t format)
{
switch (format) {
case AFMT_S8:
PCM_WRITE_S8_NE(dst, value);
break;
case AFMT_U8:
PCM_WRITE_U8_NE(dst, value);
break;
case AFMT_S16_LE:
PCM_WRITE_S16_LE(dst, value);
break;
case AFMT_S16_BE:
PCM_WRITE_S16_BE(dst, value);
break;
case AFMT_U16_LE:
PCM_WRITE_U16_LE(dst, value);
break;
case AFMT_U16_BE:
PCM_WRITE_U16_BE(dst, value);
break;
case AFMT_S24_LE:
PCM_WRITE_S24_LE(dst, value);
break;
case AFMT_S24_BE:
PCM_WRITE_S24_BE(dst, value);
break;
case AFMT_U24_LE:
PCM_WRITE_U24_LE(dst, value);
break;
case AFMT_U24_BE:
PCM_WRITE_U24_BE(dst, value);
break;
case AFMT_S32_LE:
PCM_WRITE_S32_LE(dst, value);
break;
case AFMT_S32_BE:
PCM_WRITE_S32_BE(dst, value);
break;
case AFMT_U32_LE:
PCM_WRITE_U32_LE(dst, value);
break;
case AFMT_U32_BE:
PCM_WRITE_U32_BE(dst, value);
break;
case AFMT_MU_LAW:
*dst = _INTPCM_TO_G711(u8_to_ulaw, value);
break;
case AFMT_A_LAW:
*dst = _INTPCM_TO_G711(u8_to_alaw, value);
break;
default:
value = 0;
}
}
/* Helper function to write one normalized sample to a buffer. */
static void
local_pcm_write_norm(uint8_t *dst, intpcm_t value, uint32_t format)
{
local_pcm_write(dst, value >> (32 - AFMT_BIT(format)), format);
}
ATF_TC(pcm_read);
ATF_TC_HEAD(pcm_read, tc)
{
@ -403,21 +137,21 @@ ATF_TC_BODY(pcm_read, tc)
/* Read sample at format magnitude. */
expected = test->value;
result = local_pcm_read(src, test->format);
result = pcm_sample_read(src, test->format);
ATF_CHECK_MSG(result == expected,
"pcm_read[\"%s\"].value: expected=0x%08x, result=0x%08x",
test->label, expected, result);
/* Read sample at format magnitude, for calculations. */
expected = local_calc_limit(test->value, test->size * 8);
result = local_pcm_read_calc(src, test->format);
result = pcm_sample_read_calc(src, test->format);
ATF_CHECK_MSG(result == expected,
"pcm_read[\"%s\"].calc: expected=0x%08x, result=0x%08x",
test->label, expected, result);
/* Read sample at full 32 bit magnitude. */
expected = local_normalize(test->value, test->size * 8, 32);
result = local_pcm_read_norm(src, test->format);
result = pcm_sample_read_norm(src, test->format);
ATF_CHECK_MSG(result == expected,
"pcm_read[\"%s\"].norm: expected=0x%08x, result=0x%08x",
test->label, expected, result);
@ -445,7 +179,7 @@ ATF_TC_BODY(pcm_write, tc)
memcpy(expected, test->buffer, sizeof(expected));
memset(dst, 0x00, sizeof(dst));
value = test->value;
local_pcm_write(dst, value, test->format);
pcm_sample_write(dst, value, test->format);
ATF_CHECK_MSG(memcmp(dst, expected, sizeof(dst)) == 0,
"pcm_write[\"%s\"].value: "
"expected={0x%02x, 0x%02x, 0x%02x, 0x%02x}, "
@ -467,7 +201,7 @@ ATF_TC_BODY(pcm_write, tc)
else
expected[0] = 0x00;
}
local_pcm_write_calc(dst, value, test->format);
pcm_sample_write_calc(dst, value, test->format);
ATF_CHECK_MSG(memcmp(dst, expected, sizeof(dst)) == 0,
"pcm_write[\"%s\"].calc: "
"expected={0x%02x, 0x%02x, 0x%02x, 0x%02x}, "
@ -479,7 +213,7 @@ ATF_TC_BODY(pcm_write, tc)
memcpy(expected, test->buffer, sizeof(expected));
memset(dst, 0x00, sizeof(dst));
value = local_normalize(test->value, test->size * 8, 32);
local_pcm_write_norm(dst, value, test->format);
pcm_sample_write_norm(dst, value, test->format);
ATF_CHECK_MSG(memcmp(dst, expected, sizeof(dst)) == 0,
"pcm_write[\"%s\"].norm: "
"expected={0x%02x, 0x%02x, 0x%02x, 0x%02x}, "