/* $NetBSD: mulaw.c,v 1.5 2021/07/21 06:35:44 skrll Exp $ */
/*
* Copyright (C) 2017 Tetsuya Isaki. All rights reserved.
* Copyright (C) 2017 Y.Sugahara (moveccr). 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 ``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 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.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: mulaw.c,v 1.5 2021/07/21 06:35:44 skrll Exp $");
#include <sys/param.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <dev/audio/audiovar.h>
#include <dev/audio/mulaw.h>
/*
* audio_internal_to_mulaw has two implementations.
*
* 1. Use 8bit table (MULAW_LQ_ENC)
* It's traditional implementation and its precision is 8bit.
* It's faster but the size is larger. And you can hear a little noise
* in silent part.
*
* 2. Calculation (default)
* It calculates mu-law with full spec and its precision is 14bit.
* It's about 3 times slower but the size is less than a half (on m68k,
* for example).
*
* mu-law is no longer a popular format. I think size-optimized is better.
*/
/* #define MULAW_LQ_ENC */
/*
* About mulaw32 format.
*
* The format which I call ``mulaw32'' is only used in dev/tc/bba.c .
* It is 8bit mu-law but 16bit left-shifted and its containter is 32bit.
* Not mu-law calculated in 32bit.
*
* When MULAW32 is not defined (it's default), this file outputs
* audio_internal_to_mulaw() and audio_mulaw_to_internal(). When
* MULAW32 is defined, this file outputs audio_internal_to_mulaw32()
* and audio_mulaw32_to_internal() instead.
*
* Since mu-law is used as userland format and is mandatory, all audio
* drivers (including tc/bba) link this mulaw.c in ordinary procedure.
* On the other hand, only tc/bba also needs audio_internal_to_mulaw32()
* and audio_mulaw32_to_internal() as its hardware drivers codec, so
* define MULAW32 and include this file. It's a bit tricky but I think
* this is the simplest way.
*/
#if 0
#define MPRINTF(fmt, ...) printf(fmt, ## __VA_ARGS__)
#else
#define MPRINTF(fmt, ...) /**/
#endif
static const int16_t mulaw_to_slinear16[256] = {
0x8284, 0x8684, 0x8a84, 0x8e84, 0x9284, 0x9684, 0x9a84, 0x9e84,
0xa284, 0xa684, 0xaa84, 0xae84, 0xb284, 0xb684, 0xba84, 0xbe84,
0xc184, 0xc384, 0xc584, 0xc784, 0xc984, 0xcb84, 0xcd84, 0xcf84,
0xd184, 0xd384, 0xd584, 0xd784, 0xd984, 0xdb84, 0xdd84, 0xdf84,
0xe104, 0xe204, 0xe304, 0xe404, 0xe504, 0xe604, 0xe704, 0xe804,
0xe904, 0xea04, 0xeb04, 0xec04, 0xed04, 0xee04, 0xef04, 0xf004,
0xf0c4, 0xf144, 0xf1c4, 0xf244, 0xf2c4, 0xf344, 0xf3c4, 0xf444,
0xf4c4, 0xf544, 0xf5c4, 0xf644, 0xf6c4, 0xf744, 0xf7c4, 0xf844,
0xf8a4, 0xf8e4, 0xf924, 0xf964, 0xf9a4, 0xf9e4, 0xfa24, 0xfa64,
0xfaa4, 0xfae4, 0xfb24, 0xfb64, 0xfba4, 0xfbe4, 0xfc24, 0xfc64,
0xfc94, 0xfcb4, 0xfcd4, 0xfcf4, 0xfd14, 0xfd34, 0xfd54, 0xfd74,
0xfd94, 0xfdb4, 0xfdd4, 0xfdf4, 0xfe14, 0xfe34, 0xfe54, 0xfe74,
0xfe8c, 0xfe9c, 0xfeac, 0xfebc, 0xfecc, 0xfedc, 0xfeec, 0xfefc,
0xff0c, 0xff1c, 0xff2c, 0xff3c, 0xff4c, 0xff5c, 0xff6c, 0xff7c,
0xff88, 0xff90, 0xff98, 0xffa0, 0xffa8, 0xffb0, 0xffb8, 0xffc0,
0xffc8, 0xffd0, 0xffd8, 0xffe0, 0xffe8, 0xfff0, 0xfff8, 0xfffc,
0x7d7c, 0x797c, 0x757c, 0x717c, 0x6d7c, 0x697c, 0x657c, 0x617c,
0x5d7c, 0x597c, 0x557c, 0x517c, 0x4d7c, 0x497c, 0x457c, 0x417c,
0x3e7c, 0x3c7c, 0x3a7c, 0x387c, 0x367c, 0x347c, 0x327c, 0x307c,
0x2e7c, 0x2c7c, 0x2a7c, 0x287c, 0x267c, 0x247c, 0x227c, 0x207c,
0x1efc, 0x1dfc, 0x1cfc, 0x1bfc, 0x1afc, 0x19fc, 0x18fc, 0x17fc,
0x16fc, 0x15fc, 0x14fc, 0x13fc, 0x12fc, 0x11fc, 0x10fc, 0x0ffc,
0x0f3c, 0x0ebc, 0x0e3c, 0x0dbc, 0x0d3c, 0x0cbc, 0x0c3c, 0x0bbc,
0x0b3c, 0x0abc, 0x0a3c, 0x09bc, 0x093c, 0x08bc, 0x083c, 0x07bc,
0x075c, 0x071c, 0x06dc, 0x069c, 0x065c, 0x061c, 0x05dc, 0x059c,
0x055c, 0x051c, 0x04dc, 0x049c, 0x045c, 0x041c, 0x03dc, 0x039c,
0x036c, 0x034c, 0x032c, 0x030c, 0x02ec, 0x02cc, 0x02ac, 0x028c,
0x026c, 0x024c, 0x022c, 0x020c, 0x01ec, 0x01cc, 0x01ac, 0x018c,
0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104,
0x00f4, 0x00e4, 0x00d4, 0x00c4, 0x00b4, 0x00a4, 0x0094, 0x0084,
0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040,
0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000,
};
#if defined(MULAW_LQ_ENC)
static const uint8_t slinear8_to_mulaw[256] = {
0xff, 0xe7, 0xdb, 0xd3, 0xcd, 0xc9, 0xc5, 0xc1,
0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, 0xb2, 0xb0,
0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
0x9f, 0x9f, 0x9e, 0x9e, 0x9d, 0x9d, 0x9c, 0x9c,
0x9b, 0x9b, 0x9a, 0x9a, 0x99, 0x99, 0x98, 0x98,
0x97, 0x97, 0x96, 0x96, 0x95, 0x95, 0x94, 0x94,
0x93, 0x93, 0x92, 0x92, 0x91, 0x91, 0x90, 0x90,
0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e,
0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c,
0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a,
0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88,
0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86,
0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84,
0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,
0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05,
0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07,
0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b,
0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d,
0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f,
0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13,
0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17,
0x17, 0x18, 0x18, 0x19, 0x19, 0x1a, 0x1a, 0x1b,
0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f,
0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
0x2f, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c,
0x3e, 0x41, 0x45, 0x49, 0x4d, 0x53, 0x5b, 0x67,
};
#endif
/*
* audio_mulaw_to_internal:
* This filter performs conversion from mu-law to internal format.
*
* audio_mulaw32_to_internal:
* This filter performs conversion from mulaw32 used only in tc/bba.c
* to internal format.
*/
void
#if !defined(MULAW32)
audio_mulaw_to_internal(audio_filter_arg_t *arg)
#else
audio_mulaw32_to_internal(audio_filter_arg_t *arg)
#endif
{
#if defined(MULAW32)
const uint32_t *s;
#else
const uint8_t *s;
#endif
aint_t *d;
u_int sample_count;
u_int i;
DIAGNOSTIC_filter_arg(arg);
#if !defined(MULAW32)
KASSERT(arg->srcfmt->encoding == AUDIO_ENCODING_ULAW);
KASSERT(arg->srcfmt->stride == 8);
KASSERT(arg->srcfmt->precision == 8);
#endif
KASSERT(audio_format2_is_internal(arg->dstfmt));
KASSERT(arg->srcfmt->channels == arg->dstfmt->channels);
s = arg->src;
d = arg->dst;
sample_count = arg->count * arg->srcfmt->channels;
for (i = 0; i < sample_count; i++) {
aint_t val;
uint m;
m = *s++;
#if defined(MULAW32)
/* 32bit container used only in tc/bba.c */
m = (m >> 16) & 0xff;
#endif
val = mulaw_to_slinear16[m];
val <<= AUDIO_INTERNAL_BITS - 16;
*d++ = val;
}
}
/*
* audio_internal_to_mulaw:
* This filter performs conversion from internal format to mu-law.
*
* audio_internal_to_mulaw32:
* This filter performs conversion from internal format to mulaw32
* used only in tc/bba.c.
*/
void
#if !defined(MULAW32)
audio_internal_to_mulaw(audio_filter_arg_t *arg)
#else
audio_internal_to_mulaw32(audio_filter_arg_t *arg)
#endif
{
const aint_t *s;
#if defined(MULAW32)
uint32_t *d;
#else
uint8_t *d;
#endif
u_int sample_count;
u_int i;
DIAGNOSTIC_filter_arg(arg);
#if !defined(MULAW32)
KASSERT(arg->dstfmt->encoding == AUDIO_ENCODING_ULAW);
KASSERT(arg->dstfmt->stride == 8);
KASSERT(arg->dstfmt->precision == 8);
#endif
KASSERT(audio_format2_is_internal(arg->srcfmt));
KASSERT(arg->srcfmt->channels == arg->dstfmt->channels);
s = arg->src;
d = arg->dst;
sample_count = arg->count * arg->srcfmt->channels;
for (i = 0; i < sample_count; i++) {
uint8_t m;
#if defined(MULAW_LQ_ENC)
/* 8bit (low quality, fast but fat) encoder */
uint8_t val;
val = (*s++) >> (AUDIO_INTERNAL_BITS - 8);
m = slinear8_to_mulaw[val];
#else
/* 14bit (fullspec, slow but small) encoder */
uint16_t val;
int c;
val = *s++ >> (AUDIO_INTERNAL_BITS - 16);
if ((int16_t)val < 0) {
m = 0;
} else {
val = ~val;
m = 0x80;
}
/* limit */
if ((int16_t)val < -8158 * 4)
val = -8158 * 4;
val -= 33 * 4; /* bias */
// Before(1) Before(2) Before(3)
// S0MMMMxx_xxxxxxxx 0MMMMxxx_xxxxxxx0 c=0,v=0MMMMxxx_xxxxxxx0
// S10MMMMx_xxxxxxxx 10MMMMxx_xxxxxxx0 c=1,v=0MMMMxxx_xxxxxx00
// S110MMMM_xxxxxxxx 110MMMMx_xxxxxxx0 c=2,v=0MMMMxxx_xxxxx000
// : : :
// S1111110_MMMMxxxx 1111110M_MMMxxxx0 c=6,v=0MMMMxxx_x0000000
// (1) Push out sign bit
val <<= 1;
// (2) Find first zero (and align val to left)
c = 0;
if (val >= 0xf000) c += 4, val <<= 4;
if (val >= 0xc000) c += 2, val <<= 2;
if (val >= 0x8000) c += 1, val <<= 1;
// (3)
m += (c << 4);
m += (val >> 11) & 0x0f;
#endif
#if defined(MULAW32)
/* 8bit mu-law in 32bit container used only in tc/bba.c */
*d++ = m << 16;
#else
*d++ = m;
#endif
}
}