1537078d8f
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
703 lines
17 KiB
C
703 lines
17 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2008-2009 Ariff Abdullah <ariff@FreeBSD.org>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* feeder_eq: Parametric (compile time) Software Equalizer. Though accidental,
|
|
* it proves good enough for educational and general consumption.
|
|
*
|
|
* "Cookbook formulae for audio EQ biquad filter coefficients"
|
|
* by Robert Bristow-Johnson <rbj@audioimagination.com>
|
|
* - http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
|
|
*/
|
|
|
|
#ifdef _KERNEL
|
|
#ifdef HAVE_KERNEL_OPTION_HEADERS
|
|
#include "opt_snd.h"
|
|
#endif
|
|
#include <dev/sound/pcm/sound.h>
|
|
#include <dev/sound/pcm/pcm.h>
|
|
#include "feeder_if.h"
|
|
|
|
#define SND_USE_FXDIV
|
|
#include "snd_fxdiv_gen.h"
|
|
|
|
SND_DECLARE_FILE("$FreeBSD$");
|
|
#endif
|
|
|
|
#include "feeder_eq_gen.h"
|
|
|
|
#define FEEDEQ_LEVELS \
|
|
(((FEEDEQ_GAIN_MAX - FEEDEQ_GAIN_MIN) * \
|
|
(FEEDEQ_GAIN_DIV / FEEDEQ_GAIN_STEP)) + 1)
|
|
|
|
#define FEEDEQ_L2GAIN(v) \
|
|
((int)min(((v) * FEEDEQ_LEVELS) / 100, FEEDEQ_LEVELS - 1))
|
|
|
|
#define FEEDEQ_PREAMP_IPART(x) (abs(x) >> FEEDEQ_GAIN_SHIFT)
|
|
#define FEEDEQ_PREAMP_FPART(x) (abs(x) & FEEDEQ_GAIN_FMASK)
|
|
#define FEEDEQ_PREAMP_SIGNVAL(x) ((x) < 0 ? -1 : 1)
|
|
#define FEEDEQ_PREAMP_SIGNMARK(x) (((x) < 0) ? '-' : '+')
|
|
|
|
#define FEEDEQ_PREAMP_IMIN -192
|
|
#define FEEDEQ_PREAMP_IMAX 192
|
|
#define FEEDEQ_PREAMP_FMIN 0
|
|
#define FEEDEQ_PREAMP_FMAX 9
|
|
|
|
#define FEEDEQ_PREAMP_INVALID INT_MAX
|
|
|
|
#define FEEDEQ_IF2PREAMP(i, f) \
|
|
((abs(i) << FEEDEQ_GAIN_SHIFT) | \
|
|
(((abs(f) / FEEDEQ_GAIN_STEP) * FEEDEQ_GAIN_STEP) & \
|
|
FEEDEQ_GAIN_FMASK))
|
|
|
|
#define FEEDEQ_PREAMP_MIN \
|
|
(FEEDEQ_PREAMP_SIGNVAL(FEEDEQ_GAIN_MIN) * \
|
|
FEEDEQ_IF2PREAMP(FEEDEQ_GAIN_MIN, 0))
|
|
|
|
#define FEEDEQ_PREAMP_MAX \
|
|
(FEEDEQ_PREAMP_SIGNVAL(FEEDEQ_GAIN_MAX) * \
|
|
FEEDEQ_IF2PREAMP(FEEDEQ_GAIN_MAX, 0))
|
|
|
|
#define FEEDEQ_PREAMP_DEFAULT FEEDEQ_IF2PREAMP(0, 0)
|
|
|
|
#define FEEDEQ_PREAMP2IDX(v) \
|
|
((int32_t)((FEEDEQ_GAIN_MAX * (FEEDEQ_GAIN_DIV / \
|
|
FEEDEQ_GAIN_STEP)) + (FEEDEQ_PREAMP_SIGNVAL(v) * \
|
|
FEEDEQ_PREAMP_IPART(v) * (FEEDEQ_GAIN_DIV / \
|
|
FEEDEQ_GAIN_STEP)) + (FEEDEQ_PREAMP_SIGNVAL(v) * \
|
|
(FEEDEQ_PREAMP_FPART(v) / FEEDEQ_GAIN_STEP))))
|
|
|
|
static int feeder_eq_exact_rate = 0;
|
|
|
|
#ifdef _KERNEL
|
|
static char feeder_eq_presets[] = FEEDER_EQ_PRESETS;
|
|
SYSCTL_STRING(_hw_snd, OID_AUTO, feeder_eq_presets, CTLFLAG_RD,
|
|
&feeder_eq_presets, 0, "compile-time eq presets");
|
|
|
|
SYSCTL_INT(_hw_snd, OID_AUTO, feeder_eq_exact_rate, CTLFLAG_RWTUN,
|
|
&feeder_eq_exact_rate, 0, "force exact rate validation");
|
|
#endif
|
|
|
|
struct feed_eq_info;
|
|
|
|
typedef void (*feed_eq_t)(struct feed_eq_info *, uint8_t *, uint32_t);
|
|
|
|
struct feed_eq_tone {
|
|
intpcm_t o1[SND_CHN_MAX];
|
|
intpcm_t o2[SND_CHN_MAX];
|
|
intpcm_t i1[SND_CHN_MAX];
|
|
intpcm_t i2[SND_CHN_MAX];
|
|
int gain;
|
|
};
|
|
|
|
struct feed_eq_info {
|
|
struct feed_eq_tone treble;
|
|
struct feed_eq_tone bass;
|
|
struct feed_eq_coeff *coeff;
|
|
feed_eq_t biquad;
|
|
uint32_t channels;
|
|
uint32_t rate;
|
|
uint32_t align;
|
|
int32_t preamp;
|
|
int state;
|
|
};
|
|
|
|
#if !defined(_KERNEL) && defined(FEEDEQ_ERR_CLIP)
|
|
#define FEEDEQ_ERR_CLIP_CHECK(t, v) do { \
|
|
if ((v) < PCM_S32_MIN || (v) > PCM_S32_MAX) \
|
|
errx(1, "\n\n%s(): ["#t"] Sample clipping: %jd\n", \
|
|
__func__, (intmax_t)(v)); \
|
|
} while (0)
|
|
#else
|
|
#define FEEDEQ_ERR_CLIP_CHECK(...)
|
|
#endif
|
|
|
|
#define FEEDEQ_CLAMP(v) (((v) > PCM_S32_MAX) ? PCM_S32_MAX : \
|
|
(((v) < PCM_S32_MIN) ? PCM_S32_MIN : \
|
|
(v)))
|
|
|
|
#define FEEDEQ_DECLARE(SIGN, BIT, ENDIAN) \
|
|
static void \
|
|
feed_eq_biquad_##SIGN##BIT##ENDIAN(struct feed_eq_info *info, \
|
|
uint8_t *dst, uint32_t count) \
|
|
{ \
|
|
struct feed_eq_coeff_tone *treble, *bass; \
|
|
intpcm64_t w; \
|
|
intpcm_t v; \
|
|
uint32_t i, j; \
|
|
int32_t pmul, pshift; \
|
|
\
|
|
pmul = feed_eq_preamp[info->preamp].mul; \
|
|
pshift = feed_eq_preamp[info->preamp].shift; \
|
|
\
|
|
if (info->state == FEEDEQ_DISABLE) { \
|
|
j = count * info->channels; \
|
|
dst += j * PCM_##BIT##_BPS; \
|
|
do { \
|
|
dst -= PCM_##BIT##_BPS; \
|
|
v = _PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
|
|
v = ((intpcm64_t)pmul * v) >> pshift; \
|
|
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, v); \
|
|
} while (--j != 0); \
|
|
\
|
|
return; \
|
|
} \
|
|
\
|
|
treble = &(info->coeff[info->treble.gain].treble); \
|
|
bass = &(info->coeff[info->bass.gain].bass); \
|
|
\
|
|
do { \
|
|
i = 0; \
|
|
j = info->channels; \
|
|
do { \
|
|
v = _PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
|
|
v <<= 32 - BIT; \
|
|
v = ((intpcm64_t)pmul * v) >> pshift; \
|
|
\
|
|
w = (intpcm64_t)v * treble->b0; \
|
|
w += (intpcm64_t)info->treble.i1[i] * treble->b1; \
|
|
w += (intpcm64_t)info->treble.i2[i] * treble->b2; \
|
|
w -= (intpcm64_t)info->treble.o1[i] * treble->a1; \
|
|
w -= (intpcm64_t)info->treble.o2[i] * treble->a2; \
|
|
info->treble.i2[i] = info->treble.i1[i]; \
|
|
info->treble.i1[i] = v; \
|
|
info->treble.o2[i] = info->treble.o1[i]; \
|
|
w >>= FEEDEQ_COEFF_SHIFT; \
|
|
FEEDEQ_ERR_CLIP_CHECK(treble, w); \
|
|
v = FEEDEQ_CLAMP(w); \
|
|
info->treble.o1[i] = v; \
|
|
\
|
|
w = (intpcm64_t)v * bass->b0; \
|
|
w += (intpcm64_t)info->bass.i1[i] * bass->b1; \
|
|
w += (intpcm64_t)info->bass.i2[i] * bass->b2; \
|
|
w -= (intpcm64_t)info->bass.o1[i] * bass->a1; \
|
|
w -= (intpcm64_t)info->bass.o2[i] * bass->a2; \
|
|
info->bass.i2[i] = info->bass.i1[i]; \
|
|
info->bass.i1[i] = v; \
|
|
info->bass.o2[i] = info->bass.o1[i]; \
|
|
w >>= FEEDEQ_COEFF_SHIFT; \
|
|
FEEDEQ_ERR_CLIP_CHECK(bass, w); \
|
|
v = FEEDEQ_CLAMP(w); \
|
|
info->bass.o1[i] = v; \
|
|
\
|
|
v >>= 32 - BIT; \
|
|
_PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, v); \
|
|
dst += PCM_##BIT##_BPS; \
|
|
i++; \
|
|
} while (--j != 0); \
|
|
} while (--count != 0); \
|
|
}
|
|
|
|
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
|
|
FEEDEQ_DECLARE(S, 16, LE)
|
|
FEEDEQ_DECLARE(S, 32, LE)
|
|
#endif
|
|
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
|
|
FEEDEQ_DECLARE(S, 16, BE)
|
|
FEEDEQ_DECLARE(S, 32, BE)
|
|
#endif
|
|
#ifdef SND_FEEDER_MULTIFORMAT
|
|
FEEDEQ_DECLARE(S, 8, NE)
|
|
FEEDEQ_DECLARE(S, 24, LE)
|
|
FEEDEQ_DECLARE(S, 24, BE)
|
|
FEEDEQ_DECLARE(U, 8, NE)
|
|
FEEDEQ_DECLARE(U, 16, LE)
|
|
FEEDEQ_DECLARE(U, 24, LE)
|
|
FEEDEQ_DECLARE(U, 32, LE)
|
|
FEEDEQ_DECLARE(U, 16, BE)
|
|
FEEDEQ_DECLARE(U, 24, BE)
|
|
FEEDEQ_DECLARE(U, 32, BE)
|
|
#endif
|
|
|
|
#define FEEDEQ_ENTRY(SIGN, BIT, ENDIAN) \
|
|
{ \
|
|
AFMT_##SIGN##BIT##_##ENDIAN, \
|
|
feed_eq_biquad_##SIGN##BIT##ENDIAN \
|
|
}
|
|
|
|
|
|
static const struct {
|
|
uint32_t format;
|
|
feed_eq_t biquad;
|
|
} feed_eq_biquad_tab[] = {
|
|
#if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
|
|
FEEDEQ_ENTRY(S, 16, LE),
|
|
FEEDEQ_ENTRY(S, 32, LE),
|
|
#endif
|
|
#if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
|
|
FEEDEQ_ENTRY(S, 16, BE),
|
|
FEEDEQ_ENTRY(S, 32, BE),
|
|
#endif
|
|
#ifdef SND_FEEDER_MULTIFORMAT
|
|
FEEDEQ_ENTRY(S, 8, NE),
|
|
FEEDEQ_ENTRY(S, 24, LE),
|
|
FEEDEQ_ENTRY(S, 24, BE),
|
|
FEEDEQ_ENTRY(U, 8, NE),
|
|
FEEDEQ_ENTRY(U, 16, LE),
|
|
FEEDEQ_ENTRY(U, 24, LE),
|
|
FEEDEQ_ENTRY(U, 32, LE),
|
|
FEEDEQ_ENTRY(U, 16, BE),
|
|
FEEDEQ_ENTRY(U, 24, BE),
|
|
FEEDEQ_ENTRY(U, 32, BE)
|
|
#endif
|
|
};
|
|
|
|
#define FEEDEQ_BIQUAD_TAB_SIZE \
|
|
((int32_t)(sizeof(feed_eq_biquad_tab) / sizeof(feed_eq_biquad_tab[0])))
|
|
|
|
static struct feed_eq_coeff *
|
|
feed_eq_coeff_rate(uint32_t rate)
|
|
{
|
|
uint32_t spd, threshold;
|
|
int i;
|
|
|
|
if (rate < FEEDEQ_RATE_MIN || rate > FEEDEQ_RATE_MAX)
|
|
return (NULL);
|
|
|
|
/*
|
|
* Not all rates are supported. Choose the best rate that we can to
|
|
* allow 'sloppy' conversion. Good enough for naive listeners.
|
|
*/
|
|
for (i = 0; i < FEEDEQ_TAB_SIZE; i++) {
|
|
spd = feed_eq_tab[i].rate;
|
|
threshold = spd + ((i < (FEEDEQ_TAB_SIZE - 1) &&
|
|
feed_eq_tab[i + 1].rate > spd) ?
|
|
((feed_eq_tab[i + 1].rate - spd) >> 1) : 0);
|
|
if (rate == spd ||
|
|
(feeder_eq_exact_rate == 0 && rate <= threshold))
|
|
return (feed_eq_tab[i].coeff);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
int
|
|
feeder_eq_validrate(uint32_t rate)
|
|
{
|
|
|
|
if (feed_eq_coeff_rate(rate) != NULL)
|
|
return (1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
feed_eq_reset(struct feed_eq_info *info)
|
|
{
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < info->channels; i++) {
|
|
info->treble.i1[i] = 0;
|
|
info->treble.i2[i] = 0;
|
|
info->treble.o1[i] = 0;
|
|
info->treble.o2[i] = 0;
|
|
info->bass.i1[i] = 0;
|
|
info->bass.i2[i] = 0;
|
|
info->bass.o1[i] = 0;
|
|
info->bass.o2[i] = 0;
|
|
}
|
|
}
|
|
|
|
static int
|
|
feed_eq_setup(struct feed_eq_info *info)
|
|
{
|
|
|
|
info->coeff = feed_eq_coeff_rate(info->rate);
|
|
if (info->coeff == NULL)
|
|
return (EINVAL);
|
|
|
|
feed_eq_reset(info);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
feed_eq_init(struct pcm_feeder *f)
|
|
{
|
|
struct feed_eq_info *info;
|
|
feed_eq_t biquad_op;
|
|
int i;
|
|
|
|
if (f->desc->in != f->desc->out)
|
|
return (EINVAL);
|
|
|
|
biquad_op = NULL;
|
|
|
|
for (i = 0; i < FEEDEQ_BIQUAD_TAB_SIZE && biquad_op == NULL; i++) {
|
|
if (AFMT_ENCODING(f->desc->in) == feed_eq_biquad_tab[i].format)
|
|
biquad_op = feed_eq_biquad_tab[i].biquad;
|
|
}
|
|
|
|
if (biquad_op == NULL)
|
|
return (EINVAL);
|
|
|
|
info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
|
|
if (info == NULL)
|
|
return (ENOMEM);
|
|
|
|
info->channels = AFMT_CHANNEL(f->desc->in);
|
|
info->align = info->channels * AFMT_BPS(f->desc->in);
|
|
|
|
info->rate = FEEDEQ_RATE_MIN;
|
|
info->treble.gain = FEEDEQ_L2GAIN(50);
|
|
info->bass.gain = FEEDEQ_L2GAIN(50);
|
|
info->preamp = FEEDEQ_PREAMP2IDX(FEEDEQ_PREAMP_DEFAULT);
|
|
info->state = FEEDEQ_UNKNOWN;
|
|
|
|
info->biquad = biquad_op;
|
|
|
|
f->data = info;
|
|
|
|
return (feed_eq_setup(info));
|
|
}
|
|
|
|
static int
|
|
feed_eq_set(struct pcm_feeder *f, int what, int value)
|
|
{
|
|
struct feed_eq_info *info;
|
|
|
|
info = f->data;
|
|
|
|
switch (what) {
|
|
case FEEDEQ_CHANNELS:
|
|
if (value < SND_CHN_MIN || value > SND_CHN_MAX)
|
|
return (EINVAL);
|
|
info->channels = (uint32_t)value;
|
|
info->align = info->channels * AFMT_BPS(f->desc->in);
|
|
feed_eq_reset(info);
|
|
break;
|
|
case FEEDEQ_RATE:
|
|
if (feeder_eq_validrate(value) == 0)
|
|
return (EINVAL);
|
|
info->rate = (uint32_t)value;
|
|
if (info->state == FEEDEQ_UNKNOWN)
|
|
info->state = FEEDEQ_ENABLE;
|
|
return (feed_eq_setup(info));
|
|
break;
|
|
case FEEDEQ_TREBLE:
|
|
case FEEDEQ_BASS:
|
|
if (value < 0 || value > 100)
|
|
return (EINVAL);
|
|
if (what == FEEDEQ_TREBLE)
|
|
info->treble.gain = FEEDEQ_L2GAIN(value);
|
|
else
|
|
info->bass.gain = FEEDEQ_L2GAIN(value);
|
|
break;
|
|
case FEEDEQ_PREAMP:
|
|
if (value < FEEDEQ_PREAMP_MIN || value > FEEDEQ_PREAMP_MAX)
|
|
return (EINVAL);
|
|
info->preamp = FEEDEQ_PREAMP2IDX(value);
|
|
break;
|
|
case FEEDEQ_STATE:
|
|
if (!(value == FEEDEQ_BYPASS || value == FEEDEQ_ENABLE ||
|
|
value == FEEDEQ_DISABLE))
|
|
return (EINVAL);
|
|
info->state = value;
|
|
feed_eq_reset(info);
|
|
break;
|
|
default:
|
|
return (EINVAL);
|
|
break;
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
feed_eq_free(struct pcm_feeder *f)
|
|
{
|
|
struct feed_eq_info *info;
|
|
|
|
info = f->data;
|
|
if (info != NULL)
|
|
free(info, M_DEVBUF);
|
|
|
|
f->data = NULL;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
feed_eq_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
|
|
uint32_t count, void *source)
|
|
{
|
|
struct feed_eq_info *info;
|
|
uint32_t j;
|
|
uint8_t *dst;
|
|
|
|
info = f->data;
|
|
|
|
/*
|
|
* 3 major states:
|
|
* FEEDEQ_BYPASS - Bypass entirely, nothing happened.
|
|
* FEEDEQ_ENABLE - Preamp+biquad filtering.
|
|
* FEEDEQ_DISABLE - Preamp only.
|
|
*/
|
|
if (info->state == FEEDEQ_BYPASS)
|
|
return (FEEDER_FEED(f->source, c, b, count, source));
|
|
|
|
dst = b;
|
|
count = SND_FXROUND(count, info->align);
|
|
|
|
do {
|
|
if (count < info->align)
|
|
break;
|
|
|
|
j = SND_FXDIV(FEEDER_FEED(f->source, c, dst, count, source),
|
|
info->align);
|
|
if (j == 0)
|
|
break;
|
|
|
|
info->biquad(info, dst, j);
|
|
|
|
j *= info->align;
|
|
dst += j;
|
|
count -= j;
|
|
|
|
} while (count != 0);
|
|
|
|
return (dst - b);
|
|
}
|
|
|
|
static struct pcm_feederdesc feeder_eq_desc[] = {
|
|
{ FEEDER_EQ, 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
static kobj_method_t feeder_eq_methods[] = {
|
|
KOBJMETHOD(feeder_init, feed_eq_init),
|
|
KOBJMETHOD(feeder_free, feed_eq_free),
|
|
KOBJMETHOD(feeder_set, feed_eq_set),
|
|
KOBJMETHOD(feeder_feed, feed_eq_feed),
|
|
KOBJMETHOD_END
|
|
};
|
|
|
|
FEEDER_DECLARE(feeder_eq, NULL);
|
|
|
|
static int32_t
|
|
feed_eq_scan_preamp_arg(const char *s)
|
|
{
|
|
int r, i, f;
|
|
size_t len;
|
|
char buf[32];
|
|
|
|
bzero(buf, sizeof(buf));
|
|
|
|
/* XXX kind of ugly, but works for now.. */
|
|
|
|
r = sscanf(s, "%d.%d", &i, &f);
|
|
|
|
if (r == 1 && !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX)) {
|
|
snprintf(buf, sizeof(buf), "%c%d",
|
|
FEEDEQ_PREAMP_SIGNMARK(i), abs(i));
|
|
f = 0;
|
|
} else if (r == 2 &&
|
|
!(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX ||
|
|
f < FEEDEQ_PREAMP_FMIN || f > FEEDEQ_PREAMP_FMAX))
|
|
snprintf(buf, sizeof(buf), "%c%d.%d",
|
|
FEEDEQ_PREAMP_SIGNMARK(i), abs(i), f);
|
|
else
|
|
return (FEEDEQ_PREAMP_INVALID);
|
|
|
|
len = strlen(s);
|
|
if (len > 2 && strcasecmp(s + len - 2, "dB") == 0)
|
|
strlcat(buf, "dB", sizeof(buf));
|
|
|
|
if (i == 0 && *s == '-')
|
|
*buf = '-';
|
|
|
|
if (strcasecmp(buf + ((*s >= '0' && *s <= '9') ? 1 : 0), s) != 0)
|
|
return (FEEDEQ_PREAMP_INVALID);
|
|
|
|
while ((f / FEEDEQ_GAIN_DIV) > 0)
|
|
f /= FEEDEQ_GAIN_DIV;
|
|
|
|
return (((i < 0 || *buf == '-') ? -1 : 1) * FEEDEQ_IF2PREAMP(i, f));
|
|
}
|
|
|
|
#ifdef _KERNEL
|
|
static int
|
|
sysctl_dev_pcm_eq(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct snddev_info *d;
|
|
struct pcm_channel *c;
|
|
struct pcm_feeder *f;
|
|
int err, val, oval;
|
|
|
|
d = oidp->oid_arg1;
|
|
if (!PCM_REGISTERED(d))
|
|
return (ENODEV);
|
|
|
|
PCM_LOCK(d);
|
|
PCM_WAIT(d);
|
|
if (d->flags & SD_F_EQ_BYPASSED)
|
|
val = 2;
|
|
else if (d->flags & SD_F_EQ_ENABLED)
|
|
val = 1;
|
|
else
|
|
val = 0;
|
|
PCM_ACQUIRE(d);
|
|
PCM_UNLOCK(d);
|
|
|
|
oval = val;
|
|
err = sysctl_handle_int(oidp, &val, 0, req);
|
|
|
|
if (err == 0 && req->newptr != NULL && val != oval) {
|
|
if (!(val == 0 || val == 1 || val == 2)) {
|
|
PCM_RELEASE_QUICK(d);
|
|
return (EINVAL);
|
|
}
|
|
|
|
PCM_LOCK(d);
|
|
|
|
d->flags &= ~(SD_F_EQ_ENABLED | SD_F_EQ_BYPASSED);
|
|
if (val == 2) {
|
|
val = FEEDEQ_BYPASS;
|
|
d->flags |= SD_F_EQ_BYPASSED;
|
|
} else if (val == 1) {
|
|
val = FEEDEQ_ENABLE;
|
|
d->flags |= SD_F_EQ_ENABLED;
|
|
} else
|
|
val = FEEDEQ_DISABLE;
|
|
|
|
CHN_FOREACH(c, d, channels.pcm.busy) {
|
|
CHN_LOCK(c);
|
|
f = chn_findfeeder(c, FEEDER_EQ);
|
|
if (f != NULL)
|
|
(void)FEEDER_SET(f, FEEDEQ_STATE, val);
|
|
CHN_UNLOCK(c);
|
|
}
|
|
|
|
PCM_RELEASE(d);
|
|
PCM_UNLOCK(d);
|
|
} else
|
|
PCM_RELEASE_QUICK(d);
|
|
|
|
return (err);
|
|
}
|
|
|
|
static int
|
|
sysctl_dev_pcm_eq_preamp(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
struct snddev_info *d;
|
|
struct pcm_channel *c;
|
|
struct pcm_feeder *f;
|
|
int err, val, oval;
|
|
char buf[32];
|
|
|
|
d = oidp->oid_arg1;
|
|
if (!PCM_REGISTERED(d))
|
|
return (ENODEV);
|
|
|
|
PCM_LOCK(d);
|
|
PCM_WAIT(d);
|
|
val = d->eqpreamp;
|
|
bzero(buf, sizeof(buf));
|
|
(void)snprintf(buf, sizeof(buf), "%c%d.%ddB",
|
|
FEEDEQ_PREAMP_SIGNMARK(val), FEEDEQ_PREAMP_IPART(val),
|
|
FEEDEQ_PREAMP_FPART(val));
|
|
PCM_ACQUIRE(d);
|
|
PCM_UNLOCK(d);
|
|
|
|
oval = val;
|
|
err = sysctl_handle_string(oidp, buf, sizeof(buf), req);
|
|
|
|
if (err == 0 && req->newptr != NULL) {
|
|
val = feed_eq_scan_preamp_arg(buf);
|
|
if (val == FEEDEQ_PREAMP_INVALID) {
|
|
PCM_RELEASE_QUICK(d);
|
|
return (EINVAL);
|
|
}
|
|
|
|
PCM_LOCK(d);
|
|
|
|
if (val != oval) {
|
|
if (val < FEEDEQ_PREAMP_MIN)
|
|
val = FEEDEQ_PREAMP_MIN;
|
|
else if (val > FEEDEQ_PREAMP_MAX)
|
|
val = FEEDEQ_PREAMP_MAX;
|
|
|
|
d->eqpreamp = val;
|
|
|
|
CHN_FOREACH(c, d, channels.pcm.busy) {
|
|
CHN_LOCK(c);
|
|
f = chn_findfeeder(c, FEEDER_EQ);
|
|
if (f != NULL)
|
|
(void)FEEDER_SET(f, FEEDEQ_PREAMP, val);
|
|
CHN_UNLOCK(c);
|
|
}
|
|
|
|
}
|
|
|
|
PCM_RELEASE(d);
|
|
PCM_UNLOCK(d);
|
|
} else
|
|
PCM_RELEASE_QUICK(d);
|
|
|
|
return (err);
|
|
}
|
|
|
|
void
|
|
feeder_eq_initsys(device_t dev)
|
|
{
|
|
struct snddev_info *d;
|
|
const char *preamp;
|
|
char buf[64];
|
|
|
|
d = device_get_softc(dev);
|
|
|
|
if (!(resource_string_value(device_get_name(dev), device_get_unit(dev),
|
|
"eq_preamp", &preamp) == 0 &&
|
|
(d->eqpreamp = feed_eq_scan_preamp_arg(preamp)) !=
|
|
FEEDEQ_PREAMP_INVALID))
|
|
d->eqpreamp = FEEDEQ_PREAMP_DEFAULT;
|
|
|
|
if (d->eqpreamp < FEEDEQ_PREAMP_MIN)
|
|
d->eqpreamp = FEEDEQ_PREAMP_MIN;
|
|
else if (d->eqpreamp > FEEDEQ_PREAMP_MAX)
|
|
d->eqpreamp = FEEDEQ_PREAMP_MAX;
|
|
|
|
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
|
|
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
|
|
"eq", CTLTYPE_INT | CTLFLAG_RWTUN, d, sizeof(d),
|
|
sysctl_dev_pcm_eq, "I",
|
|
"Bass/Treble Equalizer (0=disable, 1=enable, 2=bypass)");
|
|
|
|
(void)snprintf(buf, sizeof(buf), "Bass/Treble Equalizer Preamp "
|
|
"(-/+ %d.0dB , %d.%ddB step)",
|
|
FEEDEQ_GAIN_MAX, FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV,
|
|
FEEDEQ_GAIN_STEP - ((FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV) *
|
|
FEEDEQ_GAIN_DIV));
|
|
|
|
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
|
|
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
|
|
"eq_preamp", CTLTYPE_STRING | CTLFLAG_RWTUN, d, sizeof(d),
|
|
sysctl_dev_pcm_eq_preamp, "A", buf);
|
|
}
|
|
#endif
|