[picodrive.git] / pico / sound / sn76496.c

/***************************************************************************\r
\r
  sn76496.c\r
\r
  Routines to emulate the Texas Instruments SN76489 / SN76496 programmable\r
  tone /noise generator. Also known as (or at least compatible with) TMS9919.\r
\r
  Noise emulation is not accurate due to lack of documentation. The noise\r
  generator uses a shift register with a XOR-feedback network, but the exact\r
  layout is unknown. It can be set for either period or white noise; again,\r
  the details are unknown.\r
\r
  28/03/2005 : Sebastien Chevalier\r
  Update th SN76496Write func, according to SN76489 doc found on SMSPower.\r
   - On write with 0x80 set to 0, when LastRegister is other then TONE,\r
   the function is similar than update with 0x80 set to 1\r
***************************************************************************/\r
\r
#ifndef __GNUC__\r
#pragma warning (disable:4244)\r
#endif\r
\r
#include "sn76496.h"\r
\r
#define MAX_OUTPUT 0x47ff // was 0x7fff\r
\r
#define STEP 0x10000\r
\r
\r
/* Formulas for noise generator */\r
/* bit0 = output */\r
\r
/* noise feedback for white noise mode (verified on real SN76489 by John Kortink) */\r
#define FB_WNOISE 0x14002	/* (16bits) bit16 = bit0(out) ^ bit2 ^ bit15 */\r
\r
/* noise feedback for periodic noise mode */\r
//#define FB_PNOISE 0x10000 /* 16bit rorate */\r
#define FB_PNOISE 0x08000   /* JH 981127 - fixes Do Run Run */\r
\r
/*\r
0x08000 is definitely wrong. The Master System conversion of Marble Madness\r
uses periodic noise as a baseline. With a 15-bit rotate, the bassline is\r
out of tune.\r
The 16-bit rotate has been confirmed against a real PAL Sega Master System 2.\r
Hope that helps the System E stuff, more news on the PSG as and when!\r
*/\r
\r
/* noise generator start preset (for periodic noise) */\r
#define NG_PRESET 0x0f35\r
\r
\r
struct SN76496\r
{\r
	//sound_stream * Channel;\r
	int SampleRate;\r
	unsigned int UpdateStep;\r
	int VolTable[16];	/* volume table         */\r
	int Register[8];	/* registers */\r
	int LastRegister;	/* last register written */\r
	int Volume[4];		/* volume of voice 0-2 and noise */\r
	unsigned int RNG;		/* noise generator      */\r
	int NoiseFB;		/* noise feedback mask */\r
	int Period[4];\r
	int Count[4];\r
	int Output[4];\r
	int pad[1];\r
};\r
\r
static struct SN76496 ono_sn; // one and only SN76496\r
int *sn76496_regs;\r
\r
//static\r
void SN76496Write(int data)\r
{\r
	struct SN76496 *R = &ono_sn;\r
	int n;\r
\r
\r
	/* update the output buffer before changing the registers */\r
	//stream_update(R->Channel,0);\r
\r
	if (data & 0x80)\r
	{\r
		int r = (data & 0x70) >> 4;\r
		int c = r/2;\r
\r
		R->LastRegister = r;\r
		R->Register[r] = (R->Register[r] & 0x3f0) | (data & 0x0f);\r
		switch (r)\r
		{\r
			case 0:	/* tone 0 : frequency */\r
			case 2:	/* tone 1 : frequency */\r
			case 4:	/* tone 2 : frequency */\r
				R->Period[c] = R->UpdateStep * R->Register[r];\r
				if (R->Period[c] == 0) R->Period[c] = R->UpdateStep;\r
				if (r == 4)\r
				{\r
					/* update noise shift frequency */\r
					if ((R->Register[6] & 0x03) == 0x03)\r
						R->Period[3] = 2 * R->Period[2];\r
				}\r
				break;\r
			case 1:	/* tone 0 : volume */\r
			case 3:	/* tone 1 : volume */\r
			case 5:	/* tone 2 : volume */\r
			case 7:	/* noise  : volume */\r
				R->Volume[c] = R->VolTable[data & 0x0f];\r
				break;\r
			case 6:	/* noise  : frequency, mode */\r
				{\r
					int n = R->Register[6];\r
					R->NoiseFB = (n & 4) ? FB_WNOISE : FB_PNOISE;\r
					n &= 3;\r
					/* N/512,N/1024,N/2048,Tone #3 output */\r
					R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (R->UpdateStep << (5+(n&3)));\r
\r
					/* reset noise shifter */\r
					R->RNG = NG_PRESET;\r
					R->Output[3] = R->RNG & 1;\r
				}\r
				break;\r
		}\r
	}\r
	else\r
	{\r
		int r = R->LastRegister;\r
		int c = r/2;\r
\r
		switch (r)\r
		{\r
			case 0:	/* tone 0 : frequency */\r
			case 2:	/* tone 1 : frequency */\r
			case 4:	/* tone 2 : frequency */\r
				R->Register[r] = (R->Register[r] & 0x0f) | ((data & 0x3f) << 4);\r
				R->Period[c] = R->UpdateStep * R->Register[r];\r
				if (R->Period[c] == 0) R->Period[c] = R->UpdateStep;\r
				if (r == 4)\r
				{\r
					/* update noise shift frequency */\r
					if ((R->Register[6] & 0x03) == 0x03)\r
						R->Period[3] = 2 * R->Period[2];\r
				}\r
				break;\r
			case 1:	/* tone 0 : volume */\r
			case 3:	/* tone 1 : volume */\r
			case 5:	/* tone 2 : volume */\r
			case 7:	/* noise  : volume */\r
				R->Volume[c] = R->VolTable[data & 0x0f];\r
				R->Register[r] = (R->Register[r] & 0x3f0) | (data & 0x0f);\r
				break;\r
			case 6:	/* noise  : frequency, mode */\r
				{\r
					R->Register[r] = (R->Register[r] & 0x3f0) | (data & 0x0f);\r
					n = R->Register[6];\r
					R->NoiseFB = (n & 4) ? FB_WNOISE : FB_PNOISE;\r
					n &= 3;\r
					/* N/512,N/1024,N/2048,Tone #3 output */\r
					R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (R->UpdateStep << (5+(n&3)));\r
\r
					/* reset noise shifter */\r
					R->RNG = NG_PRESET;\r
					R->Output[3] = R->RNG & 1;\r
				}\r
				break;\r
		}\r
	}\r
}\r
\r
/*\r
WRITE8_HANDLER( SN76496_0_w ) {	SN76496Write(0,data); }\r
WRITE8_HANDLER( SN76496_1_w ) {	SN76496Write(1,data); }\r
WRITE8_HANDLER( SN76496_2_w ) {	SN76496Write(2,data); }\r
WRITE8_HANDLER( SN76496_3_w ) {	SN76496Write(3,data); }\r
WRITE8_HANDLER( SN76496_4_w ) {	SN76496Write(4,data); }\r
*/\r
\r
//static\r
void SN76496Update(short *buffer, int length, int stereo)\r
{\r
	int i;\r
	struct SN76496 *R = &ono_sn;\r
\r
	/* If the volume is 0, increase the counter */\r
	for (i = 0;i < 4;i++)\r
	{\r
		if (R->Volume[i] == 0)\r
		{\r
			/* note that I do count += length, NOT count = length + 1. You might think */\r
			/* it's the same since the volume is 0, but doing the latter could cause */\r
			/* interferencies when the program is rapidly modulating the volume. */\r
			if (R->Count[i] <= length*STEP) R->Count[i] += length*STEP;\r
		}\r
	}\r
\r
	while (length > 0)\r
	{\r
		int vol[4];\r
		unsigned int out;\r
		int left;\r
\r
\r
		/* vol[] keeps track of how long each square wave stays */\r
		/* in the 1 position during the sample period. */\r
		vol[0] = vol[1] = vol[2] = vol[3] = 0;\r
\r
		for (i = 0;i < 3;i++)\r
		{\r
			if (R->Output[i]) vol[i] += R->Count[i];\r
			R->Count[i] -= STEP;\r
			/* Period[i] is the half period of the square wave. Here, in each */\r
			/* loop I add Period[i] twice, so that at the end of the loop the */\r
			/* square wave is in the same status (0 or 1) it was at the start. */\r
			/* vol[i] is also incremented by Period[i], since the wave has been 1 */\r
			/* exactly half of the time, regardless of the initial position. */\r
			/* If we exit the loop in the middle, Output[i] has to be inverted */\r
			/* and vol[i] incremented only if the exit status of the square */\r
			/* wave is 1. */\r
			while (R->Count[i] <= 0)\r
			{\r
				R->Count[i] += R->Period[i];\r
				if (R->Count[i] > 0)\r
				{\r
					R->Output[i] ^= 1;\r
					if (R->Output[i]) vol[i] += R->Period[i];\r
					break;\r
				}\r
				R->Count[i] += R->Period[i];\r
				vol[i] += R->Period[i];\r
			}\r
			if (R->Output[i]) vol[i] -= R->Count[i];\r
		}\r
\r
		left = STEP;\r
		do\r
		{\r
			int nextevent;\r
\r
			if (R->Count[3] < left) nextevent = R->Count[3];\r
			else nextevent = left;\r
\r
			if (R->Output[3]) vol[3] += R->Count[3];\r
			R->Count[3] -= nextevent;\r
			if (R->Count[3] <= 0)\r
			{\r
				if (R->RNG & 1) R->RNG ^= R->NoiseFB;\r
				R->RNG >>= 1;\r
				R->Output[3] = R->RNG & 1;\r
				R->Count[3] += R->Period[3];\r
				if (R->Output[3]) vol[3] += R->Period[3];\r
			}\r
			if (R->Output[3]) vol[3] -= R->Count[3];\r
\r
			left -= nextevent;\r
		} while (left > 0);\r
\r
		out = vol[0] * R->Volume[0] + vol[1] * R->Volume[1] +\r
				vol[2] * R->Volume[2] + vol[3] * R->Volume[3];\r
\r
		if (out > MAX_OUTPUT * STEP) out = MAX_OUTPUT * STEP;\r
\r
		if ((out /= STEP)) // will be optimized to shift; max 0x47ff = 18431\r
			*buffer += out;\r
		if(stereo) buffer+=2; // only left for stereo, to be mixed to right later\r
		else buffer++;\r
\r
		length--;\r
	}\r
}\r
\r
\r
static void SN76496_set_clock(struct SN76496 *R,int clock)\r
{\r
\r
	/* the base clock for the tone generators is the chip clock divided by 16; */\r
	/* for the noise generator, it is clock / 256. */\r
	/* Here we calculate the number of steps which happen during one sample */\r
	/* at the given sample rate. No. of events = sample rate / (clock/16). */\r
	/* STEP is a multiplier used to turn the fraction into a fixed point */\r
	/* number. */\r
	R->UpdateStep = ((double)STEP * R->SampleRate * 16) / clock;\r
}\r
\r
\r
static void SN76496_set_gain(struct SN76496 *R,int gain)\r
{\r
	int i;\r
	double out;\r
\r
\r
	gain &= 0xff;\r
\r
	/* increase max output basing on gain (0.2 dB per step) */\r
	out = MAX_OUTPUT / 3;\r
	while (gain-- > 0)\r
		out *= 1.023292992;	/* = (10 ^ (0.2/20)) */\r
\r
	/* build volume table (2dB per step) */\r
	for (i = 0;i < 15;i++)\r
	{\r
		/* limit volume to avoid clipping */\r
		if (out > MAX_OUTPUT / 3) R->VolTable[i] = MAX_OUTPUT / 3;\r
		else R->VolTable[i] = out;\r
\r
		out /= 1.258925412;	/* = 10 ^ (2/20) = 2dB */\r
	}\r
	R->VolTable[15] = 0;\r
}\r
\r
\r
//static\r
int SN76496_init(int clock,int sample_rate)\r
{\r
	struct SN76496 *R = &ono_sn;\r
	int i;\r
\r
	//R->Channel = stream_create(0,1, sample_rate,R,SN76496Update);\r
	sn76496_regs = R->Register;\r
\r
	R->SampleRate = sample_rate;\r
	SN76496_set_clock(R,clock);\r
\r
	for (i = 0;i < 4;i++) R->Volume[i] = 0;\r
\r
	R->LastRegister = 0;\r
	for (i = 0;i < 8;i+=2)\r
	{\r
		R->Register[i] = 0;\r
		R->Register[i + 1] = 0x0f;	/* volume = 0 */\r
	}\r
\r
	for (i = 0;i < 4;i++)\r
	{\r
		R->Output[i] = 0;\r
		R->Period[i] = R->Count[i] = R->UpdateStep;\r
	}\r
	R->RNG = NG_PRESET;\r
	R->Output[3] = R->RNG & 1;\r
\r
	// added\r
	SN76496_set_gain(R, 0);\r
\r
	return 0;\r
}\r
\r
Commit	Line	Data
cc68a136	1	/***************************************************************************\r
	2	\r
	3	sn76496.c\r
	4	\r
	5	Routines to emulate the Texas Instruments SN76489 / SN76496 programmable\r
	6	tone /noise generator. Also known as (or at least compatible with) TMS9919.\r
	7	\r
	8	Noise emulation is not accurate due to lack of documentation. The noise\r
	9	generator uses a shift register with a XOR-feedback network, but the exact\r
	10	layout is unknown. It can be set for either period or white noise; again,\r
	11	the details are unknown.\r
	12	\r
	13	28/03/2005 : Sebastien Chevalier\r
	14	Update th SN76496Write func, according to SN76489 doc found on SMSPower.\r
	15	- On write with 0x80 set to 0, when LastRegister is other then TONE,\r
	16	the function is similar than update with 0x80 set to 1\r
	17	***************************************************************************/\r
	18	\r
	19	#ifndef __GNUC__\r
	20	#pragma warning (disable:4244)\r
	21	#endif\r
	22	\r
	23	#include "sn76496.h"\r
	24	\r
	25	#define MAX_OUTPUT 0x47ff // was 0x7fff\r
	26	\r
	27	#define STEP 0x10000\r
	28	\r
	29	\r
	30	/* Formulas for noise generator */\r
	31	/* bit0 = output */\r
	32	\r
	33	/* noise feedback for white noise mode (verified on real SN76489 by John Kortink) */\r
	34	#define FB_WNOISE 0x14002 /* (16bits) bit16 = bit0(out) ^ bit2 ^ bit15 */\r
	35	\r
	36	/* noise feedback for periodic noise mode */\r
	37	//#define FB_PNOISE 0x10000 /* 16bit rorate */\r
	38	#define FB_PNOISE 0x08000 /* JH 981127 - fixes Do Run Run */\r
	39	\r
	40	/*\r
	41	0x08000 is definitely wrong. The Master System conversion of Marble Madness\r
	42	uses periodic noise as a baseline. With a 15-bit rotate, the bassline is\r
	43	out of tune.\r
	44	The 16-bit rotate has been confirmed against a real PAL Sega Master System 2.\r
	45	Hope that helps the System E stuff, more news on the PSG as and when!\r
	46	*/\r
	47	\r
	48	/* noise generator start preset (for periodic noise) */\r
	49	#define NG_PRESET 0x0f35\r
	50	\r
	51	\r
	52	struct SN76496\r
	53	{\r
	54	//sound_stream * Channel;\r
	55	int SampleRate;\r
	56	unsigned int UpdateStep;\r
	57	int VolTable[16]; /* volume table */\r
	58	int Register[8]; /* registers */\r
	59	int LastRegister; /* last register written */\r
	60	int Volume[4]; /* volume of voice 0-2 and noise */\r
	61	unsigned int RNG; /* noise generator */\r
	62	int NoiseFB; /* noise feedback mask */\r
	63	int Period[4];\r
	64	int Count[4];\r
65	int Output[4];\r
66	int pad[1];\r
67	};\r
68	\r
69	static struct SN76496 ono_sn; // one and only SN76496\r
70	int *sn76496_regs;\r
71	\r
72	//static\r
73	void SN76496Write(int data)\r
74	{\r
75	struct SN76496 *R = &ono_sn;\r
76	int n;\r
77	\r
78	\r
79	/* update the output buffer before changing the registers */\r
80	//stream_update(R->Channel,0);\r
81	\r
82	if (data & 0x80)\r
83	{\r
84	int r = (data & 0x70) >> 4;\r
85	int c = r/2;\r
86	\r
87	R->LastRegister = r;\r
88	R->Register[r] = (R->Register[r] & 0x3f0) \| (data & 0x0f);\r
89	switch (r)\r
90	{\r
91	case 0: /* tone 0 : frequency */\r
92	case 2: /* tone 1 : frequency */\r
93	case 4: /* tone 2 : frequency */\r
94	R->Period[c] = R->UpdateStep * R->Register[r];\r
95	if (R->Period[c] == 0) R->Period[c] = R->UpdateStep;\r
96	if (r == 4)\r
97	{\r
98	/* update noise shift frequency */\r
99	if ((R->Register[6] & 0x03) == 0x03)\r
100	R->Period[3] = 2 * R->Period[2];\r
101	}\r
102	break;\r
103	case 1: /* tone 0 : volume */\r
104	case 3: /* tone 1 : volume */\r
105	case 5: /* tone 2 : volume */\r
106	case 7: /* noise : volume */\r
107	R->Volume[c] = R->VolTable[data & 0x0f];\r
108	break;\r
109	case 6: /* noise : frequency, mode */\r
110	{\r
111	int n = R->Register[6];\r
112	R->NoiseFB = (n & 4) ? FB_WNOISE : FB_PNOISE;\r
113	n &= 3;\r
114	/* N/512,N/1024,N/2048,Tone #3 output */\r
115	R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (R->UpdateStep << (5+(n&3)));\r
116	\r
117	/* reset noise shifter */\r
118	R->RNG = NG_PRESET;\r
119	R->Output[3] = R->RNG & 1;\r
120	}\r
121	break;\r
122	}\r
123	}\r
124	else\r
125	{\r
126	int r = R->LastRegister;\r
127	int c = r/2;\r
128	\r
129	switch (r)\r
130	{\r
131	case 0: /* tone 0 : frequency */\r
132	case 2: /* tone 1 : frequency */\r
133	case 4: /* tone 2 : frequency */\r
134	R->Register[r] = (R->Register[r] & 0x0f) \| ((data & 0x3f) << 4);\r
135	R->Period[c] = R->UpdateStep * R->Register[r];\r
136	if (R->Period[c] == 0) R->Period[c] = R->UpdateStep;\r
137	if (r == 4)\r
138	{\r
139	/* update noise shift frequency */\r
140	if ((R->Register[6] & 0x03) == 0x03)\r
141	R->Period[3] = 2 * R->Period[2];\r
142	}\r
143	break;\r
144	case 1: /* tone 0 : volume */\r
145	case 3: /* tone 1 : volume */\r
146	case 5: /* tone 2 : volume */\r
147	case 7: /* noise : volume */\r
148	R->Volume[c] = R->VolTable[data & 0x0f];\r
149	R->Register[r] = (R->Register[r] & 0x3f0) \| (data & 0x0f);\r
150	break;\r
151	case 6: /* noise : frequency, mode */\r
152	{\r
153	R->Register[r] = (R->Register[r] & 0x3f0) \| (data & 0x0f);\r
154	n = R->Register[6];\r
155	R->NoiseFB = (n & 4) ? FB_WNOISE : FB_PNOISE;\r
156	n &= 3;\r
157	/* N/512,N/1024,N/2048,Tone #3 output */\r
158	R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (R->UpdateStep << (5+(n&3)));\r
159	\r
160	/* reset noise shifter */\r
161	R->RNG = NG_PRESET;\r
162	R->Output[3] = R->RNG & 1;\r
163	}\r
164	break;\r
165	}\r
166	}\r
167	}\r
168	\r
169	/*\r
170	WRITE8_HANDLER( SN76496_0_w ) { SN76496Write(0,data); }\r
171	WRITE8_HANDLER( SN76496_1_w ) { SN76496Write(1,data); }\r
172	WRITE8_HANDLER( SN76496_2_w ) { SN76496Write(2,data); }\r
173	WRITE8_HANDLER( SN76496_3_w ) { SN76496Write(3,data); }\r
174	WRITE8_HANDLER( SN76496_4_w ) { SN76496Write(4,data); }\r
175	*/\r
176	\r
177	//static\r
4f265db7	178	void SN76496Update(short *buffer, int length, int stereo)\r
cc68a136	179	{\r
	180	int i;\r
	181	struct SN76496 *R = &ono_sn;\r
	182	\r
	183	/* If the volume is 0, increase the counter */\r
	184	for (i = 0;i < 4;i++)\r
	185	{\r
	186	if (R->Volume[i] == 0)\r
	187	{\r
	188	/* note that I do count += length, NOT count = length + 1. You might think */\r
	189	/* it's the same since the volume is 0, but doing the latter could cause */\r
	190	/* interferencies when the program is rapidly modulating the volume. */\r
	191	if (R->Count[i] <= lengthSTEP) R->Count[i] += lengthSTEP;\r
	192	}\r
	193	}\r
	194	\r
	195	while (length > 0)\r
	196	{\r
	197	int vol[4];\r
	198	unsigned int out;\r
	199	int left;\r
	200	\r
	201	\r
	202	/* vol[] keeps track of how long each square wave stays */\r
	203	/* in the 1 position during the sample period. */\r
	204	vol[0] = vol[1] = vol[2] = vol[3] = 0;\r
	205	\r
	206	for (i = 0;i < 3;i++)\r
	207	{\r
	208	if (R->Output[i]) vol[i] += R->Count[i];\r
	209	R->Count[i] -= STEP;\r
	210	/* Period[i] is the half period of the square wave. Here, in each */\r
	211	/* loop I add Period[i] twice, so that at the end of the loop the */\r
	212	/* square wave is in the same status (0 or 1) it was at the start. */\r
	213	/* vol[i] is also incremented by Period[i], since the wave has been 1 */\r
	214	/* exactly half of the time, regardless of the initial position. */\r
	215	/* If we exit the loop in the middle, Output[i] has to be inverted */\r
	216	/* and vol[i] incremented only if the exit status of the square */\r
	217	/* wave is 1. */\r
	218	while (R->Count[i] <= 0)\r
	219	{\r
	220	R->Count[i] += R->Period[i];\r
	221	if (R->Count[i] > 0)\r
	222	{\r
	223	R->Output[i] ^= 1;\r
	224	if (R->Output[i]) vol[i] += R->Period[i];\r
	225	break;\r
	226	}\r
	227	R->Count[i] += R->Period[i];\r
	228	vol[i] += R->Period[i];\r
	229	}\r
	230	if (R->Output[i]) vol[i] -= R->Count[i];\r
	231	}\r
	232	\r
	233	left = STEP;\r
	234	do\r
	235	{\r
	236	int nextevent;\r
	237	\r
	238	if (R->Count[3] < left) nextevent = R->Count[3];\r
	239	else nextevent = left;\r
	240	\r
	241	if (R->Output[3]) vol[3] += R->Count[3];\r
	242	R->Count[3] -= nextevent;\r
243	if (R->Count[3] <= 0)\r
244	{\r
245	if (R->RNG & 1) R->RNG ^= R->NoiseFB;\r
246	R->RNG >>= 1;\r
247	R->Output[3] = R->RNG & 1;\r
248	R->Count[3] += R->Period[3];\r
249	if (R->Output[3]) vol[3] += R->Period[3];\r
250	}\r
251	if (R->Output[3]) vol[3] -= R->Count[3];\r
252	\r
253	left -= nextevent;\r
254	} while (left > 0);\r
255	\r
256	out = vol[0] * R->Volume[0] + vol[1] * R->Volume[1] +\r
257	vol[2] * R->Volume[2] + vol[3] * R->Volume[3];\r
258	\r
259	if (out > MAX_OUTPUT * STEP) out = MAX_OUTPUT * STEP;\r
260	\r
4f265db7	261	if ((out /= STEP)) // will be optimized to shift; max 0x47ff = 18431\r
cc68a136	262	*buffer += out;\r
4f265db7	263	if(stereo) buffer+=2; // only left for stereo, to be mixed to right later\r
4f265db7	264	else buffer++;\r
cc68a136	265	\r
	266	length--;\r
	267	}\r
	268	}\r
	269	\r
	270	\r
	271	static void SN76496_set_clock(struct SN76496 *R,int clock)\r
	272	{\r
	273	\r
	274	/* the base clock for the tone generators is the chip clock divided by 16; */\r
	275	/* for the noise generator, it is clock / 256. */\r
	276	/* Here we calculate the number of steps which happen during one sample */\r
	277	/* at the given sample rate. No. of events = sample rate / (clock/16). */\r
	278	/* STEP is a multiplier used to turn the fraction into a fixed point */\r
	279	/* number. */\r
	280	R->UpdateStep = ((double)STEP * R->SampleRate * 16) / clock;\r
	281	}\r
	282	\r
	283	\r
	284	static void SN76496_set_gain(struct SN76496 *R,int gain)\r
	285	{\r
	286	int i;\r
	287	double out;\r
	288	\r
	289	\r
	290	gain &= 0xff;\r
	291	\r
	292	/* increase max output basing on gain (0.2 dB per step) */\r
	293	out = MAX_OUTPUT / 3;\r
	294	while (gain-- > 0)\r
	295	out = 1.023292992; / = (10 ^ (0.2/20)) */\r
	296	\r
	297	/* build volume table (2dB per step) */\r
	298	for (i = 0;i < 15;i++)\r
	299	{\r
	300	/* limit volume to avoid clipping */\r
	301	if (out > MAX_OUTPUT / 3) R->VolTable[i] = MAX_OUTPUT / 3;\r
	302	else R->VolTable[i] = out;\r
	303	\r
	304	out /= 1.258925412; /* = 10 ^ (2/20) = 2dB */\r
	305	}\r
	306	R->VolTable[15] = 0;\r
	307	}\r
	308	\r
	309	\r
	310	//static\r
	311	int SN76496_init(int clock,int sample_rate)\r
	312	{\r
	313	struct SN76496 *R = &ono_sn;\r
	314	int i;\r
	315	\r
	316	//R->Channel = stream_create(0,1, sample_rate,R,SN76496Update);\r
	317	sn76496_regs = R->Register;\r
	318	\r
	319	R->SampleRate = sample_rate;\r
	320	SN76496_set_clock(R,clock);\r
	321	\r
	322	for (i = 0;i < 4;i++) R->Volume[i] = 0;\r
	323	\r
	324	R->LastRegister = 0;\r
	325	for (i = 0;i < 8;i+=2)\r
	326	{\r
	327	R->Register[i] = 0;\r
	328	R->Register[i + 1] = 0x0f; /* volume = 0 */\r
329	}\r
330	\r
331	for (i = 0;i < 4;i++)\r
332	{\r
333	R->Output[i] = 0;\r
334	R->Period[i] = R->Count[i] = R->UpdateStep;\r
335	}\r
336	R->RNG = NG_PRESET;\r
337	R->Output[3] = R->RNG & 1;\r
338	\r
339	// added\r
340	SN76496_set_gain(R, 0);\r
341	\r
342	return 0;\r
343	}\r
344	\r