[deliverable/linux.git] / drivers / isdn / mISDN / dsp_audio.c

/*
 * Audio support data for mISDN_dsp.
 *
 * Copyright 2002/2003 by Andreas Eversberg (jolly@eversberg.eu)
 * Rewritten by Peter
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

#include <linux/delay.h>
#include <linux/mISDNif.h>
#include <linux/mISDNdsp.h>
#include <linux/export.h>
#include "core.h"
#include "dsp.h"

/* ulaw[unsigned char] -> signed 16-bit */
s32 dsp_audio_ulaw_to_s32[256];
/* alaw[unsigned char] -> signed 16-bit */
s32 dsp_audio_alaw_to_s32[256];

s32 *dsp_audio_law_to_s32;
EXPORT_SYMBOL(dsp_audio_law_to_s32);

/* signed 16-bit -> law */
u8 dsp_audio_s16_to_law[65536];
EXPORT_SYMBOL(dsp_audio_s16_to_law);

/* alaw -> ulaw */
u8 dsp_audio_alaw_to_ulaw[256];
/* ulaw -> alaw */
static u8 dsp_audio_ulaw_to_alaw[256];
u8 dsp_silence;


/*****************************************************
 * generate table for conversion of s16 to alaw/ulaw *
 *****************************************************/

#define AMI_MASK 0x55

static inline unsigned char linear2alaw(short int linear)
{
	int mask;
	int seg;
	int pcm_val;
	static int seg_end[8] = {
		0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF
	};

	pcm_val = linear;
	if (pcm_val >= 0) {
		/* Sign (7th) bit = 1 */
		mask = AMI_MASK | 0x80;
	} else {
		/* Sign bit = 0 */
		mask = AMI_MASK;
		pcm_val = -pcm_val;
	}

	/* Convert the scaled magnitude to segment number. */
	for (seg = 0; seg < 8; seg++) {
		if (pcm_val <= seg_end[seg])
			break;
	}
	/* Combine the sign, segment, and quantization bits. */
	return  ((seg << 4) |
		 ((pcm_val >> ((seg)  ?  (seg + 3)  :  4)) & 0x0F)) ^ mask;
}


static inline short int alaw2linear(unsigned char alaw)
{
	int i;
	int seg;

	alaw ^= AMI_MASK;
	i = ((alaw & 0x0F) << 4) + 8 /* rounding error */;
	seg = (((int) alaw & 0x70) >> 4);
	if (seg)
		i = (i + 0x100) << (seg - 1);
	return (short int) ((alaw & 0x80)  ?  i  :  -i);
}

static inline short int ulaw2linear(unsigned char ulaw)
{
	short mu, e, f, y;
	static short etab[] = {0, 132, 396, 924, 1980, 4092, 8316, 16764};

	mu = 255 - ulaw;
	e = (mu & 0x70) / 16;
	f = mu & 0x0f;
	y = f * (1 << (e + 3));
	y += etab[e];
	if (mu & 0x80)
		y = -y;
	return y;
}

#define BIAS 0x84   /*!< define the add-in bias for 16 bit samples */

static unsigned char linear2ulaw(short sample)
{
	static int exp_lut[256] = {
		0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
		4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
	int sign, exponent, mantissa;
	unsigned char ulawbyte;

	/* Get the sample into sign-magnitude. */
	sign = (sample >> 8) & 0x80;	  /* set aside the sign */
	if (sign != 0)
		sample = -sample;	      /* get magnitude */

	/* Convert from 16 bit linear to ulaw. */
	sample = sample + BIAS;
	exponent = exp_lut[(sample >> 7) & 0xFF];
	mantissa = (sample >> (exponent + 3)) & 0x0F;
	ulawbyte = ~(sign | (exponent << 4) | mantissa);

	return ulawbyte;
}

static int reverse_bits(int i)
{
	int z, j;
	z = 0;

	for (j = 0; j < 8; j++) {
		if ((i & (1 << j)) != 0)
			z |= 1 << (7 - j);
	}
	return z;
}


void dsp_audio_generate_law_tables(void)
{
	int i;
	for (i = 0; i < 256; i++)
		dsp_audio_alaw_to_s32[i] = alaw2linear(reverse_bits(i));

	for (i = 0; i < 256; i++)
		dsp_audio_ulaw_to_s32[i] = ulaw2linear(reverse_bits(i));

	for (i = 0; i < 256; i++) {
		dsp_audio_alaw_to_ulaw[i] =
			linear2ulaw(dsp_audio_alaw_to_s32[i]);
		dsp_audio_ulaw_to_alaw[i] =
			linear2alaw(dsp_audio_ulaw_to_s32[i]);
	}
}

void
dsp_audio_generate_s2law_table(void)
{
	int i;

	if (dsp_options & DSP_OPT_ULAW) {
		/* generating ulaw-table */
		for (i = -32768; i < 32768; i++) {
			dsp_audio_s16_to_law[i & 0xffff] =
				reverse_bits(linear2ulaw(i));
		}
	} else {
		/* generating alaw-table */
		for (i = -32768; i < 32768; i++) {
			dsp_audio_s16_to_law[i & 0xffff] =
				reverse_bits(linear2alaw(i));
		}
	}
}


/*
 * the seven bit sample is the number of every second alaw-sample ordered by
 * aplitude. 0x00 is negative, 0x7f is positive amplitude.
 */
u8 dsp_audio_seven2law[128];
u8 dsp_audio_law2seven[256];

/********************************************************************
 * generate table for conversion law from/to 7-bit alaw-like sample *
 ********************************************************************/

void
dsp_audio_generate_seven(void)
{
	int i, j, k;
	u8 spl;
	u8 sorted_alaw[256];

	/* generate alaw table, sorted by the linear value */
	for (i = 0; i < 256; i++) {
		j = 0;
		for (k = 0; k < 256; k++) {
			if (dsp_audio_alaw_to_s32[k]
			    < dsp_audio_alaw_to_s32[i])
				j++;
		}
		sorted_alaw[j] = i;
	}

	/* generate tabels */
	for (i = 0; i < 256; i++) {
		/* spl is the source: the law-sample (converted to alaw) */
		spl = i;
		if (dsp_options & DSP_OPT_ULAW)
			spl = dsp_audio_ulaw_to_alaw[i];
		/* find the 7-bit-sample */
		for (j = 0; j < 256; j++) {
			if (sorted_alaw[j] == spl)
				break;
		}
		/* write 7-bit audio value */
		dsp_audio_law2seven[i] = j >> 1;
	}
	for (i = 0; i < 128; i++) {
		spl = sorted_alaw[i << 1];
		if (dsp_options & DSP_OPT_ULAW)
			spl = dsp_audio_alaw_to_ulaw[spl];
		dsp_audio_seven2law[i] = spl;
	}
}


/* mix 2*law -> law */
u8 dsp_audio_mix_law[65536];

/******************************************************
 * generate mix table to mix two law samples into one *
 ******************************************************/

void
dsp_audio_generate_mix_table(void)
{
	int i, j;
	s32 sample;

	i = 0;
	while (i < 256) {
		j = 0;
		while (j < 256) {
			sample = dsp_audio_law_to_s32[i];
			sample += dsp_audio_law_to_s32[j];
			if (sample > 32767)
				sample = 32767;
			if (sample < -32768)
				sample = -32768;
			dsp_audio_mix_law[(i << 8) | j] =
				dsp_audio_s16_to_law[sample & 0xffff];
			j++;
		}
		i++;
	}
}


/*************************************
 * generate different volume changes *
 *************************************/

static u8 dsp_audio_reduce8[256];
static u8 dsp_audio_reduce7[256];
static u8 dsp_audio_reduce6[256];
static u8 dsp_audio_reduce5[256];
static u8 dsp_audio_reduce4[256];
static u8 dsp_audio_reduce3[256];
static u8 dsp_audio_reduce2[256];
static u8 dsp_audio_reduce1[256];
static u8 dsp_audio_increase1[256];
static u8 dsp_audio_increase2[256];
static u8 dsp_audio_increase3[256];
static u8 dsp_audio_increase4[256];
static u8 dsp_audio_increase5[256];
static u8 dsp_audio_increase6[256];
static u8 dsp_audio_increase7[256];
static u8 dsp_audio_increase8[256];

static u8 *dsp_audio_volume_change[16] = {
	dsp_audio_reduce8,
	dsp_audio_reduce7,
	dsp_audio_reduce6,
	dsp_audio_reduce5,
	dsp_audio_reduce4,
	dsp_audio_reduce3,
	dsp_audio_reduce2,
	dsp_audio_reduce1,
	dsp_audio_increase1,
	dsp_audio_increase2,
	dsp_audio_increase3,
	dsp_audio_increase4,
	dsp_audio_increase5,
	dsp_audio_increase6,
	dsp_audio_increase7,
	dsp_audio_increase8,
};

void
dsp_audio_generate_volume_changes(void)
{
	register s32 sample;
	int i;
	int num[]   = { 110, 125, 150, 175, 200, 300, 400, 500 };
	int denum[] = { 100, 100, 100, 100, 100, 100, 100, 100 };

	i = 0;
	while (i < 256) {
		dsp_audio_reduce8[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[7] / num[7]) & 0xffff];
		dsp_audio_reduce7[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[6] / num[6]) & 0xffff];
		dsp_audio_reduce6[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[5] / num[5]) & 0xffff];
		dsp_audio_reduce5[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[4] / num[4]) & 0xffff];
		dsp_audio_reduce4[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[3] / num[3]) & 0xffff];
		dsp_audio_reduce3[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[2] / num[2]) & 0xffff];
		dsp_audio_reduce2[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[1] / num[1]) & 0xffff];
		dsp_audio_reduce1[i] = dsp_audio_s16_to_law[
			(dsp_audio_law_to_s32[i] * denum[0] / num[0]) & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[0] / denum[0];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase1[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[1] / denum[1];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase2[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[2] / denum[2];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase3[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[3] / denum[3];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase4[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[4] / denum[4];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase5[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[5] / denum[5];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase6[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[6] / denum[6];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase7[i] = dsp_audio_s16_to_law[sample & 0xffff];
		sample = dsp_audio_law_to_s32[i] * num[7] / denum[7];
		if (sample < -32768)
			sample = -32768;
		else if (sample > 32767)
			sample = 32767;
		dsp_audio_increase8[i] = dsp_audio_s16_to_law[sample & 0xffff];

		i++;
	}
}


/**************************************
 * change the volume of the given skb *
 **************************************/

/* this is a helper function for changing volume of skb. the range may be
 * -8 to 8, which is a shift to the power of 2. 0 == no volume, 3 == volume*8
 */
void
dsp_change_volume(struct sk_buff *skb, int volume)
{
	u8 *volume_change;
	int i, ii;
	u8 *p;
	int shift;

	if (volume == 0)
		return;

	/* get correct conversion table */
	if (volume < 0) {
		shift = volume + 8;
		if (shift < 0)
			shift = 0;
	} else {
		shift = volume + 7;
		if (shift > 15)
			shift = 15;
	}
	volume_change = dsp_audio_volume_change[shift];
	i = 0;
	ii = skb->len;
	p = skb->data;
	/* change volume */
	while (i < ii) {
		*p = volume_change[*p];
		p++;
		i++;
	}
}
Commit	Line	Data
960366cf KK	1	/*
	2	* Audio support data for mISDN_dsp.
	3	*
	4	* Copyright 2002/2003 by Andreas Eversberg (jolly@eversberg.eu)
	5	* Rewritten by Peter
	6	*
	7	* This software may be used and distributed according to the terms
	8	* of the GNU General Public License, incorporated herein by reference.
	9	*
	10	*/
	11
	12	#include <linux/delay.h>
	13	#include <linux/mISDNif.h>
	14	#include <linux/mISDNdsp.h>
5d76fc21	15	#include <linux/export.h>
960366cf KK	16	#include "core.h"
	17	#include "dsp.h"
	18
	19	/* ulaw[unsigned char] -> signed 16-bit */
	20	s32 dsp_audio_ulaw_to_s32[256];
	21	/* alaw[unsigned char] -> signed 16-bit */
	22	s32 dsp_audio_alaw_to_s32[256];
	23
	24	s32 *dsp_audio_law_to_s32;
	25	EXPORT_SYMBOL(dsp_audio_law_to_s32);
	26
	27	/* signed 16-bit -> law */
	28	u8 dsp_audio_s16_to_law[65536];
	29	EXPORT_SYMBOL(dsp_audio_s16_to_law);
	30
	31	/* alaw -> ulaw */
	32	u8 dsp_audio_alaw_to_ulaw[256];
	33	/* ulaw -> alaw */
5b834354	34	static u8 dsp_audio_ulaw_to_alaw[256];
960366cf KK	35	u8 dsp_silence;
	36
	37
	38	/*****************************************************
	39	* generate table for conversion of s16 to alaw/ulaw *
	40	*****************************************************/
	41
	42	#define AMI_MASK 0x55
	43
	44	static inline unsigned char linear2alaw(short int linear)
	45	{
	46	int mask;
	47	int seg;
	48	int pcm_val;
	49	static int seg_end[8] = {
	50	0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF
	51	};
	52
	53	pcm_val = linear;
	54	if (pcm_val >= 0) {
	55	/* Sign (7th) bit = 1 */
	56	mask = AMI_MASK \| 0x80;
	57	} else {
	58	/* Sign bit = 0 */
	59	mask = AMI_MASK;
	60	pcm_val = -pcm_val;
	61	}
	62
	63	/* Convert the scaled magnitude to segment number. */
475be4d8	64	for (seg = 0; seg < 8; seg++) {
960366cf KK	65	if (pcm_val <= seg_end[seg])
	66	break;
	67	}
	68	/* Combine the sign, segment, and quantization bits. */
	69	return ((seg << 4) \|
	70	((pcm_val >> ((seg) ? (seg + 3) : 4)) & 0x0F)) ^ mask;
	71	}
	72
	73
	74	static inline short int alaw2linear(unsigned char alaw)
	75	{
	76	int i;
	77	int seg;
	78
	79	alaw ^= AMI_MASK;
	80	i = ((alaw & 0x0F) << 4) + 8 /* rounding error */;
	81	seg = (((int) alaw & 0x70) >> 4);
	82	if (seg)
	83	i = (i + 0x100) << (seg - 1);
	84	return (short int) ((alaw & 0x80) ? i : -i);
	85	}
	86
	87	static inline short int ulaw2linear(unsigned char ulaw)
	88	{
	89	short mu, e, f, y;
	90	static short etab[] = {0, 132, 396, 924, 1980, 4092, 8316, 16764};
	91
	92	mu = 255 - ulaw;
	93	e = (mu & 0x70) / 16;
	94	f = mu & 0x0f;
	95	y = f * (1 << (e + 3));
	96	y += etab[e];
	97	if (mu & 0x80)
	98	y = -y;
	99	return y;
	100	}
	101
	102	#define BIAS 0x84 /!< define the add-in bias for 16 bit samples /
	103
	104	static unsigned char linear2ulaw(short sample)
	105	{
	106	static int exp_lut[256] = {
	107	0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
	108	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
	109	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
	110	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
	111	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
	112	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
	113	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
	114	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
	115	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	116	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	117	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	118	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	119	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	120	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	121	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	122	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
	123	int sign, exponent, mantissa;
	124	unsigned char ulawbyte;
	125
	126	/* Get the sample into sign-magnitude. */
	127	sign = (sample >> 8) & 0x80; /* set aside the sign */
	128	if (sign != 0)
129	sample = -sample; /* get magnitude */
130
131	/* Convert from 16 bit linear to ulaw. */
132	sample = sample + BIAS;
133	exponent = exp_lut[(sample >> 7) & 0xFF];
134	mantissa = (sample >> (exponent + 3)) & 0x0F;
135	ulawbyte = ~(sign \| (exponent << 4) \| mantissa);
136
137	return ulawbyte;
138	}
139
140	static int reverse_bits(int i)
141	{
142	int z, j;
143	z = 0;
144
145	for (j = 0; j < 8; j++) {
146	if ((i & (1 << j)) != 0)
147	z \|= 1 << (7 - j);
148	}
149	return z;
150	}
151
152
153	void dsp_audio_generate_law_tables(void)
154	{
155	int i;
156	for (i = 0; i < 256; i++)
157	dsp_audio_alaw_to_s32[i] = alaw2linear(reverse_bits(i));
158
159	for (i = 0; i < 256; i++)
160	dsp_audio_ulaw_to_s32[i] = ulaw2linear(reverse_bits(i));
161
162	for (i = 0; i < 256; i++) {
163	dsp_audio_alaw_to_ulaw[i] =
164	linear2ulaw(dsp_audio_alaw_to_s32[i]);
165	dsp_audio_ulaw_to_alaw[i] =
166	linear2alaw(dsp_audio_ulaw_to_s32[i]);
167	}
168	}
169
170	void
171	dsp_audio_generate_s2law_table(void)
172	{
173	int i;
174
175	if (dsp_options & DSP_OPT_ULAW) {
176	/* generating ulaw-table */
177	for (i = -32768; i < 32768; i++) {
178	dsp_audio_s16_to_law[i & 0xffff] =
179	reverse_bits(linear2ulaw(i));
180	}
181	} else {
182	/* generating alaw-table */
183	for (i = -32768; i < 32768; i++) {
184	dsp_audio_s16_to_law[i & 0xffff] =
185	reverse_bits(linear2alaw(i));
186	}
187	}
188	}
189
190
191	/*
192	* the seven bit sample is the number of every second alaw-sample ordered by
193	* aplitude. 0x00 is negative, 0x7f is positive amplitude.
194	*/
195	u8 dsp_audio_seven2law[128];
196	u8 dsp_audio_law2seven[256];
197
198	/********************************************************************
199	* generate table for conversion law from/to 7-bit alaw-like sample *
200	********************************************************************/
201
202	void
203	dsp_audio_generate_seven(void)
204	{
205	int i, j, k;
206	u8 spl;
207	u8 sorted_alaw[256];
208
209	/* generate alaw table, sorted by the linear value */
210	for (i = 0; i < 256; i++) {
211	j = 0;
212	for (k = 0; k < 256; k++) {
213	if (dsp_audio_alaw_to_s32[k]
eac74af9 KK	214	< dsp_audio_alaw_to_s32[i])
eac74af9 KK	215	j++;
960366cf KK	216	}
	217	sorted_alaw[j] = i;
	218	}
	219
	220	/* generate tabels */
	221	for (i = 0; i < 256; i++) {
	222	/* spl is the source: the law-sample (converted to alaw) */
	223	spl = i;
	224	if (dsp_options & DSP_OPT_ULAW)
	225	spl = dsp_audio_ulaw_to_alaw[i];
	226	/* find the 7-bit-sample */
	227	for (j = 0; j < 256; j++) {
	228	if (sorted_alaw[j] == spl)
	229	break;
	230	}
	231	/* write 7-bit audio value */
	232	dsp_audio_law2seven[i] = j >> 1;
	233	}
	234	for (i = 0; i < 128; i++) {
	235	spl = sorted_alaw[i << 1];
	236	if (dsp_options & DSP_OPT_ULAW)
	237	spl = dsp_audio_alaw_to_ulaw[spl];
	238	dsp_audio_seven2law[i] = spl;
	239	}
	240	}
	241
	242
	243	/* mix 2law -> law /
	244	u8 dsp_audio_mix_law[65536];
	245
	246	/******************************************************
	247	* generate mix table to mix two law samples into one *
	248	******************************************************/
	249
	250	void
	251	dsp_audio_generate_mix_table(void)
	252	{
	253	int i, j;
	254	s32 sample;
	255
	256	i = 0;
	257	while (i < 256) {
	258	j = 0;
	259	while (j < 256) {
	260	sample = dsp_audio_law_to_s32[i];
	261	sample += dsp_audio_law_to_s32[j];
	262	if (sample > 32767)
	263	sample = 32767;
	264	if (sample < -32768)
	265	sample = -32768;
475be4d8	266	dsp_audio_mix_law[(i << 8) \| j] =
960366cf KK	267	dsp_audio_s16_to_law[sample & 0xffff];
	268	j++;
	269	}
	270	i++;
	271	}
	272	}
	273
	274
	275	/*************************************
	276	* generate different volume changes *
	277	*************************************/
	278
	279	static u8 dsp_audio_reduce8[256];
	280	static u8 dsp_audio_reduce7[256];
	281	static u8 dsp_audio_reduce6[256];
	282	static u8 dsp_audio_reduce5[256];
	283	static u8 dsp_audio_reduce4[256];
	284	static u8 dsp_audio_reduce3[256];
	285	static u8 dsp_audio_reduce2[256];
	286	static u8 dsp_audio_reduce1[256];
	287	static u8 dsp_audio_increase1[256];
	288	static u8 dsp_audio_increase2[256];
	289	static u8 dsp_audio_increase3[256];
	290	static u8 dsp_audio_increase4[256];
	291	static u8 dsp_audio_increase5[256];
	292	static u8 dsp_audio_increase6[256];
	293	static u8 dsp_audio_increase7[256];
	294	static u8 dsp_audio_increase8[256];
	295
	296	static u8 *dsp_audio_volume_change[16] = {
	297	dsp_audio_reduce8,
	298	dsp_audio_reduce7,
	299	dsp_audio_reduce6,
	300	dsp_audio_reduce5,
	301	dsp_audio_reduce4,
	302	dsp_audio_reduce3,
	303	dsp_audio_reduce2,
	304	dsp_audio_reduce1,
	305	dsp_audio_increase1,
	306	dsp_audio_increase2,
	307	dsp_audio_increase3,
	308	dsp_audio_increase4,
	309	dsp_audio_increase5,
	310	dsp_audio_increase6,
	311	dsp_audio_increase7,
	312	dsp_audio_increase8,
	313	};
	314
	315	void
	316	dsp_audio_generate_volume_changes(void)
	317	{
	318	register s32 sample;
	319	int i;
	320	int num[] = { 110, 125, 150, 175, 200, 300, 400, 500 };
	321	int denum[] = { 100, 100, 100, 100, 100, 100, 100, 100 };
	322
	323	i = 0;
	324	while (i < 256) {
	325	dsp_audio_reduce8[i] = dsp_audio_s16_to_law[
	326	(dsp_audio_law_to_s32[i] * denum[7] / num[7]) & 0xffff];
	327	dsp_audio_reduce7[i] = dsp_audio_s16_to_law[
	328	(dsp_audio_law_to_s32[i] * denum[6] / num[6]) & 0xffff];
	329	dsp_audio_reduce6[i] = dsp_audio_s16_to_law[
	330	(dsp_audio_law_to_s32[i] * denum[5] / num[5]) & 0xffff];
331	dsp_audio_reduce5[i] = dsp_audio_s16_to_law[
332	(dsp_audio_law_to_s32[i] * denum[4] / num[4]) & 0xffff];
333	dsp_audio_reduce4[i] = dsp_audio_s16_to_law[
334	(dsp_audio_law_to_s32[i] * denum[3] / num[3]) & 0xffff];
335	dsp_audio_reduce3[i] = dsp_audio_s16_to_law[
336	(dsp_audio_law_to_s32[i] * denum[2] / num[2]) & 0xffff];
337	dsp_audio_reduce2[i] = dsp_audio_s16_to_law[
338	(dsp_audio_law_to_s32[i] * denum[1] / num[1]) & 0xffff];
339	dsp_audio_reduce1[i] = dsp_audio_s16_to_law[
340	(dsp_audio_law_to_s32[i] * denum[0] / num[0]) & 0xffff];
341	sample = dsp_audio_law_to_s32[i] * num[0] / denum[0];
342	if (sample < -32768)
343	sample = -32768;
344	else if (sample > 32767)
345	sample = 32767;
346	dsp_audio_increase1[i] = dsp_audio_s16_to_law[sample & 0xffff];
347	sample = dsp_audio_law_to_s32[i] * num[1] / denum[1];
348	if (sample < -32768)
349	sample = -32768;
350	else if (sample > 32767)
351	sample = 32767;
352	dsp_audio_increase2[i] = dsp_audio_s16_to_law[sample & 0xffff];
353	sample = dsp_audio_law_to_s32[i] * num[2] / denum[2];
354	if (sample < -32768)
355	sample = -32768;
356	else if (sample > 32767)
357	sample = 32767;
358	dsp_audio_increase3[i] = dsp_audio_s16_to_law[sample & 0xffff];
359	sample = dsp_audio_law_to_s32[i] * num[3] / denum[3];
360	if (sample < -32768)
361	sample = -32768;
362	else if (sample > 32767)
363	sample = 32767;
364	dsp_audio_increase4[i] = dsp_audio_s16_to_law[sample & 0xffff];
365	sample = dsp_audio_law_to_s32[i] * num[4] / denum[4];
366	if (sample < -32768)
367	sample = -32768;
368	else if (sample > 32767)
369	sample = 32767;
370	dsp_audio_increase5[i] = dsp_audio_s16_to_law[sample & 0xffff];
371	sample = dsp_audio_law_to_s32[i] * num[5] / denum[5];
372	if (sample < -32768)
373	sample = -32768;
374	else if (sample > 32767)
375	sample = 32767;
376	dsp_audio_increase6[i] = dsp_audio_s16_to_law[sample & 0xffff];
377	sample = dsp_audio_law_to_s32[i] * num[6] / denum[6];
378	if (sample < -32768)
379	sample = -32768;
380	else if (sample > 32767)
381	sample = 32767;
382	dsp_audio_increase7[i] = dsp_audio_s16_to_law[sample & 0xffff];
383	sample = dsp_audio_law_to_s32[i] * num[7] / denum[7];
384	if (sample < -32768)
385	sample = -32768;
386	else if (sample > 32767)
387	sample = 32767;
388	dsp_audio_increase8[i] = dsp_audio_s16_to_law[sample & 0xffff];
389
390	i++;
391	}
392	}
393
394
395	/**************************************
396	* change the volume of the given skb *
397	**************************************/
398
399	/* this is a helper function for changing volume of skb. the range may be
400	* -8 to 8, which is a shift to the power of 2. 0 == no volume, 3 == volume*8
401	*/
402	void
403	dsp_change_volume(struct sk_buff *skb, int volume)
404	{
405	u8 *volume_change;
406	int i, ii;
407	u8 *p;
408	int shift;
409
410	if (volume == 0)
411	return;
412
413	/* get correct conversion table */
414	if (volume < 0) {
415	shift = volume + 8;
416	if (shift < 0)
417	shift = 0;
418	} else {
419	shift = volume + 7;
420	if (shift > 15)
421	shift = 15;
422	}
423	volume_change = dsp_audio_volume_change[shift];
424	i = 0;
425	ii = skb->len;
426	p = skb->data;
427	/* change volume */
428	while (i < ii) {
429	p = volume_change[p];
430	p++;
431	i++;
432	}
433	}