[linux.git] / sound / oss / gus_vol.c


/*
 * gus_vol.c - Compute volume for GUS.
 *
 *
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 */
#include "sound_config.h"

#include "gus.h"
#include "gus_linearvol.h"

#define GUS_VOLUME	gus_wave_volume


extern int      gus_wave_volume;

/*
 * Calculate gus volume from note velocity, main volume, expression, and
 * intrinsic patch volume given in patch library.  Expression is multiplied
 * in, so it emphasizes differences in note velocity, while main volume is
 * added in -- I don't know whether this is right, but it seems reasonable to
 * me.  (In the previous stage, main volume controller messages were changed
 * to expression controller messages, if they were found to be used for
 * dynamic volume adjustments, so here, main volume can be assumed to be
 * constant throughout a song.)
 *
 * Intrinsic patch volume is added in, but if over 64 is also multiplied in, so
 * we can give a big boost to very weak voices like nylon guitar and the
 * basses.  The normal value is 64.  Strings are assigned lower values.
 */

unsigned short gus_adagio_vol(int vel, int mainv, int xpn, int voicev)
{
	int i, m, n, x;


	/*
	 * A voice volume of 64 is considered neutral, so adjust the main volume if
	 * something other than this neutral value was assigned in the patch
	 * library.
	 */
	x = 256 + 6 * (voicev - 64);

	/*
	 * Boost expression by voice volume above neutral.
	 */
	 
	if (voicev > 65)
		xpn += voicev - 64;
	xpn += (voicev - 64) / 2;

	/*
	 * Combine multiplicative and level components.
	 */
	x = vel * xpn * 6 + (voicev / 4) * x;

#ifdef GUS_VOLUME
	/*
	 * Further adjustment by installation-specific master volume control
	 * (default 60).
	 */
	x = (x * GUS_VOLUME * GUS_VOLUME) / 10000;
#endif

#ifdef GUS_USE_CHN_MAIN_VOLUME
	/*
	 * Experimental support for the channel main volume
	 */

	mainv = (mainv / 2) + 64;	/* Scale to 64 to 127 */
	x = (x * mainv * mainv) / 16384;
#endif

	if (x < 2)
		return (0);
	else if (x >= 65535)
		return ((15 << 8) | 255);

	/*
	 * Convert to GUS's logarithmic form with 4 bit exponent i and 8 bit
	 * mantissa m.
	 */
	 
	n = x;
	i = 7;
	if (n < 128)
	{
		  while (i > 0 && n < (1 << i))
			  i--;
	}
	else
	{
		while (n > 255)
		{
			  n >>= 1;
			  i++;
		}
	}
	/*
	 * Mantissa is part of linear volume not expressed in exponent.  (This is
	 * not quite like real logs -- I wonder if it's right.)
	 */
	m = x - (1 << i);

	/*
	 * Adjust mantissa to 8 bits.
	 */
	if (m > 0)
	{
		if (i > 8)
			m >>= i - 8;
		else if (i < 8)
			m <<= 8 - i;
	}
	return ((i << 8) + m);
}

/*
 * Volume-values are interpreted as linear values. Volume is based on the
 * value supplied with SEQ_START_NOTE(), channel main volume (if compiled in)
 * and the volume set by the mixer-device (default 60%).
 */

unsigned short gus_linear_vol(int vol, int mainvol)
{
	int mixer_mainvol;

	if (vol <= 0)
		vol = 0;
	else if (vol >= 127)
		vol = 127;

#ifdef GUS_VOLUME
	mixer_mainvol = GUS_VOLUME;
#else
	mixer_mainvol = 100;
#endif

#ifdef GUS_USE_CHN_MAIN_VOLUME
	if (mainvol <= 0)
		mainvol = 0;
	else if (mainvol >= 127)
		mainvol = 127;
#else
	mainvol = 127;
#endif
	return gus_linearvol[(((vol * mainvol) / 127) * mixer_mainvol) / 100];
}
Commit	Line	Data
1da177e4 LT	1
	2	/*
	3	* gus_vol.c - Compute volume for GUS.
	4	*
	5	*
	6	* Copyright (C) by Hannu Savolainen 1993-1997
	7	*
	8	* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
	9	* Version 2 (June 1991). See the "COPYING" file distributed with this software
	10	* for more info.
	11	*/
	12	#include "sound_config.h"
	13
	14	#include "gus.h"
	15	#include "gus_linearvol.h"
	16
	17	#define GUS_VOLUME gus_wave_volume
	18
	19
	20	extern int gus_wave_volume;
	21
	22	/*
	23	* Calculate gus volume from note velocity, main volume, expression, and
	24	* intrinsic patch volume given in patch library. Expression is multiplied
	25	* in, so it emphasizes differences in note velocity, while main volume is
	26	* added in -- I don't know whether this is right, but it seems reasonable to
	27	* me. (In the previous stage, main volume controller messages were changed
	28	* to expression controller messages, if they were found to be used for
	29	* dynamic volume adjustments, so here, main volume can be assumed to be
	30	* constant throughout a song.)
	31	*
	32	* Intrinsic patch volume is added in, but if over 64 is also multiplied in, so
	33	* we can give a big boost to very weak voices like nylon guitar and the
	34	* basses. The normal value is 64. Strings are assigned lower values.
	35	*/
	36
	37	unsigned short gus_adagio_vol(int vel, int mainv, int xpn, int voicev)
	38	{
	39	int i, m, n, x;
	40
	41
	42	/*
	43	* A voice volume of 64 is considered neutral, so adjust the main volume if
	44	* something other than this neutral value was assigned in the patch
	45	* library.
	46	*/
	47	x = 256 + 6 * (voicev - 64);
	48
	49	/*
	50	* Boost expression by voice volume above neutral.
	51	*/
	52
	53	if (voicev > 65)
	54	xpn += voicev - 64;
	55	xpn += (voicev - 64) / 2;
	56
	57	/*
	58	* Combine multiplicative and level components.
	59	*/
	60	x = vel * xpn * 6 + (voicev / 4) * x;
	61
	62	#ifdef GUS_VOLUME
	63	/*
	64	* Further adjustment by installation-specific master volume control
65	* (default 60).
66	*/
67	x = (x * GUS_VOLUME * GUS_VOLUME) / 10000;
68	#endif
69
70	#ifdef GUS_USE_CHN_MAIN_VOLUME
71	/*
72	* Experimental support for the channel main volume
73	*/
74
75	mainv = (mainv / 2) + 64; /* Scale to 64 to 127 */
76	x = (x * mainv * mainv) / 16384;
77	#endif
78
79	if (x < 2)
80	return (0);
81	else if (x >= 65535)
82	return ((15 << 8) \| 255);
83
84	/*
85	* Convert to GUS's logarithmic form with 4 bit exponent i and 8 bit
86	* mantissa m.
87	*/
88
89	n = x;
90	i = 7;
91	if (n < 128)
92	{
93	while (i > 0 && n < (1 << i))
94	i--;
95	}
96	else
97	{
98	while (n > 255)
99	{
100	n >>= 1;
101	i++;
102	}
103	}
104	/*
105	* Mantissa is part of linear volume not expressed in exponent. (This is
106	* not quite like real logs -- I wonder if it's right.)
107	*/
108	m = x - (1 << i);
109
110	/*
111	* Adjust mantissa to 8 bits.
112	*/
113	if (m > 0)
114	{
115	if (i > 8)
116	m >>= i - 8;
117	else if (i < 8)
118	m <<= 8 - i;
119	}
120	return ((i << 8) + m);
121	}
122
123	/*
124	* Volume-values are interpreted as linear values. Volume is based on the
125	* value supplied with SEQ_START_NOTE(), channel main volume (if compiled in)
126	* and the volume set by the mixer-device (default 60%).
127	*/
128
129	unsigned short gus_linear_vol(int vol, int mainvol)
130	{
131	int mixer_mainvol;
132
133	if (vol <= 0)
134	vol = 0;
135	else if (vol >= 127)
136	vol = 127;
137
138	#ifdef GUS_VOLUME
139	mixer_mainvol = GUS_VOLUME;
140	#else
141	mixer_mainvol = 100;
142	#endif
143
144	#ifdef GUS_USE_CHN_MAIN_VOLUME
145	if (mainvol <= 0)
146	mainvol = 0;
147	else if (mainvol >= 127)
148	mainvol = 127;
149	#else
150	mainvol = 127;
151	#endif
152	return gus_linearvol[(((vol * mainvol) / 127) * mixer_mainvol) / 100];
153	}