Previous

199869 Revisions

Next

r26338 Thursday 21st November, 2013 at 16:59:31 UTC by Osso
Modernized the sn76477 sound device (nw)

[src/emu/sound]	sn76477.c sn76477.h
[src/mame/audio]	8080bw.c astrof.c crbaloon.c laserbat.c mw8080bw.c n8080.c snk6502.c
[src/mame/drivers]	8080bw.c astrof.c crbaloon.c dai3wksi.c laserbat.c rotaryf.c route16.c snk6502.c spectra.c toratora.c
[src/mame/includes]	8080bw.h astrof.h crbaloon.h laserbat.h mw8080bw.h n8080.h route16.h
[src/mame/machine]	mw8080bw.c
[src/mame/video]	route16.c
[src/mess/drivers]	abc80.c hec2hrp.c interact.c
[src/mess/includes]	hec2hrp.h
[src/mess/machine]	hec2hrp.c hecdisk2.c
[src/mess/video]	hec2video.c

trunk/src/emu/sound/sn76477.c

r26337	r26338
30	30	#include "emu.h"
31	31	#include "wavwrite.h"
32	32	#include "sn76477.h"
33		#include "devlegcy.h"
34	33
35	34
36	35
r26337	r26338
68	67
69	68	#define LOG(n,x) do { if (VERBOSE >= (n)) logerror x; } while (0)
70	69
71		#define CHECK_CHIP_NUM                  assert(sn != NULL)
	70	#define CHECK_CHIP_NUM                  assert(this != NULL)
72	71	#define CHECK_CHIP_NUM_AND_BOOLEAN      CHECK_CHIP_NUM; assert((state & 0x01) == state)
73	72	#define CHECK_CHIP_NUM_AND_POSITIVE     CHECK_CHIP_NUM; assert(data >= 0.0)
74	73	#define CHECK_CHIP_NUM_AND_VOLTAGE      CHECK_CHIP_NUM; assert((data >= 0.0) && (data <= 5.0))
r26337	r26338
122	121	0           /* 9  enable           */
123	122	};
124	123
125		#define test_interface empty_empty_interface
	124	#define test_interface empty_interface
126	125
127	126	#endif
128	127
r26337	r26338
187	186	};
188	187
189	188
	189	const device_type SN76477 = &device_creator<sn76477_device>;
190	190
191		/*****************************************************************************
192		*
193		*  State structure
194		*
195		*****************************************************************************/
196
197		struct sn76477_state
	191	sn76477_device::sn76477_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	192	: device_t(mconfig, SN76477, "SN76477", tag, owner, clock, "sn76477", __FILE__),
	193	device_sound_interface(mconfig, *this),
	194	m_enable(0),
	195	m_envelope_mode(0),
	196	m_vco_mode(0),
	197	m_mixer_mode(0),
	198	m_one_shot_res(0),
	199	m_one_shot_cap(0),
	200	m_one_shot_cap_voltage_ext(0),
	201	m_slf_res(0),
	202	m_slf_cap(0),
	203	m_slf_cap_voltage_ext(0),
	204	m_vco_voltage(0),
	205	m_vco_res(0),
	206	m_vco_cap(0),
	207	m_vco_cap_voltage_ext(0),
	208	m_noise_clock_res(0),
	209	m_noise_clock_ext(0),
	210	m_noise_clock(0),
	211	m_noise_filter_res(0),
	212	m_noise_filter_cap(0),
	213	m_noise_filter_cap_voltage_ext(0),
	214	m_attack_res(0),
	215	m_decay_res(0),
	216	m_attack_decay_cap(0),
	217	m_attack_decay_cap_voltage_ext(0),
	218	m_amplitude_res(0),
	219	m_feedback_res(0),
	220	m_pitch_voltage(0),
	221	m_one_shot_cap_voltage(0),
	222	m_one_shot_running_ff(0),
	223	m_slf_cap_voltage(0),
	224	m_slf_out_ff(0),
	225	m_vco_cap_voltage(0),
	226	m_vco_out_ff(0),
	227	m_vco_alt_pos_edge_ff(0),
	228	m_noise_filter_cap_voltage(0),
	229	m_real_noise_bit_ff(0),
	230	m_filtered_noise_bit_ff(0),
	231	m_noise_gen_count(0),
	232	m_attack_decay_cap_voltage(0),
	233	m_rng(0),
	234	m_channel(NULL),
	235	m_our_sample_rate(0),
	236	m_file(NULL)
198	237	{
199		/* chip's external interface */
200		UINT32 enable;
201		UINT32 envelope_mode;
202		UINT32 vco_mode;
203		UINT32 mixer_mode;
	238	}
204	239
205		double one_shot_res;
206		double one_shot_cap;
207		UINT32 one_shot_cap_voltage_ext;
	240	//-------------------------------------------------
	241	//  device_config_complete - perform any
	242	//  operations now that the configuration is
	243	//  complete
	244	//-------------------------------------------------
208	245
209		double slf_res;
210		double slf_cap;
211		UINT32 slf_cap_voltage_ext;
	246	void sn76477_device::device_config_complete()
	247	{
	248	// inherit a copy of the static data
	249	const sn76477_interface *intf = reinterpret_cast<const sn76477_interface *>(static_config());
	250	if (intf != NULL)
	251	#if TEST_MODE == 0
	252	*static_cast<sn76477_interface *>(this) = *intf;
212	253
213		double vco_voltage;
214		double vco_res;
215		double vco_cap;
216		UINT32 vco_cap_voltage_ext;
	254	// or initialize to defaults if none provided
	255	else
	256	{
	257	m_intf_noise_clock_res = 0.0;
	258	m_intf_noise_filter_res = 0.0;
	259	m_intf_noise_filter_cap = 0.0;
	260	m_intf_decay_res = 0.0;
	261	m_intf_attack_decay_cap = 0.0;
	262	m_intf_attack_res = 0.0;
	263	m_intf_amplitude_res = 0.0;
	264	m_intf_feedback_res = 0.0;
	265	m_intf_vco_voltage = 0.0;
	266	m_intf_vco_cap = 0.0;
	267	m_intf_vco_res = 0.0;
	268	m_intf_pitch_voltage = 0.0;
	269	m_intf_slf_res = 0.0;
	270	m_intf_slf_cap = 0.0;
	271	m_intf_one_shot_cap = 0.0;
	272	m_intf_one_shot_res = 0.0;
	273	m_intf_vco = 0;
	274	m_intf_mixer_a = 0;
	275	m_intf_mixer_b = 0;
	276	m_intf_mixer_c = 0;
	277	m_intf_envelope_1 = 0;
	278	m_intf_envelope_2 = 0;
	279	m_intf_enable = 0;
	280	}
	281	#else
	282	intf = &test_interface;
	283	#endif
	284	}
217	285
218		double noise_clock_res;
219		UINT32 noise_clock_ext;
220		UINT32 noise_clock;
221		double noise_filter_res;
222		double noise_filter_cap;
223		UINT32 noise_filter_cap_voltage_ext;
	286	//-------------------------------------------------
	287	//  device_start - device-specific startup
	288	//-------------------------------------------------
224	289
225		double attack_res;
226		double decay_res;
227		double attack_decay_cap;
228		UINT32 attack_decay_cap_voltage_ext;
	290	void sn76477_device::device_start()
	291	{
	292	m_channel = machine().sound().stream_alloc(*this, 0, 1, machine().sample_rate(), this);
229	293
230		double amplitude_res;
231		double feedback_res;
232		double pitch_voltage;
	294	if (clock() > 0)
	295	{
	296	m_our_sample_rate = clock();
	297	}
	298	else
	299	{
	300	m_our_sample_rate = machine().sample_rate();
	301	}
233	302
234		/* chip's internal state */
235		double one_shot_cap_voltage;        /* voltage on the one-shot cap */
236		UINT32 one_shot_running_ff;         /* 1 = one-shot running, 0 = stopped */
	303	intialize_noise();
	304
	305	/* set up interface values */
	306	_SN76477_enable_w(m_intf_enable);
	307	_SN76477_vco_w(m_intf_vco);
	308	_SN76477_mixer_a_w(m_intf_mixer_a);
	309	_SN76477_mixer_b_w(m_intf_mixer_b);
	310	_SN76477_mixer_c_w(m_intf_mixer_c);
	311	_SN76477_envelope_1_w(m_intf_envelope_1);
	312	_SN76477_envelope_2_w(m_intf_envelope_2);
	313	_SN76477_one_shot_res_w(m_intf_one_shot_res);
	314	_SN76477_one_shot_cap_w(m_intf_one_shot_cap);
	315	_SN76477_slf_res_w(m_intf_slf_res);
	316	_SN76477_slf_cap_w(m_intf_slf_cap);
	317	_SN76477_vco_res_w(m_intf_vco_res);
	318	_SN76477_vco_cap_w(m_intf_vco_cap);
	319	_SN76477_vco_voltage_w(m_intf_vco_voltage);
	320	_SN76477_noise_clock_res_w(m_intf_noise_clock_res);
	321	_SN76477_noise_filter_res_w(m_intf_noise_filter_res);
	322	_SN76477_noise_filter_cap_w(m_intf_noise_filter_cap);
	323	_SN76477_decay_res_w(m_intf_decay_res);
	324	_SN76477_attack_res_w(m_intf_attack_res);
	325	_SN76477_attack_decay_cap_w(m_intf_attack_decay_cap);
	326	_SN76477_amplitude_res_w(m_intf_amplitude_res);
	327	_SN76477_feedback_res_w(m_intf_feedback_res);
	328	_SN76477_pitch_voltage_w(m_intf_pitch_voltage);
237	329
238		double slf_cap_voltage;             /* voltage on the SLF cap */
239		UINT32 slf_out_ff;                  /* output of the SLF */
	330	m_one_shot_cap_voltage = ONE_SHOT_CAP_VOLTAGE_MIN;
	331	m_slf_cap_voltage = SLF_CAP_VOLTAGE_MIN;
	332	m_vco_cap_voltage = VCO_CAP_VOLTAGE_MIN;
	333	m_noise_filter_cap_voltage = NOISE_CAP_VOLTAGE_MIN;
	334	m_attack_decay_cap_voltage = AD_CAP_VOLTAGE_MIN;
240	335
241		double vco_cap_voltage;             /* voltage on the VCO cap */
242		UINT32 vco_out_ff;                  /* output of the VCO */
243		UINT32 vco_alt_pos_edge_ff;         /* keeps track of the # of positive edges for VCO Alt envelope */
	336	state_save_register();
244	337
245		double noise_filter_cap_voltage;    /* voltage on the noise filter cap */
246		UINT32 real_noise_bit_ff;           /* the current noise bit before filtering */
247		UINT32 filtered_noise_bit_ff;       /* the noise bit after filtering */
248		UINT32 noise_gen_count;             /* noise freq emulation */
	338	log_complete_state();
249	339
250		double attack_decay_cap_voltage;    /* voltage on the attack/decay cap */
	340	if (LOG_WAV)
	341	open_wav_file();
	342	}
251	343
252		UINT32 rng;                         /* current value of the random number generator */
	344	//-------------------------------------------------
	345	//  device_stop - device-specific stop
	346	//-------------------------------------------------
253	347
254		/* others */
255		sound_stream *channel;              /* returned by stream_create() */
256		int sample_rate;                    /* from machine.sample_rate() */
257		device_t *device;
258
259		wav_file *file;                     /* handle of the wave file to produce */
260		};
261
262
263		INLINE sn76477_state *get_safe_token(device_t *device)
	348	void sn76477_device::device_stop()
264	349	{
265		assert(device != NULL);
266		assert(device->type() == SN76477);
267		return (sn76477_state *)downcast<sn76477_device *>(device)->token();
	350	if (LOG_WAV)
	351	close_wav_file();
268	352	}
269	353
270	354
r26337	r26338
298	382	*
299	383	*****************************************************************************/
300	384
301		static double compute_one_shot_cap_charging_rate(sn76477_state *sn) /* in V/sec */
	385	double sn76477_device::compute_one_shot_cap_charging_rate() /* in V/sec */
302	386	{
303	387	/* this formula was derived using the data points below
304	388
r26337	r26338
315	399
316	400	double ret = 0;
317	401
318		if ((sn->one_shot_res > 0) && (sn->one_shot_cap > 0))
	402	if ((m_one_shot_res > 0) && (m_one_shot_cap > 0))
319	403	{
320		ret = ONE_SHOT_CAP_VOLTAGE_RANGE / (0.8024 * sn->one_shot_res * sn->one_shot_cap + 0.002079);
	404	ret = ONE_SHOT_CAP_VOLTAGE_RANGE / (0.8024 * m_one_shot_res * m_one_shot_cap + 0.002079);
321	405	}
322		else if (sn->one_shot_cap > 0)
	406	else if (m_one_shot_cap > 0)
323	407	{
324	408	/* if no resistor, there is no current to charge the cap,
325	409	effectively making the one-shot time effectively infinite */
326	410	ret = +1e-30;
327	411	}
328		else if (sn->one_shot_res > 0)
	412	else if (m_one_shot_res > 0)
329	413	{
330	414	/* if no cap, the voltage changes extremely fast,
331	415	effectively making the one-shot time 0 */
r26337	r26338
336	420	}
337	421
338	422
339		static double compute_one_shot_cap_discharging_rate(sn76477_state *sn) /* in V/sec */
	423	double sn76477_device::compute_one_shot_cap_discharging_rate() /* in V/sec */
340	424	{
341	425	/* this formula was derived using the data points below
342	426
r26337	r26338
349	433
350	434	double ret = 0;
351	435
352		if ((sn->one_shot_res > 0) && (sn->one_shot_cap > 0))
	436	if ((m_one_shot_res > 0) && (m_one_shot_cap > 0))
353	437	{
354		ret = ONE_SHOT_CAP_VOLTAGE_RANGE / (854.7 * sn->one_shot_cap + 0.00001795);
	438	ret = ONE_SHOT_CAP_VOLTAGE_RANGE / (854.7 * m_one_shot_cap + 0.00001795);
355	439	}
356		else if (sn->one_shot_res > 0)
	440	else if (m_one_shot_res > 0)
357	441	{
358	442	/* if no cap, the voltage changes extremely fast,
359	443	effectively making the one-shot time 0 */
r26337	r26338
364	448	}
365	449
366	450
367		static double compute_slf_cap_charging_rate(sn76477_state *sn) /* in V/sec */
	451	double sn76477_device::compute_slf_cap_charging_rate() /* in V/sec */
368	452	{
369	453	/* this formula was derived using the data points below
370	454
r26337	r26338
378	462	*/
379	463	double ret = 0;
380	464
381		if ((sn->slf_res > 0) && (sn->slf_cap > 0))
	465	if ((m_slf_res > 0) && (m_slf_cap > 0))
382	466	{
383		ret = SLF_CAP_VOLTAGE_RANGE / (0.5885 * sn->slf_res * sn->slf_cap + 0.001300);
	467	ret = SLF_CAP_VOLTAGE_RANGE / (0.5885 * m_slf_res * m_slf_cap + 0.001300);
384	468	}
385	469
386	470	return ret;
387	471	}
388	472
389	473
390		static double compute_slf_cap_discharging_rate(sn76477_state *sn) /* in V/sec */
	474	double sn76477_device::compute_slf_cap_discharging_rate() /* in V/sec */
391	475	{
392	476	/* this formula was derived using the data points below
393	477
r26337	r26338
401	485	*/
402	486	double ret = 0;
403	487
404		if ((sn->slf_res > 0) && (sn->slf_cap > 0))
	488	if ((m_slf_res > 0) && (m_slf_cap > 0))
405	489	{
406		ret = SLF_CAP_VOLTAGE_RANGE / (0.5413 * sn->slf_res * sn->slf_cap + 0.001343);
	490	ret = SLF_CAP_VOLTAGE_RANGE / (0.5413 * m_slf_res * m_slf_cap + 0.001343);
407	491	}
408	492
409	493	return ret;
410	494	}
411	495
412	496
413		static double compute_vco_cap_charging_discharging_rate(sn76477_state *sn) /* in V/sec */
	497	double sn76477_device::compute_vco_cap_charging_discharging_rate() /* in V/sec */
414	498	{
415	499	double ret = 0;
416	500
417		if ((sn->vco_res > 0) && (sn->vco_cap > 0))
	501	if ((m_vco_res > 0) && (m_vco_cap > 0))
418	502	{
419		ret = 0.64 * 2 * VCO_CAP_VOLTAGE_RANGE / (sn->vco_res * sn->vco_cap);
	503	ret = 0.64 * 2 * VCO_CAP_VOLTAGE_RANGE / (m_vco_res * m_vco_cap);
420	504	}
421	505
422	506	return ret;
423	507	}
424	508
425	509
426		static double compute_vco_duty_cycle(sn76477_state *sn) /* no measure, just a number */
	510	double sn76477_device::compute_vco_duty_cycle() /* no measure, just a number */
427	511	{
428	512	double ret = 0.5;   /* 50% */
429	513
430		if ((sn->vco_voltage > 0) && (sn->pitch_voltage != VCO_DUTY_CYCLE_50))
	514	if ((m_vco_voltage > 0) && (m_pitch_voltage != VCO_DUTY_CYCLE_50))
431	515	{
432		ret = max(0.5 * (sn->pitch_voltage / sn->vco_voltage), (VCO_MIN_DUTY_CYCLE / 100.0));
	516	ret = max(0.5 * (m_pitch_voltage / m_vco_voltage), (VCO_MIN_DUTY_CYCLE / 100.0));
433	517
434	518	ret = min(ret, 1);
435	519	}
r26337	r26338
438	522	}
439	523
440	524
441		static UINT32 compute_noise_gen_freq(sn76477_state *sn) /* in Hz */
	525	UINT32 sn76477_device::compute_noise_gen_freq() /* in Hz */
442	526	{
443	527	/* this formula was derived using the data points below
444	528
r26337	r26338
470	554
471	555	UINT32 ret = 0;
472	556
473		if ((sn->noise_clock_res >= NOISE_MIN_CLOCK_RES) &&
474		(sn->noise_clock_res <= NOISE_MAX_CLOCK_RES))
	557	if ((m_noise_clock_res >= NOISE_MIN_CLOCK_RES) &&
	558	(m_noise_clock_res <= NOISE_MAX_CLOCK_RES))
475	559	{
476		ret = 339100000 * pow(sn->noise_clock_res, -0.8849);
	560	ret = 339100000 * pow(m_noise_clock_res, -0.8849);
477	561	}
478	562
479	563	return ret;
480	564	}
481	565
482	566
483		static double compute_noise_filter_cap_charging_rate(sn76477_state *sn) /* in V/sec */
	567	double sn76477_device::compute_noise_filter_cap_charging_rate() /* in V/sec */
484	568	{
485	569	/* this formula was derived using the data points below
486	570
r26337	r26338
497	581
498	582	double ret = 0;
499	583
500		if ((sn->noise_filter_res > 0) && (sn->noise_filter_cap > 0))
	584	if ((m_noise_filter_res > 0) && (m_noise_filter_cap > 0))
501	585	{
502		ret = NOISE_CAP_VOLTAGE_RANGE / (0.1571 * sn->noise_filter_res * sn->noise_filter_cap + 0.00001430);
	586	ret = NOISE_CAP_VOLTAGE_RANGE / (0.1571 * m_noise_filter_res * m_noise_filter_cap + 0.00001430);
503	587	}
504		else if (sn->noise_filter_cap > 0)
	588	else if (m_noise_filter_cap > 0)
505	589	{
506	590	/* if no resistor, there is no current to charge the cap,
507	591	effectively making the filter's output constants */
508	592	ret = +1e-30;
509	593	}
510		else if (sn->noise_filter_res > 0)
	594	else if (m_noise_filter_res > 0)
511	595	{
512	596	/* if no cap, the voltage changes extremely fast,
513	597	effectively disabling the filter */
r26337	r26338
518	602	}
519	603
520	604
521		static double compute_noise_filter_cap_discharging_rate(sn76477_state *sn) /* in V/sec */
	605	double sn76477_device::compute_noise_filter_cap_discharging_rate() /* in V/sec */
522	606	{
523	607	/* this formula was derived using the data points below
524	608
r26337	r26338
535	619
536	620	double ret = 0;
537	621
538		if ((sn->noise_filter_res > 0) && (sn->noise_filter_cap > 0))
	622	if ((m_noise_filter_res > 0) && (m_noise_filter_cap > 0))
539	623	{
540		ret = NOISE_CAP_VOLTAGE_RANGE / (0.1331 * sn->noise_filter_res * sn->noise_filter_cap + 0.00001734);
	624	ret = NOISE_CAP_VOLTAGE_RANGE / (0.1331 * m_noise_filter_res * m_noise_filter_cap + 0.00001734);
541	625	}
542		else if (sn->noise_filter_cap > 0)
	626	else if (m_noise_filter_cap > 0)
543	627	{
544	628	/* if no resistor, there is no current to charge the cap,
545	629	effectively making the filter's output constants */
546	630	ret = +1e-30;
547	631	}
548		else if (sn->noise_filter_res > 0)
	632	else if (m_noise_filter_res > 0)
549	633	{
550	634	/* if no cap, the voltage changes extremely fast,
551	635	effectively disabling the filter */
r26337	r26338
556	640	}
557	641
558	642
559		static double compute_attack_decay_cap_charging_rate(sn76477_state *sn)  /* in V/sec */
	643	double sn76477_device::compute_attack_decay_cap_charging_rate()  /* in V/sec */
560	644	{
561	645	double ret = 0;
562	646
563		if ((sn->attack_res > 0) && (sn->attack_decay_cap > 0))
	647	if ((m_attack_res > 0) && (m_attack_decay_cap > 0))
564	648	{
565		ret = AD_CAP_VOLTAGE_RANGE / (sn->attack_res * sn->attack_decay_cap);
	649	ret = AD_CAP_VOLTAGE_RANGE / (m_attack_res * m_attack_decay_cap);
566	650	}
567		else if (sn->attack_decay_cap > 0)
	651	else if (m_attack_decay_cap > 0)
568	652	{
569	653	/* if no resistor, there is no current to charge the cap,
570	654	effectively making the attack time infinite */
571	655	ret = +1e-30;
572	656	}
573		else if (sn->attack_res > 0)
	657	else if (m_attack_res > 0)
574	658	{
575	659	/* if no cap, the voltage changes extremely fast,
576	660	effectively making the attack time 0 */
r26337	r26338
581	665	}
582	666
583	667
584		static double compute_attack_decay_cap_discharging_rate(sn76477_state *sn)  /* in V/sec */
	668	double sn76477_device::compute_attack_decay_cap_discharging_rate()  /* in V/sec */
585	669	{
586	670	double ret = 0;
587	671
588		if ((sn->decay_res > 0) && (sn->attack_decay_cap > 0))
	672	if ((m_decay_res > 0) && (m_attack_decay_cap > 0))
589	673	{
590		ret = AD_CAP_VOLTAGE_RANGE / (sn->decay_res * sn->attack_decay_cap);
	674	ret = AD_CAP_VOLTAGE_RANGE / (m_decay_res * m_attack_decay_cap);
591	675	}
592		else if (sn->attack_decay_cap > 0)
	676	else if (m_attack_decay_cap > 0)
593	677	{
594	678	/* if no resistor, there is no current to charge the cap,
595	679	effectively making the decay time infinite */
596	680	ret = +1e-30;
597	681	}
598		else if (sn->attack_res > 0)
	682	else if (m_attack_res > 0)
599	683	{
600	684	/* if no cap, the voltage changes extremely fast,
601	685	effectively making the decay time 0 */
r26337	r26338
606	690	}
607	691
608	692
609		static double compute_center_to_peak_voltage_out(sn76477_state *sn)
	693	double sn76477_device::compute_center_to_peak_voltage_out()
610	694	{
611	695	/* this formula was derived using the data points below
612	696
r26337	r26338
624	708
625	709	double ret = 0;
626	710
627		if (sn->amplitude_res > 0)
	711	if (m_amplitude_res > 0)
628	712	{
629		ret = 3.818 * (sn->feedback_res / sn->amplitude_res) + 0.03;
	713	ret = 3.818 * (m_feedback_res / m_amplitude_res) + 0.03;
630	714	}
631	715
632	716	return ret;
r26337	r26338
640	724	*
641	725	*****************************************************************************/
642	726
643		static void log_enable_line(sn76477_state *sn)
	727	void sn76477_device::log_enable_line()
644	728	{
645	729	static const char *const desc[] =
646	730	{
647	731	"Enabled", "Inhibited"
648	732	};
649	733
650		LOG(1, ("SN76477 '%s':              Enable line (9): %d [%s]\n", sn->device->tag(), sn->enable, desc[sn->enable]));
	734	LOG(1, ("SN76477 '%s':              Enable line (9): %d [%s]\n", tag(), m_enable, desc[m_enable]));
651	735	}
652	736
653	737
654		static void log_mixer_mode(sn76477_state *sn)
	738	void sn76477_device::log_mixer_mode()
655	739	{
656	740	static const char *const desc[] =
657	741	{
r26337	r26338
659	743	"SLF/Noise", "SLF/VCO/Noise", "SLF/VCO", "Inhibit"
660	744	};
661	745
662		LOG(1, ("SN76477 '%s':           Mixer mode (25-27): %d [%s]\n", sn->device->tag(), sn->mixer_mode, desc[sn->mixer_mode]));
	746	LOG(1, ("SN76477 '%s':           Mixer mode (25-27): %d [%s]\n", tag(), m_mixer_mode, desc[m_mixer_mode]));
663	747	}
664	748
665	749
666		static void log_envelope_mode(sn76477_state *sn)
	750	void sn76477_device::log_envelope_mode()
667	751	{
668	752	static const char *const desc[] =
669	753	{
670	754	"VCO", "One-Shot", "Mixer Only", "VCO with Alternating Polarity"
671	755	};
672	756
673		LOG(1, ("SN76477 '%s':         Envelope mode (1,28): %d [%s]\n", sn->device->tag(), sn->envelope_mode, desc[sn->envelope_mode]));
	757	LOG(1, ("SN76477 '%s':         Envelope mode (1,28): %d [%s]\n", tag(), m_envelope_mode, desc[m_envelope_mode]));
674	758	}
675	759
676	760
677		static void log_vco_mode(sn76477_state *sn)
	761	void sn76477_device::log_vco_mode()
678	762	{
679	763	static const char *const desc[] =
680	764	{
681	765	"External (Pin 16)", "Internal (SLF)"
682	766	};
683	767
684		LOG(1, ("SN76477 '%s':                VCO mode (22): %d [%s]\n", sn->device->tag(), sn->vco_mode, desc[sn->vco_mode]));
	768	LOG(1, ("SN76477 '%s':                VCO mode (22): %d [%s]\n", tag(), m_vco_mode, desc[m_vco_mode]));
685	769	}
686	770
687	771
688		static void log_one_shot_time(sn76477_state *sn)
	772	void sn76477_device::log_one_shot_time()
689	773	{
690		if (!sn->one_shot_cap_voltage_ext)
	774	if (!m_one_shot_cap_voltage_ext)
691	775	{
692		if (compute_one_shot_cap_charging_rate(sn) > 0)
	776	if (compute_one_shot_cap_charging_rate() > 0)
693	777	{
694		LOG(1, ("SN76477 '%s':        One-shot time (23,24): %.4f sec\n", sn->device->tag(), ONE_SHOT_CAP_VOLTAGE_RANGE * (1 / compute_one_shot_cap_charging_rate(sn))));
	778	LOG(1, ("SN76477 '%s':        One-shot time (23,24): %.4f sec\n", tag(), ONE_SHOT_CAP_VOLTAGE_RANGE * (1 / compute_one_shot_cap_charging_rate())));
695	779	}
696	780	else
697	781	{
698		LOG(1, ("SN76477 '%s':        One-shot time (23,24): N/A\n", sn->device->tag()));
	782	LOG(1, ("SN76477 '%s':        One-shot time (23,24): N/A\n", tag()));
699	783	}
700	784	}
701	785	else
702	786	{
703		LOG(1, ("SN76477 '%s':        One-shot time (23,24): External (cap = %.2fV)\n", sn->device->tag(), sn->one_shot_cap_voltage));
	787	LOG(1, ("SN76477 '%s':        One-shot time (23,24): External (cap = %.2fV)\n", tag(), m_one_shot_cap_voltage));
704	788	}
705	789	}
706	790
707	791
708		static void log_slf_freq(sn76477_state *sn)
	792	void sn76477_device::log_slf_freq()
709	793	{
710		if (!sn->slf_cap_voltage_ext)
	794	if (!m_slf_cap_voltage_ext)
711	795	{
712		if (compute_slf_cap_charging_rate(sn) > 0)
	796	if (compute_slf_cap_charging_rate() > 0)
713	797	{
714		double charging_time = (1 / compute_slf_cap_charging_rate(sn)) * SLF_CAP_VOLTAGE_RANGE;
715		double discharging_time = (1 / compute_slf_cap_discharging_rate(sn)) * SLF_CAP_VOLTAGE_RANGE;
	798	double charging_time = (1 / compute_slf_cap_charging_rate()) * SLF_CAP_VOLTAGE_RANGE;
	799	double discharging_time = (1 / compute_slf_cap_discharging_rate()) * SLF_CAP_VOLTAGE_RANGE;
716	800
717		LOG(1, ("SN76477 '%s':        SLF frequency (20,21): %.2f Hz\n", sn->device->tag(), 1 / (charging_time + discharging_time)));
	801	LOG(1, ("SN76477 '%s':        SLF frequency (20,21): %.2f Hz\n", tag(), 1 / (charging_time + discharging_time)));
718	802	}
719	803	else
720	804	{
721		LOG(1, ("SN76477 '%s':        SLF frequency (20,21): N/A\n", sn->device->tag()));
	805	LOG(1, ("SN76477 '%s':        SLF frequency (20,21): N/A\n", tag()));
722	806	}
723	807	}
724	808	else
725	809	{
726		LOG(1, ("SN76477 '%s':        SLF frequency (20,21): External (cap = %.2fV)\n", sn->device->tag(), sn->slf_cap_voltage));
	810	LOG(1, ("SN76477 '%s':        SLF frequency (20,21): External (cap = %.2fV)\n", tag(), m_slf_cap_voltage));
727	811	}
728	812	}
729	813
730	814
731		static void log_vco_pitch_voltage(sn76477_state *sn)
	815	void sn76477_device::log_vco_pitch_voltage()
732	816	{
733		LOG(1, ("SN76477 '%s':       VCO pitch voltage (19): %.2fV\n", sn->device->tag(), sn->pitch_voltage));
	817	LOG(1, ("SN76477 '%s':       VCO pitch voltage (19): %.2fV\n", tag(), m_pitch_voltage));
734	818	}
735	819
736	820
737		static void log_vco_duty_cycle(sn76477_state *sn)
	821	void sn76477_device::log_vco_duty_cycle()
738	822	{
739		LOG(1, ("SN76477 '%s':       VCO duty cycle (16,19): %.0f%%\n", sn->device->tag(), compute_vco_duty_cycle(sn) * 100.0));
	823	LOG(1, ("SN76477 '%s':       VCO duty cycle (16,19): %.0f%%\n", tag(), compute_vco_duty_cycle() * 100.0));
740	824	}
741	825
742	826
743		static void log_vco_freq(sn76477_state *sn)
	827	void sn76477_device::log_vco_freq()
744	828	{
745		if (!sn->vco_cap_voltage_ext)
	829	if (!m_vco_cap_voltage_ext)
746	830	{
747		if (compute_vco_cap_charging_discharging_rate(sn) > 0)
	831	if (compute_vco_cap_charging_discharging_rate() > 0)
748	832	{
749		double min_freq = compute_vco_cap_charging_discharging_rate(sn) / (2 * VCO_CAP_VOLTAGE_RANGE);
750		double max_freq = compute_vco_cap_charging_discharging_rate(sn) / (2 * VCO_TO_SLF_VOLTAGE_DIFF);
	833	double min_freq = compute_vco_cap_charging_discharging_rate() / (2 * VCO_CAP_VOLTAGE_RANGE);
	834	double max_freq = compute_vco_cap_charging_discharging_rate() / (2 * VCO_TO_SLF_VOLTAGE_DIFF);
751	835
752		LOG(1, ("SN76477 '%s':        VCO frequency (17,18): %.2f Hz - %.1f Hz\n", sn->device->tag(), min_freq, max_freq));
	836	LOG(1, ("SN76477 '%s':        VCO frequency (17,18): %.2f Hz - %.1f Hz\n", tag(), min_freq, max_freq));
753	837	}
754	838	else
755	839	{
756		LOG(1, ("SN76477 '%s':        VCO frequency (17,18): N/A\n", sn->device->tag()));
	840	LOG(1, ("SN76477 '%s':        VCO frequency (17,18): N/A\n", tag()));
757	841	}
758	842	}
759	843	else
760	844	{
761		LOG(1, ("SN76477 '%s':        VCO frequency (17,18): External (cap = %.2fV)\n", sn->device->tag(), sn->vco_cap_voltage));
	845	LOG(1, ("SN76477 '%s':        VCO frequency (17,18): External (cap = %.2fV)\n", tag(), m_vco_cap_voltage));
762	846	}
763	847	}
764	848
765	849
766		static void log_vco_ext_voltage(sn76477_state *sn)
	850	void sn76477_device::log_vco_ext_voltage()
767	851	{
768		if (sn->vco_voltage <= VCO_MAX_EXT_VOLTAGE)
	852	if (m_vco_voltage <= VCO_MAX_EXT_VOLTAGE)
769	853	{
770		double min_freq = compute_vco_cap_charging_discharging_rate(sn) / (2 * VCO_CAP_VOLTAGE_RANGE);
771		double max_freq = compute_vco_cap_charging_discharging_rate(sn) / (2 * VCO_TO_SLF_VOLTAGE_DIFF);
	854	double min_freq = compute_vco_cap_charging_discharging_rate() / (2 * VCO_CAP_VOLTAGE_RANGE);
	855	double max_freq = compute_vco_cap_charging_discharging_rate() / (2 * VCO_TO_SLF_VOLTAGE_DIFF);
772	856
773		LOG(1, ("SN76477 '%s':        VCO ext. voltage (16): %.2fV (%.2f Hz)\n", sn->device->tag(),
774		sn->vco_voltage,
775		min_freq + ((max_freq - min_freq) * sn->vco_voltage / VCO_MAX_EXT_VOLTAGE)));
	857	LOG(1, ("SN76477 '%s':        VCO ext. voltage (16): %.2fV (%.2f Hz)\n", tag(),
	858	m_vco_voltage,
	859	min_freq + ((max_freq - min_freq) * m_vco_voltage / VCO_MAX_EXT_VOLTAGE)));
776	860	}
777	861	else
778	862	{
779		LOG(1, ("SN76477 '%s':        VCO ext. voltage (16): %.2fV (saturated, no output)\n", sn->device->tag(), sn->vco_voltage));
	863	LOG(1, ("SN76477 '%s':        VCO ext. voltage (16): %.2fV (saturated, no output)\n", tag(), m_vco_voltage));
780	864	}
781	865	}
782	866
783	867
784		static void log_noise_gen_freq(sn76477_state *sn)
	868	void sn76477_device::log_noise_gen_freq()
785	869	{
786		if (sn->noise_clock_ext)
	870	if (m_noise_clock_ext)
787	871	{
788		LOG(1, ("SN76477 '%s':      Noise gen frequency (4): External\n", sn->device->tag()));
	872	LOG(1, ("SN76477 '%s':      Noise gen frequency (4): External\n", tag()));
789	873	}
790	874	else
791	875	{
792		if (compute_noise_gen_freq(sn) > 0)
	876	if (compute_noise_gen_freq() > 0)
793	877	{
794		LOG(1, ("SN76477 '%s':      Noise gen frequency (4): %d Hz\n", sn->device->tag(), compute_noise_gen_freq(sn)));
	878	LOG(1, ("SN76477 '%s':      Noise gen frequency (4): %d Hz\n", tag(), compute_noise_gen_freq()));
795	879	}
796	880	else
797	881	{
798		LOG(1, ("SN76477 '%s':      Noise gen frequency (4): N/A\n", sn->device->tag()));
	882	LOG(1, ("SN76477 '%s':      Noise gen frequency (4): N/A\n", tag()));
799	883	}
800	884	}
801	885	}
802	886
803	887
804		static void log_noise_filter_freq(sn76477_state *sn)
	888	void sn76477_device::log_noise_filter_freq()
805	889	{
806		if (!sn->noise_filter_cap_voltage_ext)
	890	if (!m_noise_filter_cap_voltage_ext)
807	891	{
808		double charging_rate = compute_noise_filter_cap_charging_rate(sn);
	892	double charging_rate = compute_noise_filter_cap_charging_rate();
809	893
810	894	if (charging_rate > 0)
811	895	{
r26337	r26338
814	898	double charging_time = (1 / charging_rate) * NOISE_CAP_VOLTAGE_RANGE;
815	899	double discharging_time = (1 / charging_rate) * NOISE_CAP_VOLTAGE_RANGE;
816	900
817		LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): %.0f Hz\n", sn->device->tag(), 1 / (charging_time + discharging_time)));
	901	LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): %.0f Hz\n", tag(), 1 / (charging_time + discharging_time)));
818	902	}
819	903	else
820	904	{
821		LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): Very Large (Filtering Disabled)\n", sn->device->tag()));
	905	LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): Very Large (Filtering Disabled)\n", tag()));
822	906	}
823	907	}
824	908	else
825	909	{
826		LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): N/A\n", sn->device->tag()));
	910	LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): N/A\n", tag()));
827	911	}
828	912	}
829	913	else
830	914	{
831		LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): External (cap = %.2fV)\n", sn->device->tag(), sn->noise_filter_cap));
	915	LOG(1, ("SN76477 '%s': Noise filter frequency (5,6): External (cap = %.2fV)\n", tag(), m_noise_filter_cap));
832	916	}
833	917	}
834	918
835	919
836		static void log_attack_time(sn76477_state *sn)
	920	void sn76477_device::log_attack_time()
837	921	{
838		if (!sn->attack_decay_cap_voltage_ext)
	922	if (!m_attack_decay_cap_voltage_ext)
839	923	{
840		if (compute_attack_decay_cap_charging_rate(sn) > 0)
	924	if (compute_attack_decay_cap_charging_rate() > 0)
841	925	{
842		LOG(1, ("SN76477 '%s':           Attack time (8,10): %.4f sec\n", sn->device->tag(), AD_CAP_VOLTAGE_RANGE * (1 / compute_attack_decay_cap_charging_rate(sn))));
	926	LOG(1, ("SN76477 '%s':           Attack time (8,10): %.4f sec\n", tag(), AD_CAP_VOLTAGE_RANGE * (1 / compute_attack_decay_cap_charging_rate())));
843	927	}
844	928	else
845	929	{
846		LOG(1, ("SN76477 '%s':           Attack time (8,10): N/A\n", sn->device->tag()));
	930	LOG(1, ("SN76477 '%s':           Attack time (8,10): N/A\n", tag()));
847	931	}
848	932	}
849	933	else
850	934	{
851		LOG(1, ("SN76477 '%s':           Attack time (8,10): External (cap = %.2fV)\n", sn->device->tag(), sn->attack_decay_cap_voltage));
	935	LOG(1, ("SN76477 '%s':           Attack time (8,10): External (cap = %.2fV)\n", tag(), m_attack_decay_cap_voltage));
852	936	}
853	937	}
854	938
855	939
856		static void log_decay_time(sn76477_state *sn)
	940	void sn76477_device::log_decay_time()
857	941	{
858		if (!sn->attack_decay_cap_voltage_ext)
	942	if (!m_attack_decay_cap_voltage_ext)
859	943	{
860		if (compute_attack_decay_cap_discharging_rate(sn) > 0)
	944	if (compute_attack_decay_cap_discharging_rate() > 0)
861	945	{
862		LOG(1, ("SN76477 '%s':             Decay time (7,8): %.4f sec\n", sn->device->tag(), AD_CAP_VOLTAGE_RANGE * (1 / compute_attack_decay_cap_discharging_rate(sn))));
	946	LOG(1, ("SN76477 '%s':             Decay time (7,8): %.4f sec\n", tag(), AD_CAP_VOLTAGE_RANGE * (1 / compute_attack_decay_cap_discharging_rate())));
863	947	}
864	948	else
865	949	{
866		LOG(1, ("SN76477 '%s':            Decay time (8,10): N/A\n", sn->device->tag()));
	950	LOG(1, ("SN76477 '%s':            Decay time (8,10): N/A\n", tag()));
867	951	}
868	952	}
869	953	else
870	954	{
871		LOG(1, ("SN76477 '%s':             Decay time (7, 8): External (cap = %.2fV)\n", sn->device->tag(), sn->attack_decay_cap_voltage));
	955	LOG(1, ("SN76477 '%s':             Decay time (7, 8): External (cap = %.2fV)\n", tag(), m_attack_decay_cap_voltage));
872	956	}
873	957	}
874	958
875	959
876		static void log_voltage_out(sn76477_state *sn)
	960	void sn76477_device::log_voltage_out()
877	961	{
878	962	LOG(1, ("SN76477 '%s':    Voltage OUT range (11,12): %.2fV - %.2fV (clips above %.2fV)\n",
879		sn->device->tag(),
880		OUT_CENTER_LEVEL_VOLTAGE + compute_center_to_peak_voltage_out(sn) * out_neg_gain[(int)(AD_CAP_VOLTAGE_MAX * 10)],
881		OUT_CENTER_LEVEL_VOLTAGE + compute_center_to_peak_voltage_out(sn) * out_pos_gain[(int)(AD_CAP_VOLTAGE_MAX * 10)],
	963	tag(),
	964	OUT_CENTER_LEVEL_VOLTAGE + compute_center_to_peak_voltage_out() * out_neg_gain[(int)(AD_CAP_VOLTAGE_MAX * 10)],
	965	OUT_CENTER_LEVEL_VOLTAGE + compute_center_to_peak_voltage_out() * out_pos_gain[(int)(AD_CAP_VOLTAGE_MAX * 10)],
882	966	OUT_HIGH_CLIP_THRESHOLD));
883	967	}
884	968
885	969
886		static void log_complete_state(sn76477_state *sn)
	970	void sn76477_device::log_complete_state()
887	971	{
888		log_enable_line(sn);
889		log_mixer_mode(sn);
890		log_envelope_mode(sn);
891		log_vco_mode(sn);
892		log_one_shot_time(sn);
893		log_slf_freq(sn);
894		log_vco_freq(sn);
895		log_vco_ext_voltage(sn);
896		log_vco_pitch_voltage(sn);
897		log_vco_duty_cycle(sn);
898		log_noise_filter_freq(sn);
899		log_noise_gen_freq(sn);
900		log_attack_time(sn);
901		log_decay_time(sn);
902		log_voltage_out(sn);
	972	log_enable_line();
	973	log_mixer_mode();
	974	log_envelope_mode();
	975	log_vco_mode();
	976	log_one_shot_time();
	977	log_slf_freq();
	978	log_vco_freq();
	979	log_vco_ext_voltage();
	980	log_vco_pitch_voltage();
	981	log_vco_duty_cycle();
	982	log_noise_filter_freq();
	983	log_noise_gen_freq();
	984	log_attack_time();
	985	log_decay_time();
	986	log_voltage_out();
903	987	}
904	988
905	989
r26337	r26338
911	995	*****************************************************************************/
912	996
913	997
914		static void open_wav_file(sn76477_state *sn)
	998	void sn76477_device::open_wav_file()
915	999	{
916	1000	char wav_file_name[30];
917	1001
918		sprintf(wav_file_name, LOG_WAV_FILE_NAME, sn->device->tag());
919		sn->file = wav_open(wav_file_name, sn->sample_rate, 2);
	1002	sprintf(wav_file_name, LOG_WAV_FILE_NAME, tag());
	1003	m_file = wav_open(wav_file_name, m_our_sample_rate, 2);
920	1004
921		LOG(1, ("SN76477 '%s':         Logging output: %s\n", sn->device->tag(), wav_file_name));
	1005	LOG(1, ("SN76477 '%s':         Logging output: %s\n", tag(), wav_file_name));
922	1006	}
923	1007
924	1008
925		static void close_wav_file(sn76477_state *sn)
	1009	void sn76477_device::close_wav_file()
926	1010	{
927		wav_close(sn->file);
	1011	wav_close(m_file);
928	1012	}
929	1013
930	1014
931		static void add_wav_data(sn76477_state *sn, INT16 data_l, INT16 data_r)
	1015	void sn76477_device::add_wav_data(INT16 data_l, INT16 data_r)
932	1016	{
933		wav_add_data_16lr(sn->file, &data_l, &data_r, 1);
	1017	wav_add_data_16lr(m_file, &data_l, &data_r, 1);
934	1018	}
935	1019
936	1020
r26337	r26338
941	1025	*
942	1026	*****************************************************************************/
943	1027
944		static void intialize_noise(sn76477_state *sn)
	1028	void sn76477_device::intialize_noise()
945	1029	{
946		sn->rng = 0;
	1030	m_rng = 0;
947	1031	}
948	1032
949	1033
950		INLINE UINT32 generate_next_real_noise_bit(sn76477_state *sn)
	1034	inline UINT32 sn76477_device::generate_next_real_noise_bit()
951	1035	{
952		UINT32 out = ((sn->rng >> 28) & 1) ^ ((sn->rng >> 0) & 1);
	1036	UINT32 out = ((m_rng >> 28) & 1) ^ ((m_rng >> 0) & 1);
953	1037
954	1038	/* if bits 0-4 and 28 are all zero then force the output to 1 */
955		if ((sn->rng & 0x1000001f) == 0)
	1039	if ((m_rng & 0x1000001f) == 0)
956	1040	{
957	1041	out = 1;
958	1042	}
959	1043
960		sn->rng = (sn->rng >> 1) | (out << 30);
	1044	m_rng = (m_rng >> 1) | (out << 30);
961	1045
962	1046	return out;
963	1047	}
r26337	r26338
970	1054	*
971	1055	*****************************************************************************/
972	1056
973		static void _SN76477_enable_w(sn76477_state *sn, UINT32 data)
	1057	void sn76477_device::_SN76477_enable_w(UINT32 data)
974	1058	{
975		sn->enable = data;
	1059	m_enable = data;
976	1060
977	1061	/* if falling edge */
978		if (!sn->enable)
	1062	if (!m_enable)
979	1063	{
980	1064	/* start the attack phase */
981		sn->attack_decay_cap_voltage = AD_CAP_VOLTAGE_MIN;
	1065	m_attack_decay_cap_voltage = AD_CAP_VOLTAGE_MIN;
982	1066
983	1067	/* one-shot runs regardless of envelope mode */
984		sn->one_shot_running_ff = 1;
	1068	m_one_shot_running_ff = 1;
985	1069	}
986	1070	}
987	1071
988	1072
989		static void SN76477_test_enable_w(sn76477_state *sn, UINT32 data)
	1073	void sn76477_device::SN76477_test_enable_w(UINT32 data)
990	1074	{
991		if (data != sn->enable)
	1075	if (data != m_enable)
992	1076	{
993		sn->channel->update();
	1077	m_channel->update();
994	1078
995		_SN76477_enable_w(sn, data);
	1079	_SN76477_enable_w(data);
996	1080
997		log_enable_line(sn);
	1081	log_enable_line();
998	1082	}
999	1083	}
1000	1084
1001	1085
1002		WRITE_LINE_DEVICE_HANDLER( sn76477_enable_w )
	1086	WRITE_LINE_MEMBER( sn76477_device::enable_w )
1003	1087	{
1004	1088	#if TEST_MODE == 0
1005		sn76477_state *sn = get_safe_token(device);
1006
1007	1089	CHECK_CHIP_NUM_AND_BOOLEAN;
1008	1090
1009		SN76477_test_enable_w(sn, state);
	1091	SN76477_test_enable_w(state);
1010	1092	#endif
1011	1093	}
1012	1094
r26337	r26338
1018	1100	*
1019	1101	*****************************************************************************/
1020	1102
1021		static void _SN76477_mixer_a_w(sn76477_state *sn, UINT32 data)
	1103	void sn76477_device::_SN76477_mixer_a_w(UINT32 data)
1022	1104	{
1023		sn->mixer_mode = (sn->mixer_mode & ~0x01) | (data << 0);
	1105	m_mixer_mode = (m_mixer_mode & ~0x01) | (data << 0);
1024	1106	}
1025	1107
1026	1108
1027		WRITE_LINE_DEVICE_HANDLER( sn76477_mixer_a_w )
	1109	WRITE_LINE_MEMBER( sn76477_device::mixer_a_w )
1028	1110	{
1029	1111	#if TEST_MODE == 0
1030		sn76477_state *sn = get_safe_token(device);
1031
1032	1112	CHECK_CHIP_NUM_AND_BOOLEAN;
1033	1113
1034		if (state != ((sn->mixer_mode >> 0) & 0x01))
	1114	if (state != ((m_mixer_mode >> 0) & 0x01))
1035	1115	{
1036		sn->channel->update();
	1116	m_channel->update();
1037	1117
1038		_SN76477_mixer_a_w(sn, state);
	1118	_SN76477_mixer_a_w(state);
1039	1119
1040		log_mixer_mode(sn);
	1120	log_mixer_mode();
1041	1121	}
1042	1122	#endif
1043	1123	}
1044	1124
1045	1125
1046		static void _SN76477_mixer_b_w(sn76477_state *sn, UINT32 data)
	1126	void sn76477_device::_SN76477_mixer_b_w(UINT32 data)
1047	1127	{
1048		sn->mixer_mode = (sn->mixer_mode & ~0x02) | (data << 1);
	1128	m_mixer_mode = (m_mixer_mode & ~0x02) | (data << 1);
1049	1129	}
1050	1130
1051	1131
1052		WRITE_LINE_DEVICE_HANDLER( sn76477_mixer_b_w )
	1132	WRITE_LINE_MEMBER( sn76477_device::mixer_b_w )
1053	1133	{
1054	1134	#if TEST_MODE == 0
1055		sn76477_state *sn = get_safe_token(device);
1056
1057	1135	CHECK_CHIP_NUM_AND_BOOLEAN;
1058	1136
1059		if (state != ((sn->mixer_mode >> 1) & 0x01))
	1137	if (state != ((m_mixer_mode >> 1) & 0x01))
1060	1138	{
1061		sn->channel->update();
	1139	m_channel->update();
1062	1140
1063		_SN76477_mixer_b_w(sn, state);
	1141	_SN76477_mixer_b_w(state);
1064	1142
1065		log_mixer_mode(sn);
	1143	log_mixer_mode();
1066	1144	}
1067	1145	#endif
1068	1146	}
1069	1147
1070	1148
1071		static void _SN76477_mixer_c_w(sn76477_state *sn, UINT32 data)
	1149	void sn76477_device::_SN76477_mixer_c_w(UINT32 data)
1072	1150	{
1073		sn->mixer_mode = (sn->mixer_mode & ~0x04) | (data << 2);
	1151	m_mixer_mode = (m_mixer_mode & ~0x04) | (data << 2);
1074	1152	}
1075	1153
1076	1154
1077		WRITE_LINE_DEVICE_HANDLER( sn76477_mixer_c_w )
	1155	WRITE_LINE_MEMBER( sn76477_device::mixer_c_w )
1078	1156	{
1079	1157	#if TEST_MODE == 0
1080		sn76477_state *sn = get_safe_token(device);
1081
1082	1158	CHECK_CHIP_NUM_AND_BOOLEAN;
1083	1159
1084		if (state != ((sn->mixer_mode >> 2) & 0x01))
	1160	if (state != ((m_mixer_mode >> 2) & 0x01))
1085	1161	{
1086		sn->channel->update();
	1162	m_channel->update();
1087	1163
1088		_SN76477_mixer_c_w(sn, state);
	1164	_SN76477_mixer_c_w(state);
1089	1165
1090		log_mixer_mode(sn);
	1166	log_mixer_mode();
1091	1167	}
1092	1168	#endif
1093	1169	}
r26337	r26338
1100	1176	*
1101	1177	*****************************************************************************/
1102	1178
1103		static void _SN76477_envelope_1_w(sn76477_state *sn, UINT32 data)
	1179	void sn76477_device::_SN76477_envelope_1_w(UINT32 data)
1104	1180	{
1105		sn->envelope_mode = (sn->envelope_mode & ~0x01) | (data << 0);
	1181	m_envelope_mode = (m_envelope_mode & ~0x01) | (data << 0);
1106	1182	}
1107	1183
1108	1184
1109		WRITE_LINE_DEVICE_HANDLER( sn76477_envelope_1_w )
	1185	WRITE_LINE_MEMBER( sn76477_device::envelope_1_w )
1110	1186	{
1111	1187	#if TEST_MODE == 0
1112		sn76477_state *sn = get_safe_token(device);
1113
1114	1188	CHECK_CHIP_NUM_AND_BOOLEAN;
1115	1189
1116		if (state != ((sn->envelope_mode >> 0) & 0x01))
	1190	if (state != ((m_envelope_mode >> 0) & 0x01))
1117	1191	{
1118		sn->channel->update();
	1192	m_channel->update();
1119	1193
1120		_SN76477_envelope_1_w(sn, state);
	1194	_SN76477_envelope_1_w(state);
1121	1195
1122		log_envelope_mode(sn);
	1196	log_envelope_mode();
1123	1197	}
1124	1198	#endif
1125	1199	}
1126	1200
1127	1201
1128		static void _SN76477_envelope_2_w(sn76477_state *sn, UINT32 data)
	1202	void sn76477_device::_SN76477_envelope_2_w(UINT32 data)
1129	1203	{
1130		sn->envelope_mode = (sn->envelope_mode & ~0x02) | (data << 1);
	1204	m_envelope_mode = (m_envelope_mode & ~0x02) | (data << 1);
1131	1205	}
1132	1206
1133	1207
1134		WRITE_LINE_DEVICE_HANDLER( sn76477_envelope_2_w )
	1208	WRITE_LINE_MEMBER( sn76477_device::envelope_2_w )
1135	1209	{
1136	1210	#if TEST_MODE == 0
1137		sn76477_state *sn = get_safe_token(device);
1138
1139	1211	CHECK_CHIP_NUM_AND_BOOLEAN;
1140	1212
1141		if (state != ((sn->envelope_mode >> 1) & 0x01))
	1213	if (state != ((m_envelope_mode >> 1) & 0x01))
1142	1214	{
1143		sn->channel->update();
	1215	m_channel->update();
1144	1216
1145		_SN76477_envelope_2_w(sn, state);
	1217	_SN76477_envelope_2_w(state);
1146	1218
1147		log_envelope_mode(sn);
	1219	log_envelope_mode();
1148	1220	}
1149	1221	#endif
1150	1222	}
r26337	r26338
1157	1229	*
1158	1230	*****************************************************************************/
1159	1231
1160		static void _SN76477_vco_w(sn76477_state *sn, UINT32 data)
	1232	void sn76477_device::_SN76477_vco_w(UINT32 data)
1161	1233	{
1162		sn->vco_mode = data;
	1234	m_vco_mode = data;
1163	1235	}
1164	1236
1165	1237
1166		WRITE_LINE_DEVICE_HANDLER( sn76477_vco_w )
	1238	WRITE_LINE_MEMBER( sn76477_device::vco_w )
1167	1239	{
1168	1240	#if TEST_MODE == 0
1169		sn76477_state *sn = get_safe_token(device);
1170
1171	1241	CHECK_CHIP_NUM_AND_BOOLEAN;
1172	1242
1173		if (state != sn->vco_mode)
	1243	if (state != m_vco_mode)
1174	1244	{
1175		sn->channel->update();
	1245	m_channel->update();
1176	1246
1177		_SN76477_vco_w(sn, state);
	1247	_SN76477_vco_w(state);
1178	1248
1179		log_vco_mode(sn);
	1249	log_vco_mode();
1180	1250	}
1181	1251	#endif
1182	1252	}
r26337	r26338
1189	1259	*
1190	1260	*****************************************************************************/
1191	1261
1192		static void _SN76477_one_shot_res_w(sn76477_state *sn, double data)
	1262	void sn76477_device::_SN76477_one_shot_res_w(double data)
1193	1263	{
1194		sn->one_shot_res = data;
	1264	m_one_shot_res = data;
1195	1265	}
1196	1266
1197	1267
1198		void sn76477_one_shot_res_w(device_t *device, double data)
	1268	void sn76477_device::one_shot_res_w(double data)
1199	1269	{
1200	1270	#if TEST_MODE == 0
1201		sn76477_state *sn = get_safe_token(device);
1202
1203	1271	CHECK_CHIP_NUM_AND_POSITIVE;
1204	1272
1205		if (data != sn->one_shot_res)
	1273	if (data != m_one_shot_res)
1206	1274	{
1207		sn->channel->update();
	1275	m_channel->update();
1208	1276
1209		_SN76477_one_shot_res_w(sn, data);
	1277	_SN76477_one_shot_res_w(data);
1210	1278
1211		log_one_shot_time(sn);
	1279	log_one_shot_time();
1212	1280	}
1213	1281	#endif
1214	1282	}
r26337	r26338
1221	1289	*
1222	1290	*****************************************************************************/
1223	1291
1224		static void _SN76477_one_shot_cap_w(sn76477_state *sn, double data)
	1292	void sn76477_device::_SN76477_one_shot_cap_w(double data)
1225	1293	{
1226		sn->one_shot_cap = data;
	1294	m_one_shot_cap = data;
1227	1295	}
1228	1296
1229	1297
1230		void sn76477_one_shot_cap_w(device_t *device, double data)
	1298	void sn76477_device::one_shot_cap_w(double data)
1231	1299	{
1232	1300	#if TEST_MODE == 0
1233		sn76477_state *sn = get_safe_token(device);
1234
1235	1301	CHECK_CHIP_NUM_AND_POSITIVE;
1236	1302
1237		if (data != sn->one_shot_cap)
	1303	if (data != m_one_shot_cap)
1238	1304	{
1239		sn->channel->update();
	1305	m_channel->update();
1240	1306
1241		_SN76477_one_shot_cap_w(sn, data);
	1307	_SN76477_one_shot_cap_w(data);
1242	1308
1243		log_one_shot_time(sn);
	1309	log_one_shot_time();
1244	1310	}
1245	1311	#endif
1246	1312	}
r26337	r26338
1253	1319	*
1254	1320	*****************************************************************************/
1255	1321
1256		void sn76477_one_shot_cap_voltage_w(device_t *device, double data)
	1322	void sn76477_device::one_shot_cap_voltage_w(double data)
1257	1323	{
1258	1324	#if TEST_MODE == 0
1259		sn76477_state *sn = get_safe_token(device);
1260
1261	1325	CHECK_CHIP_NUM_AND_CAP_VOLTAGE;
1262	1326
1263	1327	if (data == SN76477_EXTERNAL_VOLTAGE_DISCONNECT)
1264	1328	{
1265	1329	/* switch to internal, if not already */
1266		if (sn->one_shot_cap_voltage_ext)
	1330	if (m_one_shot_cap_voltage_ext)
1267	1331	{
1268		sn->channel->update();
	1332	m_channel->update();
1269	1333
1270		sn->one_shot_cap_voltage_ext = 0;
	1334	m_one_shot_cap_voltage_ext = 0;
1271	1335
1272		log_one_shot_time(sn);
	1336	log_one_shot_time();
1273	1337	}
1274	1338	}
1275	1339	else
1276	1340	{
1277	1341	/* set the voltage on the cap */
1278		if (!sn->one_shot_cap_voltage_ext || (data != sn->one_shot_cap_voltage))
	1342	if (!m_one_shot_cap_voltage_ext || (data != m_one_shot_cap_voltage))
1279	1343	{
1280		sn->channel->update();
	1344	m_channel->update();
1281	1345
1282		sn->one_shot_cap_voltage_ext = 1;
1283		sn->one_shot_cap_voltage = data;
	1346	m_one_shot_cap_voltage_ext = 1;
	1347	m_one_shot_cap_voltage = data;
1284	1348
1285		log_one_shot_time(sn);
	1349	log_one_shot_time();
1286	1350	}
1287	1351	}
1288	1352	#endif
r26337	r26338
1296	1360	*
1297	1361	*****************************************************************************/
1298	1362
1299		static void _SN76477_slf_res_w(sn76477_state *sn, double data)
	1363	void sn76477_device::_SN76477_slf_res_w(double data)
1300	1364	{
1301		sn->slf_res = data;
	1365	m_slf_res = data;
1302	1366	}
1303	1367
1304	1368
1305		void sn76477_slf_res_w(device_t *device, double data)
	1369	void sn76477_device::slf_res_w(double data)
1306	1370	{
1307	1371	#if TEST_MODE == 0
1308		sn76477_state *sn = get_safe_token(device);
1309
1310	1372	CHECK_CHIP_NUM_AND_POSITIVE;
1311	1373
1312		if (data != sn->slf_res)
	1374	if (data != m_slf_res)
1313	1375	{
1314		sn->channel->update();
	1376	m_channel->update();
1315	1377
1316		_SN76477_slf_res_w(sn, data);
	1378	_SN76477_slf_res_w(data);
1317	1379
1318		log_slf_freq(sn);
	1380	log_slf_freq();
1319	1381	}
1320	1382	#endif
1321	1383	}
r26337	r26338
1328	1390	*
1329	1391	*****************************************************************************/
1330	1392
1331		static void _SN76477_slf_cap_w(sn76477_state *sn, double data)
	1393	void sn76477_device::_SN76477_slf_cap_w(double data)
1332	1394	{
1333		sn->slf_cap = data;
	1395	m_slf_cap = data;
1334	1396	}
1335	1397
1336	1398
1337		void sn76477_slf_cap_w(device_t *device, double data)
	1399	void sn76477_device::slf_cap_w(double data)
1338	1400	{
1339	1401	#if TEST_MODE == 0
1340		sn76477_state *sn = get_safe_token(device);
1341
1342	1402	CHECK_CHIP_NUM_AND_POSITIVE;
1343	1403
1344		if (data != sn->slf_cap)
	1404	if (data != m_slf_cap)
1345	1405	{
1346		sn->channel->update();
	1406	m_channel->update();
1347	1407
1348		_SN76477_slf_cap_w(sn, data);
	1408	_SN76477_slf_cap_w(data);
1349	1409
1350		log_slf_freq(sn);
	1410	log_slf_freq();
1351	1411	}
1352	1412	#endif
1353	1413	}
r26337	r26338
1362	1422	*
1363	1423	*****************************************************************************/
1364	1424
1365		void sn76477_slf_cap_voltage_w(device_t *device, double data)
	1425	void sn76477_device::slf_cap_voltage_w(double data)
1366	1426	{
1367	1427	#if TEST_MODE == 0
1368		sn76477_state *sn = get_safe_token(device);
1369
1370	1428	CHECK_CHIP_NUM_AND_CAP_VOLTAGE;
1371	1429
1372	1430	if (data == SN76477_EXTERNAL_VOLTAGE_DISCONNECT)
1373	1431	{
1374	1432	/* switch to internal, if not already */
1375		if (sn->slf_cap_voltage_ext)
	1433	if (m_slf_cap_voltage_ext)
1376	1434	{
1377		sn->channel->update();
	1435	m_channel->update();
1378	1436
1379		sn->slf_cap_voltage_ext = 0;
	1437	m_slf_cap_voltage_ext = 0;
1380	1438
1381		log_slf_freq(sn);
	1439	log_slf_freq();
1382	1440	}
1383	1441	}
1384	1442	else
1385	1443	{
1386	1444	/* set the voltage on the cap */
1387		if (!sn->slf_cap_voltage_ext || (data != sn->slf_cap_voltage))
	1445	if (!m_slf_cap_voltage_ext || (data != m_slf_cap_voltage))
1388	1446	{
1389		sn->channel->update();
	1447	m_channel->update();
1390	1448
1391		sn->slf_cap_voltage_ext = 1;
1392		sn->slf_cap_voltage = data;
	1449	m_slf_cap_voltage_ext = 1;
	1450	m_slf_cap_voltage = data;
1393	1451
1394		log_slf_freq(sn);
	1452	log_slf_freq();
1395	1453	}
1396	1454	}
1397	1455	#endif
r26337	r26338
1405	1463	*
1406	1464	*****************************************************************************/
1407	1465
1408		static void _SN76477_vco_res_w(sn76477_state *sn, double data)
	1466	void sn76477_device::_SN76477_vco_res_w(double data)
1409	1467	{
1410		sn->vco_res = data;
	1468	m_vco_res = data;
1411	1469	}
1412	1470
1413	1471
1414		void sn76477_vco_res_w(device_t *device, double data)
	1472	void sn76477_device::vco_res_w(double data)
1415	1473	{
1416	1474	#if TEST_MODE == 0
1417		sn76477_state *sn = get_safe_token(device);
1418
1419	1475	CHECK_CHIP_NUM_AND_POSITIVE;
1420	1476
1421		if (data != sn->vco_res)
	1477	if (data != m_vco_res)
1422	1478	{
1423		sn->channel->update();
	1479	m_channel->update();
1424	1480
1425		_SN76477_vco_res_w(sn, data);
	1481	_SN76477_vco_res_w(data);
1426	1482
1427		log_vco_freq(sn);
	1483	log_vco_freq();
1428	1484	}
1429	1485	#endif
1430	1486	}
r26337	r26338
1437	1493	*
1438	1494	*****************************************************************************/
1439	1495
1440		static void _SN76477_vco_cap_w(sn76477_state *sn, double data)
	1496	void sn76477_device::_SN76477_vco_cap_w(double data)
1441	1497	{
1442		sn->vco_cap = data;
	1498	m_vco_cap = data;
1443	1499	}
1444	1500
1445	1501
1446		void sn76477_vco_cap_w(device_t *device, double data)
	1502	void sn76477_device::vco_cap_w(double data)
1447	1503	{
1448	1504	#if TEST_MODE == 0
1449		sn76477_state *sn = get_safe_token(device);
1450
1451	1505	CHECK_CHIP_NUM_AND_POSITIVE;
1452	1506
1453		if (data != sn->vco_cap)
	1507	if (data != m_vco_cap)
1454	1508	{
1455		sn->channel->update();
	1509	m_channel->update();
1456	1510
1457		_SN76477_vco_cap_w(sn, data);
	1511	_SN76477_vco_cap_w(data);
1458	1512
1459		log_vco_freq(sn);
	1513	log_vco_freq();
1460	1514	}
1461	1515	#endif
1462	1516	}
r26337	r26338
1469	1523	*
1470	1524	*****************************************************************************/
1471	1525
1472		void sn76477_vco_cap_voltage_w(device_t *device, double data)
	1526	void sn76477_device::vco_cap_voltage_w(double data)
1473	1527	{
1474	1528	#if TEST_MODE == 0
1475		sn76477_state *sn = get_safe_token(device);
1476
1477	1529	CHECK_CHIP_NUM_AND_CAP_VOLTAGE;
1478	1530
1479	1531	if (data == SN76477_EXTERNAL_VOLTAGE_DISCONNECT)
1480	1532	{
1481	1533	/* switch to internal, if not already */
1482		if (sn->vco_cap_voltage_ext)
	1534	if (m_vco_cap_voltage_ext)
1483	1535	{
1484		sn->channel->update();
	1536	m_channel->update();
1485	1537
1486		sn->vco_cap_voltage_ext = 0;
	1538	m_vco_cap_voltage_ext = 0;
1487	1539
1488		log_vco_freq(sn);
	1540	log_vco_freq();
1489	1541	}
1490	1542	}
1491	1543	else
1492	1544	{
1493	1545	/* set the voltage on the cap */
1494		if (!sn->vco_cap_voltage_ext || (data != sn->vco_cap_voltage))
	1546	if (!m_vco_cap_voltage_ext || (data != m_vco_cap_voltage))
1495	1547	{
1496		sn->channel->update();
	1548	m_channel->update();
1497	1549
1498		sn->vco_cap_voltage_ext = 1;
1499		sn->vco_cap_voltage = data;
	1550	m_vco_cap_voltage_ext = 1;
	1551	m_vco_cap_voltage = data;
1500	1552
1501		log_vco_freq(sn);
	1553	log_vco_freq();
1502	1554	}
1503	1555	}
1504	1556	#endif
r26337	r26338
1512	1564	*
1513	1565	*****************************************************************************/
1514	1566
1515		static void _SN76477_vco_voltage_w(sn76477_state *sn, double data)
	1567	void sn76477_device::_SN76477_vco_voltage_w(double data)
1516	1568	{
1517		sn->vco_voltage = data;
	1569	m_vco_voltage = data;
1518	1570	}
1519	1571
1520	1572
1521		void sn76477_vco_voltage_w(device_t *device, double data)
	1573	void sn76477_device::vco_voltage_w(double data)
1522	1574	{
1523	1575	#if TEST_MODE == 0
1524		sn76477_state *sn = get_safe_token(device);
1525
1526	1576	CHECK_CHIP_NUM_AND_VOLTAGE;
1527	1577
1528		if (data != sn->vco_voltage)
	1578	if (data != m_vco_voltage)
1529	1579	{
1530		sn->channel->update();
	1580	m_channel->update();
1531	1581
1532		_SN76477_vco_voltage_w(sn, data);
	1582	_SN76477_vco_voltage_w(data);
1533	1583
1534		log_vco_ext_voltage(sn);
1535		log_vco_duty_cycle(sn);
	1584	log_vco_ext_voltage();
	1585	log_vco_duty_cycle();
1536	1586	}
1537	1587	#endif
1538	1588	}
r26337	r26338
1545	1595	*
1546	1596	*****************************************************************************/
1547	1597
1548		static void _SN76477_pitch_voltage_w(sn76477_state *sn, double data)
	1598	void sn76477_device::_SN76477_pitch_voltage_w(double data)
1549	1599	{
1550		sn->pitch_voltage = data;
	1600	m_pitch_voltage = data;
1551	1601	}
1552	1602
1553	1603
1554		void sn76477_pitch_voltage_w(device_t *device, double data)
	1604	void sn76477_device::pitch_voltage_w(double data)
1555	1605	{
1556	1606	#if TEST_MODE == 0
1557		sn76477_state *sn = get_safe_token(device);
1558
1559	1607	CHECK_CHIP_NUM_AND_VOLTAGE;
1560	1608
1561		if (data != sn->pitch_voltage)
	1609	if (data != m_pitch_voltage)
1562	1610	{
1563		sn->channel->update();
	1611	m_channel->update();
1564	1612
1565		_SN76477_pitch_voltage_w(sn, data);
	1613	_SN76477_pitch_voltage_w(data);
1566	1614
1567		log_vco_pitch_voltage(sn);
1568		log_vco_duty_cycle(sn);
	1615	log_vco_pitch_voltage();
	1616	log_vco_duty_cycle();
1569	1617	}
1570	1618	#endif
1571	1619	}
r26337	r26338
1578	1626	*
1579	1627	*****************************************************************************/
1580	1628
1581		WRITE_LINE_DEVICE_HANDLER( sn76477_noise_clock_w )
	1629	WRITE_LINE_MEMBER( sn76477_device::noise_clock_w )
1582	1630	{
1583	1631	#if TEST_MODE == 0
1584		sn76477_state *sn = get_safe_token(device);
1585
1586	1632	CHECK_CHIP_NUM_AND_BOOLEAN;
1587	1633
1588		if (state != sn->noise_clock)
	1634	if (state != m_noise_clock)
1589	1635	{
1590		sn->noise_clock = state;
	1636	m_noise_clock = state;
1591	1637
1592	1638	/* on the rising edge shift generate next value,
1593	1639	if external control is enabled */
1594		if (sn->noise_clock && sn->noise_clock_ext)
	1640	if (m_noise_clock && m_noise_clock_ext)
1595	1641	{
1596		sn->channel->update();
	1642	m_channel->update();
1597	1643
1598		sn->real_noise_bit_ff = generate_next_real_noise_bit(sn);
	1644	m_real_noise_bit_ff = generate_next_real_noise_bit();
1599	1645	}
1600	1646	}
1601	1647	#endif
r26337	r26338
1609	1655	*
1610	1656	*****************************************************************************/
1611	1657
1612		static void _SN76477_noise_clock_res_w(sn76477_state *sn, double data)
	1658	void sn76477_device::_SN76477_noise_clock_res_w(double data)
1613	1659	{
1614	1660	if (data == 0)
1615	1661	{
1616		sn->noise_clock_ext = 1;
	1662	m_noise_clock_ext = 1;
1617	1663	}
1618	1664	else
1619	1665	{
1620		sn->noise_clock_ext = 0;
	1666	m_noise_clock_ext = 0;
1621	1667
1622		sn->noise_clock_res = data;
	1668	m_noise_clock_res = data;
1623	1669	}
1624	1670	}
1625	1671
1626	1672
1627		void sn76477_noise_clock_res_w(device_t *device, double data)
	1673	void sn76477_device::noise_clock_res_w(double data)
1628	1674	{
1629	1675	#if TEST_MODE == 0
1630		sn76477_state *sn = get_safe_token(device);
1631
1632	1676	CHECK_CHIP_NUM_AND_POSITIVE;
1633	1677
1634		if (((data == 0) && !sn->noise_clock_ext) ||
1635		((data != 0) && (data != sn->noise_clock_res)))
	1678	if (((data == 0) && !m_noise_clock_ext) ||
	1679	((data != 0) && (data != m_noise_clock_res)))
1636	1680	{
1637		sn->channel->update();
	1681	m_channel->update();
1638	1682
1639		_SN76477_noise_clock_res_w(sn, data);
	1683	_SN76477_noise_clock_res_w(data);
1640	1684
1641		log_noise_gen_freq(sn);
	1685	log_noise_gen_freq();
1642	1686	}
1643	1687	#endif
1644	1688	}
r26337	r26338
1651	1695	*
1652	1696	*****************************************************************************/
1653	1697
1654		static void _SN76477_noise_filter_res_w(sn76477_state *sn, double data)
	1698	void sn76477_device::_SN76477_noise_filter_res_w(double data)
1655	1699	{
1656		sn->noise_filter_res = data;
	1700	m_noise_filter_res = data;
1657	1701	}
1658	1702
1659	1703
1660		void sn76477_noise_filter_res_w(device_t *device, double data)
	1704	void sn76477_device::noise_filter_res_w(double data)
1661	1705	{
1662	1706	#if TEST_MODE == 0
1663		sn76477_state *sn = get_safe_token(device);
1664
1665	1707	CHECK_CHIP_NUM_AND_POSITIVE;
1666	1708
1667		if (data != sn->noise_filter_res)
	1709	if (data != m_noise_filter_res)
1668	1710	{
1669		sn->channel->update();
	1711	m_channel->update();
1670	1712
1671		_SN76477_noise_filter_res_w(sn, data);
	1713	_SN76477_noise_filter_res_w(data);
1672	1714
1673		log_noise_filter_freq(sn);
	1715	log_noise_filter_freq();
1674	1716	}
1675	1717	#endif
1676	1718	}
r26337	r26338
1683	1725	*
1684	1726	*****************************************************************************/
1685	1727
1686		static void _SN76477_noise_filter_cap_w(sn76477_state *sn, double data)
	1728	void sn76477_device::_SN76477_noise_filter_cap_w(double data)
1687	1729	{
1688		sn->noise_filter_cap = data;
	1730	m_noise_filter_cap = data;
1689	1731	}
1690	1732
1691	1733
1692		void sn76477_noise_filter_cap_w(device_t *device, double data)
	1734	void sn76477_device::noise_filter_cap_w(double data)
1693	1735	{
1694	1736	#if TEST_MODE == 0
1695		sn76477_state *sn = get_safe_token(device);
1696
1697	1737	CHECK_CHIP_NUM_AND_POSITIVE;
1698	1738
1699		if (data != sn->noise_filter_cap)
	1739	if (data != m_noise_filter_cap)
1700	1740	{
1701		sn->channel->update();
	1741	m_channel->update();
1702	1742
1703		_SN76477_noise_filter_cap_w(sn, data);
	1743	_SN76477_noise_filter_cap_w(data);
1704	1744
1705		log_noise_filter_freq(sn);
	1745	log_noise_filter_freq();
1706	1746	}
1707	1747	#endif
1708	1748	}
r26337	r26338
1715	1755	*
1716	1756	*****************************************************************************/
1717	1757
1718		void sn76477_noise_filter_cap_voltage_w(device_t *device, double data)
	1758	void sn76477_device::noise_filter_cap_voltage_w(double data)
1719	1759	{
1720	1760	#if TEST_MODE == 0
1721		sn76477_state *sn = get_safe_token(device);
1722
1723	1761	CHECK_CHIP_NUM_AND_CAP_VOLTAGE;
1724	1762
1725	1763	if (data == SN76477_EXTERNAL_VOLTAGE_DISCONNECT)
1726	1764	{
1727	1765	/* switch to internal, if not already */
1728		if (sn->noise_filter_cap_voltage_ext)
	1766	if (m_noise_filter_cap_voltage_ext)
1729	1767	{
1730		sn->channel->update();
	1768	m_channel->update();
1731	1769
1732		sn->noise_filter_cap_voltage_ext = 0;
	1770	m_noise_filter_cap_voltage_ext = 0;
1733	1771
1734		log_noise_filter_freq(sn);
	1772	log_noise_filter_freq();
1735	1773	}
1736	1774	}
1737	1775	else
1738	1776	{
1739	1777	/* set the voltage on the cap */
1740		if (!sn->noise_filter_cap_voltage_ext || (data != sn->noise_filter_cap_voltage))
	1778	if (!m_noise_filter_cap_voltage_ext || (data != m_noise_filter_cap_voltage))
1741	1779	{
1742		sn->channel->update();
	1780	m_channel->update();
1743	1781
1744		sn->noise_filter_cap_voltage_ext = 1;
1745		sn->noise_filter_cap_voltage = data;
	1782	m_noise_filter_cap_voltage_ext = 1;
	1783	m_noise_filter_cap_voltage = data;
1746	1784
1747		log_noise_filter_freq(sn);
	1785	log_noise_filter_freq();
1748	1786	}
1749	1787	}
1750	1788	#endif
r26337	r26338
1758	1796	*
1759	1797	*****************************************************************************/
1760	1798
1761		static void _SN76477_attack_res_w(sn76477_state *sn, double data)
	1799	void sn76477_device::_SN76477_attack_res_w(double data)
1762	1800	{
1763		sn->attack_res = data;
	1801	m_attack_res = data;
1764	1802	}
1765	1803
1766	1804
1767		void sn76477_attack_res_w(device_t *device, double data)
	1805	void sn76477_device::attack_res_w(double data)
1768	1806	{
1769	1807	#if TEST_MODE == 0
1770		sn76477_state *sn = get_safe_token(device);
1771
1772	1808	CHECK_CHIP_NUM_AND_POSITIVE;
1773	1809
1774		if (data != sn->attack_res)
	1810	if (data != m_attack_res)
1775	1811	{
1776		sn->channel->update();
	1812	m_channel->update();
1777	1813
1778		_SN76477_attack_res_w(sn, data);
	1814	_SN76477_attack_res_w(data);
1779	1815
1780		log_attack_time(sn);
	1816	log_attack_time();
1781	1817	}
1782	1818	#endif
1783	1819	}
r26337	r26338
1790	1826	*
1791	1827	*****************************************************************************/
1792	1828
1793		static void _SN76477_decay_res_w(sn76477_state *sn, double data)
	1829	void sn76477_device::_SN76477_decay_res_w(double data)
1794	1830	{
1795		sn->decay_res = data;
	1831	m_decay_res = data;
1796	1832	}
1797	1833
1798	1834
1799		void sn76477_decay_res_w(device_t *device, double data)
	1835	void sn76477_device::decay_res_w(double data)
1800	1836	{
1801	1837	#if TEST_MODE == 0
1802		sn76477_state *sn = get_safe_token(device);
1803
1804	1838	CHECK_CHIP_NUM_AND_POSITIVE;
1805	1839
1806		if (data != sn->decay_res)
	1840	if (data != m_decay_res)
1807	1841	{
1808		sn->channel->update();
	1842	m_channel->update();
1809	1843
1810		_SN76477_decay_res_w(sn, data);
	1844	_SN76477_decay_res_w(data);
1811	1845
1812		log_decay_time(sn);
	1846	log_decay_time();
1813	1847	}
1814	1848	#endif
1815	1849	}
r26337	r26338
1822	1856	*
1823	1857	*****************************************************************************/
1824	1858
1825		static void _SN76477_attack_decay_cap_w(sn76477_state *sn, double data)
	1859	void sn76477_device::_SN76477_attack_decay_cap_w(double data)
1826	1860	{
1827		sn->attack_decay_cap = data;
	1861	m_attack_decay_cap = data;
1828	1862	}
1829	1863
1830	1864
1831		void sn76477_attack_decay_cap_w(device_t *device, double data)
	1865	void sn76477_device::attack_decay_cap_w(double data)
1832	1866	{
1833	1867	#if TEST_MODE == 0
1834		sn76477_state *sn = get_safe_token(device);
1835
1836	1868	CHECK_CHIP_NUM_AND_POSITIVE;
1837	1869
1838		if (data != sn->attack_decay_cap)
	1870	if (data != m_attack_decay_cap)
1839	1871	{
1840		sn->channel->update();
	1872	m_channel->update();
1841	1873
1842		_SN76477_attack_decay_cap_w(sn, data);
	1874	_SN76477_attack_decay_cap_w(data);
1843	1875
1844		log_attack_time(sn);
1845		log_decay_time(sn);
	1876	log_attack_time();
	1877	log_decay_time();
1846	1878	}
1847	1879	#endif
1848	1880	}
r26337	r26338
1855	1887	*
1856	1888	*****************************************************************************/
1857	1889
1858		void sn76477_attack_decay_cap_voltage_w(device_t *device, double data)
	1890	void sn76477_device::attack_decay_cap_voltage_w(double data)
1859	1891	{
1860	1892	#if TEST_MODE == 0
1861		sn76477_state *sn = get_safe_token(device);
1862
1863	1893	CHECK_CHIP_NUM_AND_CAP_VOLTAGE;
1864	1894
1865	1895	if (data == SN76477_EXTERNAL_VOLTAGE_DISCONNECT)
1866	1896	{
1867	1897	/* switch to internal, if not already */
1868		if (sn->attack_decay_cap_voltage_ext)
	1898	if (m_attack_decay_cap_voltage_ext)
1869	1899	{
1870		sn->channel->update();
	1900	m_channel->update();
1871	1901
1872		sn->attack_decay_cap_voltage_ext = 0;
	1902	m_attack_decay_cap_voltage_ext = 0;
1873	1903
1874		log_attack_time(sn);
1875		log_decay_time(sn);
	1904	log_attack_time();
	1905	log_decay_time();
1876	1906	}
1877	1907	}
1878	1908	else
1879	1909	{
1880	1910	/* set the voltage on the cap */
1881		if (!sn->attack_decay_cap_voltage_ext || (data != sn->attack_decay_cap_voltage))
	1911	if (!m_attack_decay_cap_voltage_ext || (data != m_attack_decay_cap_voltage))
1882	1912	{
1883		sn->channel->update();
	1913	m_channel->update();
1884	1914
1885		sn->attack_decay_cap_voltage_ext = 1;
1886		sn->attack_decay_cap_voltage = data;
	1915	m_attack_decay_cap_voltage_ext = 1;
	1916	m_attack_decay_cap_voltage = data;
1887	1917
1888		log_attack_time(sn);
1889		log_decay_time(sn);
	1918	log_attack_time();
	1919	log_decay_time();
1890	1920	}
1891	1921	}
1892	1922	#endif
r26337	r26338
1900	1930	*
1901	1931	*****************************************************************************/
1902	1932
1903		static void _SN76477_amplitude_res_w(sn76477_state *sn, double data)
	1933	void sn76477_device::_SN76477_amplitude_res_w(double data)
1904	1934	{
1905		sn->amplitude_res = data;
	1935	m_amplitude_res = data;
1906	1936	}
1907	1937
1908	1938
1909		void sn76477_amplitude_res_w(device_t *device, double data)
	1939	void sn76477_device::amplitude_res_w(double data)
1910	1940	{
1911	1941	#if TEST_MODE == 0
1912		sn76477_state *sn = get_safe_token(device);
1913
1914	1942	CHECK_CHIP_NUM_AND_POSITIVE;
1915	1943
1916		if (data != sn->amplitude_res)
	1944	if (data != m_amplitude_res)
1917	1945	{
1918		sn->channel->update();
	1946	m_channel->update();
1919	1947
1920		_SN76477_amplitude_res_w(sn, data);
	1948	_SN76477_amplitude_res_w(data);
1921	1949
1922		log_voltage_out(sn);
	1950	log_voltage_out();
1923	1951	}
1924	1952	#endif
1925	1953	}
r26337	r26338
1932	1960	*
1933	1961	*****************************************************************************/
1934	1962
1935		static void _SN76477_feedback_res_w(sn76477_state *sn, double data)
	1963	void sn76477_device::_SN76477_feedback_res_w(double data)
1936	1964	{
1937		sn->feedback_res = data;
	1965	m_feedback_res = data;
1938	1966	}
1939	1967
1940	1968
1941		void sn76477_feedback_res_w(device_t *device, double data)
	1969	void sn76477_device::feedback_res_w(double data)
1942	1970	{
1943	1971	#if TEST_MODE == 0
1944		sn76477_state *sn = get_safe_token(device);
1945
1946	1972	CHECK_CHIP_NUM_AND_POSITIVE;
1947	1973
1948		if (data != sn->feedback_res)
	1974	if (data != m_feedback_res)
1949	1975	{
1950		sn->channel->update();
	1976	m_channel->update();
1951	1977
1952		_SN76477_feedback_res_w(sn, data);
	1978	_SN76477_feedback_res_w(data);
1953	1979
1954		log_voltage_out(sn);
	1980	log_voltage_out();
1955	1981	}
1956	1982	#endif
1957	1983	}
1958	1984
1959	1985
1960
1961	1986	/*****************************************************************************
1962	1987	*
1963		*  Sample generation
	1988	*  State saving
1964	1989	*
1965	1990	*****************************************************************************/
1966	1991
1967		static STREAM_UPDATE( SN76477_update )
	1992	void sn76477_device::state_save_register()
1968	1993	{
	1994	save_item(NAME(m_enable));
	1995	save_item(NAME(m_envelope_mode));
	1996	save_item(NAME(m_vco_mode));
	1997	save_item(NAME(m_mixer_mode));
	1998
	1999	save_item(NAME(m_one_shot_res));
	2000	save_item(NAME(m_one_shot_cap));
	2001	save_item(NAME(m_one_shot_cap_voltage_ext));
	2002
	2003	save_item(NAME(m_slf_res));
	2004	save_item(NAME(m_slf_cap));
	2005	save_item(NAME(m_slf_cap_voltage_ext));
	2006
	2007	save_item(NAME(m_vco_voltage));
	2008	save_item(NAME(m_vco_res));
	2009	save_item(NAME(m_vco_cap));
	2010	save_item(NAME(m_vco_cap_voltage_ext));
	2011
	2012	save_item(NAME(m_noise_clock_res));
	2013	save_item(NAME(m_noise_clock_ext));
	2014	save_item(NAME(m_noise_clock));
	2015	save_item(NAME(m_noise_filter_res));
	2016	save_item(NAME(m_noise_filter_cap));
	2017	save_item(NAME(m_noise_filter_cap_voltage_ext));
	2018
	2019	save_item(NAME(m_attack_res));
	2020	save_item(NAME(m_decay_res));
	2021	save_item(NAME(m_attack_decay_cap));
	2022	save_item(NAME(m_attack_decay_cap_voltage_ext));
	2023
	2024	save_item(NAME(m_amplitude_res));
	2025	save_item(NAME(m_feedback_res));
	2026	save_item(NAME(m_pitch_voltage));
	2027
	2028	save_item(NAME(m_one_shot_cap_voltage));
	2029	save_item(NAME(m_one_shot_running_ff));
	2030
	2031	save_item(NAME(m_slf_cap_voltage));
	2032	save_item(NAME(m_slf_out_ff));
	2033
	2034	save_item(NAME(m_vco_cap_voltage));
	2035	save_item(NAME(m_vco_out_ff));
	2036	save_item(NAME(m_vco_alt_pos_edge_ff));
	2037
	2038	save_item(NAME(m_noise_filter_cap_voltage));
	2039	save_item(NAME(m_real_noise_bit_ff));
	2040	save_item(NAME(m_filtered_noise_bit_ff));
	2041	save_item(NAME(m_noise_gen_count));
	2042
	2043	save_item(NAME(m_attack_decay_cap_voltage));
	2044
	2045	save_item(NAME(m_rng));
	2046	}
	2047
	2048	//-------------------------------------------------
	2049	//  sound_stream_update - handle a stream update
	2050	//-------------------------------------------------
	2051
	2052	void sn76477_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
	2053	{
1969	2054	double one_shot_cap_charging_step;
1970	2055	double one_shot_cap_discharging_step;
1971	2056	double slf_cap_charging_step;
r26337	r26338
1983	2068	double voltage_out;
1984	2069	double center_to_peak_voltage_out;
1985	2070
1986		sn76477_state *sn = (sn76477_state *)param;
1987	2071	stream_sample_t *buffer = outputs[0];
1988	2072
1989	2073
1990	2074	#if TEST_MODE
1991		static int recursing = 0;   /* we need to prevent recursion since enable_w calls device->machine().input().code_pressed_once(KEYCODE_SPACE->update */
	2075	static int recursing = 0;   /* we need to prevent recursion since enable_w calls machine().input().code_pressed_once(KEYCODE_SPACE->update */
1992	2076
1993	2077	if () && !recursing)
1994	2078	{
1995	2079	recursing = 1;
1996	2080
1997		device->machine().sound().system_enable();
1998		SN76477_test_enable_w(sn, !sn->enable);
	2081	machine().sound().system_enable();
	2082	SN76477_test_enable_w(!m_enable);
1999	2083	}
2000	2084
2001	2085	recursing = 0;
2002	2086	#endif
2003	2087
2004	2088	/* compute charging values, doing it here ensures that we always use the latest values */
2005		one_shot_cap_charging_step = compute_one_shot_cap_charging_rate(sn) / sn->sample_rate;
2006		one_shot_cap_discharging_step = compute_one_shot_cap_discharging_rate(sn) / sn->sample_rate;
	2089	one_shot_cap_charging_step = compute_one_shot_cap_charging_rate() / m_our_sample_rate;
	2090	one_shot_cap_discharging_step = compute_one_shot_cap_discharging_rate() / m_our_sample_rate;
2007	2091
2008		slf_cap_charging_step = compute_slf_cap_charging_rate(sn) / sn->sample_rate;
2009		slf_cap_discharging_step = compute_slf_cap_discharging_rate(sn) / sn->sample_rate;
	2092	slf_cap_charging_step = compute_slf_cap_charging_rate() / m_our_sample_rate;
	2093	slf_cap_discharging_step = compute_slf_cap_discharging_rate() / m_our_sample_rate;
2010	2094
2011		vco_duty_cycle_multiplier = (1 - compute_vco_duty_cycle(sn)) * 2;
2012		vco_cap_charging_step = compute_vco_cap_charging_discharging_rate(sn) / vco_duty_cycle_multiplier / sn->sample_rate;
2013		vco_cap_discharging_step = compute_vco_cap_charging_discharging_rate(sn) * vco_duty_cycle_multiplier / sn->sample_rate;
	2095	vco_duty_cycle_multiplier = (1 - compute_vco_duty_cycle()) * 2;
	2096	vco_cap_charging_step = compute_vco_cap_charging_discharging_rate() / vco_duty_cycle_multiplier / m_our_sample_rate;
	2097	vco_cap_discharging_step = compute_vco_cap_charging_discharging_rate() * vco_duty_cycle_multiplier / m_our_sample_rate;
2014	2098
2015		noise_filter_cap_charging_step = compute_noise_filter_cap_charging_rate(sn) / sn->sample_rate;
2016		noise_filter_cap_discharging_step = compute_noise_filter_cap_discharging_rate(sn) / sn->sample_rate;
2017		noise_gen_freq = compute_noise_gen_freq(sn);
	2099	noise_filter_cap_charging_step = compute_noise_filter_cap_charging_rate() / m_our_sample_rate;
	2100	noise_filter_cap_discharging_step = compute_noise_filter_cap_discharging_rate() / m_our_sample_rate;
	2101	noise_gen_freq = compute_noise_gen_freq();
2018	2102
2019		attack_decay_cap_charging_step = compute_attack_decay_cap_charging_rate(sn) / sn->sample_rate;
2020		attack_decay_cap_discharging_step = compute_attack_decay_cap_discharging_rate(sn) / sn->sample_rate;
	2103	attack_decay_cap_charging_step = compute_attack_decay_cap_charging_rate() / m_our_sample_rate;
	2104	attack_decay_cap_discharging_step = compute_attack_decay_cap_discharging_rate() / m_our_sample_rate;
2021	2105
2022		center_to_peak_voltage_out = compute_center_to_peak_voltage_out(sn);
	2106	center_to_peak_voltage_out = compute_center_to_peak_voltage_out();
2023	2107
2024	2108
2025	2109	/* process 'samples' number of samples */
2026	2110	while (samples--)
2027	2111	{
2028	2112	/* update the one-shot cap voltage */
2029		if (!sn->one_shot_cap_voltage_ext)
	2113	if (!m_one_shot_cap_voltage_ext)
2030	2114	{
2031		if (sn->one_shot_running_ff)
	2115	if (m_one_shot_running_ff)
2032	2116	{
2033	2117	/* charging */
2034		sn->one_shot_cap_voltage = min(sn->one_shot_cap_voltage + one_shot_cap_charging_step, ONE_SHOT_CAP_VOLTAGE_MAX);
	2118	m_one_shot_cap_voltage = min(m_one_shot_cap_voltage + one_shot_cap_charging_step, ONE_SHOT_CAP_VOLTAGE_MAX);
2035	2119	}
2036	2120	else
2037	2121	{
2038	2122	/* discharging */
2039		sn->one_shot_cap_voltage = max(sn->one_shot_cap_voltage - one_shot_cap_discharging_step, ONE_SHOT_CAP_VOLTAGE_MIN);
	2123	m_one_shot_cap_voltage = max(m_one_shot_cap_voltage - one_shot_cap_discharging_step, ONE_SHOT_CAP_VOLTAGE_MIN);
2040	2124	}
2041	2125	}
2042	2126
2043		if (sn->one_shot_cap_voltage >= ONE_SHOT_CAP_VOLTAGE_MAX)
	2127	if (m_one_shot_cap_voltage >= ONE_SHOT_CAP_VOLTAGE_MAX)
2044	2128	{
2045		sn->one_shot_running_ff = 0;
	2129	m_one_shot_running_ff = 0;
2046	2130	}
2047	2131
2048	2132
2049	2133	/* update the SLF (super low frequency oscillator) */
2050		if (!sn->slf_cap_voltage_ext)
	2134	if (!m_slf_cap_voltage_ext)
2051	2135	{
2052	2136	/* internal */
2053		if (!sn->slf_out_ff)
	2137	if (!m_slf_out_ff)
2054	2138	{
2055	2139	/* charging */
2056		sn->slf_cap_voltage = min(sn->slf_cap_voltage + slf_cap_charging_step, SLF_CAP_VOLTAGE_MAX);
	2140	m_slf_cap_voltage = min(m_slf_cap_voltage + slf_cap_charging_step, SLF_CAP_VOLTAGE_MAX);
2057	2141	}
2058	2142	else
2059	2143	{
2060	2144	/* discharging */
2061		sn->slf_cap_voltage = max(sn->slf_cap_voltage - slf_cap_discharging_step, SLF_CAP_VOLTAGE_MIN);
	2145	m_slf_cap_voltage = max(m_slf_cap_voltage - slf_cap_discharging_step, SLF_CAP_VOLTAGE_MIN);
2062	2146	}
2063	2147	}
2064	2148
2065		if (sn->slf_cap_voltage >= SLF_CAP_VOLTAGE_MAX)
	2149	if (m_slf_cap_voltage >= SLF_CAP_VOLTAGE_MAX)
2066	2150	{
2067		sn->slf_out_ff = 1;
	2151	m_slf_out_ff = 1;
2068	2152	}
2069		else if (sn->slf_cap_voltage <= SLF_CAP_VOLTAGE_MIN)
	2153	else if (m_slf_cap_voltage <= SLF_CAP_VOLTAGE_MIN)
2070	2154	{
2071		sn->slf_out_ff = 0;
	2155	m_slf_out_ff = 0;
2072	2156	}
2073	2157
2074	2158
2075	2159	/* update the VCO (voltage controlled oscillator) */
2076		if (sn->vco_mode)
	2160	if (m_vco_mode)
2077	2161	{
2078	2162	/* VCO is controlled by SLF */
2079		vco_cap_voltage_max =  sn->slf_cap_voltage + VCO_TO_SLF_VOLTAGE_DIFF;
	2163	vco_cap_voltage_max =  m_slf_cap_voltage + VCO_TO_SLF_VOLTAGE_DIFF;
2080	2164	}
2081	2165	else
2082	2166	{
2083	2167	/* VCO is controlled by external voltage */
2084		vco_cap_voltage_max = sn->vco_voltage + VCO_TO_SLF_VOLTAGE_DIFF;
	2168	vco_cap_voltage_max = m_vco_voltage + VCO_TO_SLF_VOLTAGE_DIFF;
2085	2169	}
2086	2170
2087		if (!sn->vco_cap_voltage_ext)
	2171	if (!m_vco_cap_voltage_ext)
2088	2172	{
2089		if (!sn->vco_out_ff)
	2173	if (!m_vco_out_ff)
2090	2174	{
2091	2175	/* charging */
2092		sn->vco_cap_voltage = min(sn->vco_cap_voltage + vco_cap_charging_step, vco_cap_voltage_max);
	2176	m_vco_cap_voltage = min(m_vco_cap_voltage + vco_cap_charging_step, vco_cap_voltage_max);
2093	2177	}
2094	2178	else
2095	2179	{
2096	2180	/* discharging */
2097		sn->vco_cap_voltage = max(sn->vco_cap_voltage - vco_cap_discharging_step, VCO_CAP_VOLTAGE_MIN);
	2181	m_vco_cap_voltage = max(m_vco_cap_voltage - vco_cap_discharging_step, VCO_CAP_VOLTAGE_MIN);
2098	2182	}
2099	2183	}
2100	2184
2101		if (sn->vco_cap_voltage >= vco_cap_voltage_max)
	2185	if (m_vco_cap_voltage >= vco_cap_voltage_max)
2102	2186	{
2103		if (!sn->vco_out_ff)
	2187	if (!m_vco_out_ff)
2104	2188	{
2105	2189	/* positive edge */
2106		sn->vco_alt_pos_edge_ff = !sn->vco_alt_pos_edge_ff;
	2190	m_vco_alt_pos_edge_ff = !m_vco_alt_pos_edge_ff;
2107	2191	}
2108	2192
2109		sn->vco_out_ff = 1;
	2193	m_vco_out_ff = 1;
2110	2194	}
2111		else if (sn->vco_cap_voltage <= VCO_CAP_VOLTAGE_MIN)
	2195	else if (m_vco_cap_voltage <= VCO_CAP_VOLTAGE_MIN)
2112	2196	{
2113		sn->vco_out_ff = 0;
	2197	m_vco_out_ff = 0;
2114	2198	}
2115	2199
2116	2200
2117	2201	/* update the noise generator */
2118		while (!sn->noise_clock_ext && (sn->noise_gen_count <= noise_gen_freq))
	2202	while (!m_noise_clock_ext && (m_noise_gen_count <= noise_gen_freq))
2119	2203	{
2120		sn->noise_gen_count = sn->noise_gen_count + sn->sample_rate;
	2204	m_noise_gen_count = m_noise_gen_count + m_our_sample_rate;
2121	2205
2122		sn->real_noise_bit_ff = generate_next_real_noise_bit(sn);
	2206	m_real_noise_bit_ff = generate_next_real_noise_bit();
2123	2207	}
2124	2208
2125		sn->noise_gen_count = sn->noise_gen_count - noise_gen_freq;
	2209	m_noise_gen_count = m_noise_gen_count - noise_gen_freq;
2126	2210
2127	2211
2128	2212	/* update the noise filter */
2129		if (!sn->noise_filter_cap_voltage_ext)
	2213	if (!m_noise_filter_cap_voltage_ext)
2130	2214	{
2131	2215	/* internal */
2132		if (sn->real_noise_bit_ff)
	2216	if (m_real_noise_bit_ff)
2133	2217	{
2134	2218	/* charging */
2135		sn->noise_filter_cap_voltage = min(sn->noise_filter_cap_voltage + noise_filter_cap_charging_step, NOISE_CAP_VOLTAGE_MAX);
	2219	m_noise_filter_cap_voltage = min(m_noise_filter_cap_voltage + noise_filter_cap_charging_step, NOISE_CAP_VOLTAGE_MAX);
2136	2220	}
2137	2221	else
2138	2222	{
2139	2223	/* discharging */
2140		sn->noise_filter_cap_voltage = max(sn->noise_filter_cap_voltage - noise_filter_cap_discharging_step, NOISE_CAP_VOLTAGE_MIN);
	2224	m_noise_filter_cap_voltage = max(m_noise_filter_cap_voltage - noise_filter_cap_discharging_step, NOISE_CAP_VOLTAGE_MIN);
2141	2225	}
2142	2226	}
2143	2227
2144	2228	/* check the thresholds */
2145		if (sn->noise_filter_cap_voltage >= NOISE_CAP_HIGH_THRESHOLD)
	2229	if (m_noise_filter_cap_voltage >= NOISE_CAP_HIGH_THRESHOLD)
2146	2230	{
2147		sn->filtered_noise_bit_ff = 0;
	2231	m_filtered_noise_bit_ff = 0;
2148	2232	}
2149		else if (sn->noise_filter_cap_voltage <= NOISE_CAP_LOW_THRESHOLD)
	2233	else if (m_noise_filter_cap_voltage <= NOISE_CAP_LOW_THRESHOLD)
2150	2234	{
2151		sn->filtered_noise_bit_ff = 1;
	2235	m_filtered_noise_bit_ff = 1;
2152	2236	}
2153	2237
2154	2238
2155	2239	/* based on the envelope mode figure out the attack/decay phase we are in */
2156		switch (sn->envelope_mode)
	2240	switch (m_envelope_mode)
2157	2241	{
2158	2242	case 0:     /* VCO */
2159		attack_decay_cap_charging = sn->vco_out_ff;
	2243	attack_decay_cap_charging = m_vco_out_ff;
2160	2244	break;
2161	2245
2162	2246	case 1:     /* one-shot */
2163		attack_decay_cap_charging = sn->one_shot_running_ff;
	2247	attack_decay_cap_charging = m_one_shot_running_ff;
2164	2248	break;
2165	2249
2166	2250	case 2:
r26337	r26338
2169	2253	break;
2170	2254
2171	2255	case 3:     /* VCO with alternating polarity */
2172		attack_decay_cap_charging = sn->vco_out_ff && sn->vco_alt_pos_edge_ff;
	2256	attack_decay_cap_charging = m_vco_out_ff && m_vco_alt_pos_edge_ff;
2173	2257	break;
2174	2258	}
2175	2259
2176	2260
2177	2261	/* update a/d cap voltage */
2178		if (!sn->attack_decay_cap_voltage_ext)
	2262	if (!m_attack_decay_cap_voltage_ext)
2179	2263	{
2180	2264	if (attack_decay_cap_charging)
2181	2265	{
2182	2266	if (attack_decay_cap_charging_step > 0)
2183	2267	{
2184		sn->attack_decay_cap_voltage = min(sn->attack_decay_cap_voltage + attack_decay_cap_charging_step, AD_CAP_VOLTAGE_MAX);
	2268	m_attack_decay_cap_voltage = min(m_attack_decay_cap_voltage + attack_decay_cap_charging_step, AD_CAP_VOLTAGE_MAX);
2185	2269	}
2186	2270	else
2187	2271	{
2188	2272	/* no attack, voltage to max instantly */
2189		sn->attack_decay_cap_voltage = AD_CAP_VOLTAGE_MAX;
	2273	m_attack_decay_cap_voltage = AD_CAP_VOLTAGE_MAX;
2190	2274	}
2191	2275	}
2192	2276	else
r26337	r26338
2194	2278	/* discharging */
2195	2279	if (attack_decay_cap_discharging_step > 0)
2196	2280	{
2197		sn->attack_decay_cap_voltage = max(sn->attack_decay_cap_voltage - attack_decay_cap_discharging_step, AD_CAP_VOLTAGE_MIN);
	2281	m_attack_decay_cap_voltage = max(m_attack_decay_cap_voltage - attack_decay_cap_discharging_step, AD_CAP_VOLTAGE_MIN);
2198	2282	}
2199	2283	else
2200	2284	{
2201	2285	/* no decay, voltage to min instantly */
2202		sn->attack_decay_cap_voltage = AD_CAP_VOLTAGE_MIN;
	2286	m_attack_decay_cap_voltage = AD_CAP_VOLTAGE_MIN;
2203	2287	}
2204	2288	}
2205	2289	}
2206	2290
2207	2291
2208	2292	/* mix the output, if enabled, or not saturated by the VCO */
2209		if (!sn->enable && (sn->vco_cap_voltage <= VCO_CAP_VOLTAGE_MAX))
	2293	if (!m_enable && (m_vco_cap_voltage <= VCO_CAP_VOLTAGE_MAX))
2210	2294	{
2211	2295	UINT32 out;
2212	2296
2213	2297	/* enabled */
2214		switch (sn->mixer_mode)
	2298	switch (m_mixer_mode)
2215	2299	{
2216	2300	case 0:     /* VCO */
2217		out = sn->vco_out_ff;
	2301	out = m_vco_out_ff;
2218	2302	break;
2219	2303
2220	2304	case 1:     /* SLF */
2221		out = sn->slf_out_ff;
	2305	out = m_slf_out_ff;
2222	2306	break;
2223	2307
2224	2308	case 2:     /* noise */
2225		out = sn->filtered_noise_bit_ff;
	2309	out = m_filtered_noise_bit_ff;
2226	2310	break;
2227	2311
2228	2312	case 3:     /* VCO and noise */
2229		out = sn->vco_out_ff & sn->filtered_noise_bit_ff;
	2313	out = m_vco_out_ff & m_filtered_noise_bit_ff;
2230	2314	break;
2231	2315
2232	2316	case 4:     /* SLF and noise */
2233		out = sn->slf_out_ff & sn->filtered_noise_bit_ff;
	2317	out = m_slf_out_ff & m_filtered_noise_bit_ff;
2234	2318	break;
2235	2319
2236	2320	case 5:     /* VCO, SLF and noise */
2237		out = sn->vco_out_ff & sn->slf_out_ff & sn->filtered_noise_bit_ff;
	2321	out = m_vco_out_ff & m_slf_out_ff & m_filtered_noise_bit_ff;
2238	2322	break;
2239	2323
2240	2324	case 6:     /* VCO and SLF */
2241		out = sn->vco_out_ff & sn->slf_out_ff;
	2325	out = m_vco_out_ff & m_slf_out_ff;
2242	2326	break;
2243	2327
2244	2328	case 7:     /* inhibit */
r26337	r26338
2250	2334	/* determine the OUT voltage from the attack/delay cap voltage and clip it */
2251	2335	if (out)
2252	2336	{
2253		voltage_out = OUT_CENTER_LEVEL_VOLTAGE + center_to_peak_voltage_out * out_pos_gain[(int)(sn->attack_decay_cap_voltage * 10)],
	2337	voltage_out = OUT_CENTER_LEVEL_VOLTAGE + center_to_peak_voltage_out * out_pos_gain[(int)(m_attack_decay_cap_voltage * 10)],
2254	2338	voltage_out = min(voltage_out, OUT_HIGH_CLIP_THRESHOLD);
2255	2339	}
2256	2340	else
2257	2341	{
2258		voltage_out = OUT_CENTER_LEVEL_VOLTAGE + center_to_peak_voltage_out * out_neg_gain[(int)(sn->attack_decay_cap_voltage * 10)],
	2342	voltage_out = OUT_CENTER_LEVEL_VOLTAGE + center_to_peak_voltage_out * out_neg_gain[(int)(m_attack_decay_cap_voltage * 10)],
2259	2343	voltage_out = max(voltage_out, OUT_LOW_CLIP_THRESHOLD);
2260	2344	}
2261	2345	}
r26337	r26338
2277	2361	*/
2278	2362	*buffer++ = (((voltage_out - OUT_LOW_CLIP_THRESHOLD) / (OUT_CENTER_LEVEL_VOLTAGE - OUT_LOW_CLIP_THRESHOLD)) - 1) * 32767;
2279	2363
2280		if (LOG_WAV && LOG_WAV_ENABLED_ONLY && !sn->enable)
	2364	if (LOG_WAV && LOG_WAV_ENABLED_ONLY && !m_enable)
2281	2365	{
2282	2366	INT16 log_data_l;
2283	2367	INT16 log_data_r;
r26337	r26338
2289	2373	log_data_r = LOG_WAV_GAIN_FACTOR * voltage_out;
2290	2374	break;
2291	2375	case 1:
2292		log_data_l = LOG_WAV_GAIN_FACTOR * sn->enable;
2293		log_data_r = LOG_WAV_GAIN_FACTOR * sn->enable;
	2376	log_data_l = LOG_WAV_GAIN_FACTOR * m_enable;
	2377	log_data_r = LOG_WAV_GAIN_FACTOR * m_enable;
2294	2378	break;
2295	2379	case 2:
2296		log_data_l = LOG_WAV_GAIN_FACTOR * sn->one_shot_cap_voltage;
2297		log_data_r = LOG_WAV_GAIN_FACTOR * sn->one_shot_cap_voltage;
	2380	log_data_l = LOG_WAV_GAIN_FACTOR * m_one_shot_cap_voltage;
	2381	log_data_r = LOG_WAV_GAIN_FACTOR * m_one_shot_cap_voltage;
2298	2382	break;
2299	2383	case 3:
2300		log_data_l = LOG_WAV_GAIN_FACTOR * sn->attack_decay_cap_voltage;
2301		log_data_r = LOG_WAV_GAIN_FACTOR * sn->attack_decay_cap_voltage;
	2384	log_data_l = LOG_WAV_GAIN_FACTOR * m_attack_decay_cap_voltage;
	2385	log_data_r = LOG_WAV_GAIN_FACTOR * m_attack_decay_cap_voltage;
2302	2386	break;
2303	2387	case 4:
2304		log_data_l = LOG_WAV_GAIN_FACTOR * sn->slf_cap_voltage;
2305		log_data_r = LOG_WAV_GAIN_FACTOR * sn->slf_cap_voltage;
	2388	log_data_l = LOG_WAV_GAIN_FACTOR * m_slf_cap_voltage;
	2389	log_data_r = LOG_WAV_GAIN_FACTOR * m_slf_cap_voltage;
2306	2390	break;
2307	2391	case 5:
2308		log_data_l = LOG_WAV_GAIN_FACTOR * sn->vco_cap_voltage;
2309		log_data_r = LOG_WAV_GAIN_FACTOR * sn->vco_cap_voltage;
	2392	log_data_l = LOG_WAV_GAIN_FACTOR * m_vco_cap_voltage;
	2393	log_data_r = LOG_WAV_GAIN_FACTOR * m_vco_cap_voltage;
2310	2394	break;
2311	2395	case 6:
2312		log_data_l = LOG_WAV_GAIN_FACTOR * sn->noise_filter_cap_voltage;
2313		log_data_r = LOG_WAV_GAIN_FACTOR * sn->noise_filter_cap_voltage;
	2396	log_data_l = LOG_WAV_GAIN_FACTOR * m_noise_filter_cap_voltage;
	2397	log_data_r = LOG_WAV_GAIN_FACTOR * m_noise_filter_cap_voltage;
2314	2398	break;
2315	2399	}
2316	2400
2317		add_wav_data(sn, log_data_l, log_data_r);
	2401	add_wav_data(log_data_l, log_data_r);
2318	2402	}
2319	2403	}
2320	2404	}
2321
2322
2323
2324		/*****************************************************************************
2325		*
2326		*  State saving
2327		*
2328		*****************************************************************************/
2329
2330		static void state_save_register(device_t *device, sn76477_state *sn)
2331		{
2332		device->save_item(NAME(sn->enable));
2333		device->save_item(NAME(sn->envelope_mode));
2334		device->save_item(NAME(sn->vco_mode));
2335		device->save_item(NAME(sn->mixer_mode));
2336
2337		device->save_item(NAME(sn->one_shot_res));
2338		device->save_item(NAME(sn->one_shot_cap));
2339		device->save_item(NAME(sn->one_shot_cap_voltage_ext));
2340
2341		device->save_item(NAME(sn->slf_res));
2342		device->save_item(NAME(sn->slf_cap));
2343		device->save_item(NAME(sn->slf_cap_voltage_ext));
2344
2345		device->save_item(NAME(sn->vco_voltage));
2346		device->save_item(NAME(sn->vco_res));
2347		device->save_item(NAME(sn->vco_cap));
2348		device->save_item(NAME(sn->vco_cap_voltage_ext));
2349
2350		device->save_item(NAME(sn->noise_clock_res));
2351		device->save_item(NAME(sn->noise_clock_ext));
2352		device->save_item(NAME(sn->noise_clock));
2353		device->save_item(NAME(sn->noise_filter_res));
2354		device->save_item(NAME(sn->noise_filter_cap));
2355		device->save_item(NAME(sn->noise_filter_cap_voltage_ext));
2356
2357		device->save_item(NAME(sn->attack_res));
2358		device->save_item(NAME(sn->decay_res));
2359		device->save_item(NAME(sn->attack_decay_cap));
2360		device->save_item(NAME(sn->attack_decay_cap_voltage_ext));
2361
2362		device->save_item(NAME(sn->amplitude_res));
2363		device->save_item(NAME(sn->feedback_res));
2364		device->save_item(NAME(sn->pitch_voltage));
2365
2366		device->save_item(NAME(sn->one_shot_cap_voltage));
2367		device->save_item(NAME(sn->one_shot_running_ff));
2368
2369		device->save_item(NAME(sn->slf_cap_voltage));
2370		device->save_item(NAME(sn->slf_out_ff));
2371
2372		device->save_item(NAME(sn->vco_cap_voltage));
2373		device->save_item(NAME(sn->vco_out_ff));
2374		device->save_item(NAME(sn->vco_alt_pos_edge_ff));
2375
2376		device->save_item(NAME(sn->noise_filter_cap_voltage));
2377		device->save_item(NAME(sn->real_noise_bit_ff));
2378		device->save_item(NAME(sn->filtered_noise_bit_ff));
2379		device->save_item(NAME(sn->noise_gen_count));
2380
2381		device->save_item(NAME(sn->attack_decay_cap_voltage));
2382
2383		device->save_item(NAME(sn->rng));
2384		}
2385
2386
2387
2388		/*****************************************************************************
2389		*
2390		*  Sound interface glue functions
2391		*
2392		*****************************************************************************/
2393
2394		static DEVICE_START( sn76477 )
2395		{
2396		sn76477_state *sn = get_safe_token(device);
2397		sn76477_interface *intf;
2398
2399
2400		#if TEST_MODE == 0
2401		intf = (sn76477_interface *)device->static_config();
2402		#else
2403		intf = &test_interface;
2404		#endif
2405
2406
2407		sn->device = device;
2408
2409		sn->channel = device->machine().sound().stream_alloc(*device, 0, 1, device->machine().sample_rate(), sn, SN76477_update);
2410
2411		if (device->clock() > 0)
2412		{
2413		sn->sample_rate = device->clock();
2414		}
2415		else
2416		{
2417		sn->sample_rate = device->machine().sample_rate();
2418		}
2419
2420		intialize_noise(sn);
2421
2422		/* set up interface values */
2423		_SN76477_enable_w(sn, intf->enable);
2424		_SN76477_vco_w(sn, intf->vco);
2425		_SN76477_mixer_a_w(sn, intf->mixer_a);
2426		_SN76477_mixer_b_w(sn, intf->mixer_b);
2427		_SN76477_mixer_c_w(sn, intf->mixer_c);
2428		_SN76477_envelope_1_w(sn, intf->envelope_1);
2429		_SN76477_envelope_2_w(sn, intf->envelope_2);
2430		_SN76477_one_shot_res_w(sn, intf->one_shot_res);
2431		_SN76477_one_shot_cap_w(sn, intf->one_shot_cap);
2432		_SN76477_slf_res_w(sn, intf->slf_res);
2433		_SN76477_slf_cap_w(sn, intf->slf_cap);
2434		_SN76477_vco_res_w(sn, intf->vco_res);
2435		_SN76477_vco_cap_w(sn, intf->vco_cap);
2436		_SN76477_vco_voltage_w(sn, intf->vco_voltage);
2437		_SN76477_noise_clock_res_w(sn, intf->noise_clock_res);
2438		_SN76477_noise_filter_res_w(sn, intf->noise_filter_res);
2439		_SN76477_noise_filter_cap_w(sn, intf->noise_filter_cap);
2440		_SN76477_decay_res_w(sn, intf->decay_res);
2441		_SN76477_attack_res_w(sn, intf->attack_res);
2442		_SN76477_attack_decay_cap_w(sn, intf->attack_decay_cap);
2443		_SN76477_amplitude_res_w(sn, intf->amplitude_res);
2444		_SN76477_feedback_res_w(sn, intf->feedback_res);
2445		_SN76477_pitch_voltage_w(sn, intf->pitch_voltage);
2446
2447		sn->one_shot_cap_voltage = ONE_SHOT_CAP_VOLTAGE_MIN;
2448		sn->slf_cap_voltage = SLF_CAP_VOLTAGE_MIN;
2449		sn->vco_cap_voltage = VCO_CAP_VOLTAGE_MIN;
2450		sn->noise_filter_cap_voltage = NOISE_CAP_VOLTAGE_MIN;
2451		sn->attack_decay_cap_voltage = AD_CAP_VOLTAGE_MIN;
2452
2453		state_save_register(device, sn);
2454
2455		log_complete_state(sn);
2456
2457		if (LOG_WAV)
2458		open_wav_file(sn);
2459		}
2460
2461
2462		static DEVICE_STOP( sn76477 )
2463		{
2464		sn76477_state *sn = get_safe_token(device);
2465
2466		if (LOG_WAV)
2467		close_wav_file(sn);
2468		}
2469
2470		const device_type SN76477 = &device_creator<sn76477_device>;
2471
2472		sn76477_device::sn76477_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2473		: device_t(mconfig, SN76477, "SN76477", tag, owner, clock, "sn76477", __FILE__),
2474		device_sound_interface(mconfig, *this)
2475		{
2476		m_token = global_alloc_clear(sn76477_state);
2477		}
2478
2479		//-------------------------------------------------
2480		//  device_config_complete - perform any
2481		//  operations now that the configuration is
2482		//  complete
2483		//-------------------------------------------------
2484
2485		void sn76477_device::device_config_complete()
2486		{
2487		}
2488
2489		//-------------------------------------------------
2490		//  device_start - device-specific startup
2491		//-------------------------------------------------
2492
2493		void sn76477_device::device_start()
2494		{
2495		DEVICE_START_NAME( sn76477 )(this);
2496		}
2497
2498		//-------------------------------------------------
2499		//  device_stop - device-specific stop
2500		//-------------------------------------------------
2501
2502		void sn76477_device::device_stop()
2503		{
2504		DEVICE_STOP_NAME( sn76477 )(this);
2505		}
2506
2507		//-------------------------------------------------
2508		//  sound_stream_update - handle a stream update
2509		//-------------------------------------------------
2510
2511		void sn76477_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
2512		{
2513		// should never get here
2514		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
2515		}

trunk/src/emu/sound/sn76477.h

r26337	r26338
50	50
51	51	struct sn76477_interface
52	52	{
53		double noise_clock_res;
54		double noise_filter_res;
55		double noise_filter_cap;
56		double decay_res;
57		double attack_decay_cap;
58		double attack_res;
59		double amplitude_res;
60		double feedback_res;
61		double vco_voltage;
62		double vco_cap;
63		double vco_res;
64		double pitch_voltage;
65		double slf_res;
66		double slf_cap;
67		double one_shot_cap;
68		double one_shot_res;
69		UINT32 vco;
70		UINT32 mixer_a;
71		UINT32 mixer_b;
72		UINT32 mixer_c;
73		UINT32 envelope_1;
74		UINT32 envelope_2;
75		UINT32 enable;
	53	double m_intf_noise_clock_res;
	54	double m_intf_noise_filter_res;
	55	double m_intf_noise_filter_cap;
	56	double m_intf_decay_res;
	57	double m_intf_attack_decay_cap;
	58	double m_intf_attack_res;
	59	double m_intf_amplitude_res;
	60	double m_intf_feedback_res;
	61	double m_intf_vco_voltage;
	62	double m_intf_vco_cap;
	63	double m_intf_vco_res;
	64	double m_intf_pitch_voltage;
	65	double m_intf_slf_res;
	66	double m_intf_slf_cap;
	67	double m_intf_one_shot_cap;
	68	double m_intf_one_shot_res;
	69	UINT32 m_intf_vco;
	70	UINT32 m_intf_mixer_a;
	71	UINT32 m_intf_mixer_b;
	72	UINT32 m_intf_mixer_c;
	73	UINT32 m_intf_envelope_1;
	74	UINT32 m_intf_envelope_2;
	75	UINT32 m_intf_enable;
76	76	};
77	77
78
79
80		/*****************************************************************************
81		*
82		*  Functions to set a pin's value
83		*
84		*****************************************************************************/
85
86		/* these functions take 0 or 1 as a logic input */
87		WRITE_LINE_DEVICE_HANDLER( sn76477_enable_w );      /* active LO, 0 = enabled, 1 = disabled */
88		WRITE_LINE_DEVICE_HANDLER( sn76477_mixer_a_w );
89		WRITE_LINE_DEVICE_HANDLER( sn76477_mixer_b_w );
90		WRITE_LINE_DEVICE_HANDLER( sn76477_mixer_c_w );
91		WRITE_LINE_DEVICE_HANDLER( sn76477_envelope_1_w );
92		WRITE_LINE_DEVICE_HANDLER( sn76477_envelope_2_w );
93		WRITE_LINE_DEVICE_HANDLER( sn76477_vco_w );         /* 0 = external, 1 = controlled by SLF */
94		WRITE_LINE_DEVICE_HANDLER( sn76477_noise_clock_w ); /* noise clock write, if noise_clock_res = 0 */
95
96		/* these functions take a resistor value in Ohms */
97		void sn76477_one_shot_res_w(device_t *device, double data);
98		void sn76477_slf_res_w(device_t *device, double data);
99		void sn76477_vco_res_w(device_t *device, double data);
100		void sn76477_noise_clock_res_w(device_t *device, double data);  /* = 0 if the noise gen is clocked via noise_clock */
101		void sn76477_noise_filter_res_w(device_t *device, double data);
102		void sn76477_decay_res_w(device_t *device, double data);
103		void sn76477_attack_res_w(device_t *device, double data);
104		void sn76477_amplitude_res_w(device_t *device, double data);
105		void sn76477_feedback_res_w(device_t *device, double data);
106
107		/* these functions take a capacitor value in Farads or the voltage on it in Volts */
108		#define SN76477_EXTERNAL_VOLTAGE_DISCONNECT   (-1.0)    /* indicates that the voltage is internally computed,
109		can be used in all the functions that take a
110		voltage on a capacitor */
111		void sn76477_one_shot_cap_w(device_t *device, double data);
112		void sn76477_one_shot_cap_voltage_w(device_t *device, double data);
113		void sn76477_slf_cap_w(device_t *device, double data);
114		void sn76477_slf_cap_voltage_w(device_t *device, double data);
115		void sn76477_vco_cap_w(device_t *device, double data);
116		void sn76477_vco_cap_voltage_w(device_t *device, double data);
117		void sn76477_noise_filter_cap_w(device_t *device, double data);
118		void sn76477_noise_filter_cap_voltage_w(device_t *device, double data);
119		void sn76477_attack_decay_cap_w(device_t *device, double data);
120		void sn76477_attack_decay_cap_voltage_w(device_t *device, double data);
121
122		/* these functions take a voltage value in Volts */
123		void sn76477_vco_voltage_w(device_t *device, double data);
124		void sn76477_pitch_voltage_w(device_t *device, double data);
125
126	78	class sn76477_device : public device_t,
127		public device_sound_interface
	79	public device_sound_interface,
	80	public sn76477_interface
128	81	{
129	82	public:
130	83	sn76477_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
131		~sn76477_device() { global_free(m_token); }
	84	~sn76477_device() {}
	85
	86	/* these functions take 0 or 1 as a logic input */
	87	WRITE_LINE_MEMBER( enable_w );      /* active LO, 0 = enabled, 1 = disabled */
	88	WRITE_LINE_MEMBER( mixer_a_w );
	89	WRITE_LINE_MEMBER( mixer_b_w );
	90	WRITE_LINE_MEMBER( mixer_c_w );
	91	WRITE_LINE_MEMBER( envelope_1_w );
	92	WRITE_LINE_MEMBER( envelope_2_w );
	93	WRITE_LINE_MEMBER( vco_w );         /* 0 = external, 1 = controlled by SLF */
	94	WRITE_LINE_MEMBER( noise_clock_w ); /* noise clock write, if noise_clock_res = 0 */
132	95
133		// access to legacy token
134		void *token() const { assert(m_token != NULL); return m_token; }
	96	/* these functions take a resistor value in Ohms */
	97	void one_shot_res_w(double data);
	98	void slf_res_w(double data);
	99	void vco_res_w(double data);
	100	void noise_clock_res_w(double data);  /* = 0 if the noise gen is clocked via noise_clock */
	101	void noise_filter_res_w(double data);
	102	void decay_res_w(double data);
	103	void attack_res_w(double data);
	104	void amplitude_res_w(double data);
	105	void feedback_res_w(double data);
	106
	107	/* these functions take a capacitor value in Farads or the voltage on it in Volts */
	108	#define SN76477_EXTERNAL_VOLTAGE_DISCONNECT   (-1.0)    /* indicates that the voltage is internally computed,
	109	can be used in all the functions that take a
	110	voltage on a capacitor */
	111	void one_shot_cap_w(double data);
	112	void one_shot_cap_voltage_w(double data);
	113	void slf_cap_w(double data);
	114	void slf_cap_voltage_w(double data);
	115	void vco_cap_w(double data);
	116	void vco_cap_voltage_w(double data);
	117	void noise_filter_cap_w(double data);
	118	void noise_filter_cap_voltage_w(double data);
	119	void attack_decay_cap_w(double data);
	120	void attack_decay_cap_voltage_w(double data);
	121
	122	/* these functions take a voltage value in Volts */
	123	void vco_voltage_w(double data);
	124	void pitch_voltage_w(double data);
	125
135	126	protected:
136	127	// device-level overrides
137	128	virtual void device_config_complete();
r26337	r26338
140	131
141	132	// sound stream update overrides
142	133	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	134
143	135	private:
	136	/* chip's external interface */
	137	UINT32 m_enable;
	138	UINT32 m_envelope_mode;
	139	UINT32 m_vco_mode;
	140	UINT32 m_mixer_mode;
	141
	142	double m_one_shot_res;
	143	double m_one_shot_cap;
	144	UINT32 m_one_shot_cap_voltage_ext;
	145
	146	double m_slf_res;
	147	double m_slf_cap;
	148	UINT32 m_slf_cap_voltage_ext;
	149
	150	double m_vco_voltage;
	151	double m_vco_res;
	152	double m_vco_cap;
	153	UINT32 m_vco_cap_voltage_ext;
	154
	155	double m_noise_clock_res;
	156	UINT32 m_noise_clock_ext;
	157	UINT32 m_noise_clock;
	158	double m_noise_filter_res;
	159	double m_noise_filter_cap;
	160	UINT32 m_noise_filter_cap_voltage_ext;
	161
	162	double m_attack_res;
	163	double m_decay_res;
	164	double m_attack_decay_cap;
	165	UINT32 m_attack_decay_cap_voltage_ext;
	166
	167	double m_amplitude_res;
	168	double m_feedback_res;
	169	double m_pitch_voltage;
	170
144	171	// internal state
145		void *m_token;
	172	double m_one_shot_cap_voltage;        /* voltage on the one-shot cap */
	173	UINT32 m_one_shot_running_ff;         /* 1 = one-shot running, 0 = stopped */
	174
	175	double m_slf_cap_voltage;             /* voltage on the SLF cap */
	176	UINT32 m_slf_out_ff;                  /* output of the SLF */
	177
	178	double m_vco_cap_voltage;             /* voltage on the VCO cap */
	179	UINT32 m_vco_out_ff;                  /* output of the VCO */
	180	UINT32 m_vco_alt_pos_edge_ff;         /* keeps track of the # of positive edges for VCO Alt envelope */
	181
	182	double m_noise_filter_cap_voltage;    /* voltage on the noise filter cap */
	183	UINT32 m_real_noise_bit_ff;           /* the current noise bit before filtering */
	184	UINT32 m_filtered_noise_bit_ff;       /* the noise bit after filtering */
	185	UINT32 m_noise_gen_count;             /* noise freq emulation */
	186
	187	double m_attack_decay_cap_voltage;    /* voltage on the attack/decay cap */
	188
	189	UINT32 m_rng;                         /* current value of the random number generator */
	190
	191	/* others */
	192	sound_stream *m_channel;              /* returned by stream_create() */
	193	int m_our_sample_rate;                    /* from machine.sample_rate() */
	194
	195	wav_file *m_file;                     /* handle of the wave file to produce */
	196
	197	double compute_one_shot_cap_charging_rate();
	198	double compute_one_shot_cap_discharging_rate();
	199	double compute_slf_cap_charging_rate();
	200	double compute_slf_cap_discharging_rate();
	201	double compute_vco_cap_charging_discharging_rate();
	202	double compute_vco_duty_cycle();
	203	UINT32 compute_noise_gen_freq();
	204	double compute_noise_filter_cap_charging_rate();
	205	double compute_noise_filter_cap_discharging_rate();
	206	double compute_attack_decay_cap_charging_rate();
	207	double compute_attack_decay_cap_discharging_rate();
	208	double compute_center_to_peak_voltage_out();
	209
	210	void log_enable_line();
	211	void log_mixer_mode();
	212	void log_envelope_mode();
	213	void log_vco_mode();
	214	void log_one_shot_time();
	215	void log_slf_freq();
	216	void log_vco_pitch_voltage();
	217	void log_vco_duty_cycle();
	218	void log_vco_freq();
	219	void log_vco_ext_voltage();
	220	void log_noise_gen_freq();
	221	void log_noise_filter_freq();
	222	void log_attack_time();
	223	void log_decay_time();
	224	void log_voltage_out();
	225	void log_complete_state();
	226
	227	void open_wav_file();
	228	void close_wav_file();
	229	void add_wav_data(INT16 data_l, INT16 data_r);
	230
	231	void intialize_noise();
	232	inline UINT32 generate_next_real_noise_bit();
	233
	234	void state_save_register();
	235
	236	void _SN76477_enable_w(UINT32 data);
	237	void _SN76477_vco_w(UINT32 data);
	238	void _SN76477_mixer_a_w(UINT32 data);
	239	void _SN76477_mixer_b_w(UINT32 data);
	240	void _SN76477_mixer_c_w(UINT32 data);
	241	void _SN76477_envelope_1_w(UINT32 data);
	242	void _SN76477_envelope_2_w(UINT32 data);
	243	void _SN76477_one_shot_res_w(double data);
	244	void _SN76477_one_shot_cap_w(double data);
	245	void _SN76477_slf_res_w(double data);
	246	void _SN76477_slf_cap_w(double data);
	247	void _SN76477_vco_res_w(double data);
	248	void _SN76477_vco_cap_w(double data);
	249	void _SN76477_vco_voltage_w(double data);
	250	void _SN76477_noise_clock_res_w(double data);
	251	void _SN76477_noise_filter_res_w(double data);
	252	void _SN76477_noise_filter_cap_w(double data);
	253	void _SN76477_decay_res_w(double data);
	254	void _SN76477_attack_res_w(double data);
	255	void _SN76477_attack_decay_cap_w(double data);
	256	void _SN76477_amplitude_res_w(double data);
	257	void _SN76477_feedback_res_w(double data);
	258	void _SN76477_pitch_voltage_w(double data);
	259	void SN76477_test_enable_w(UINT32 data);
146	260	};
147	261
148	262	extern const device_type SN76477;

trunk/src/mess/drivers/hec2hrp.c

r26337	r26338
74	74	#include "imagedev/cassette.h"
75	75	#include "formats/hect_tap.h"
76	76	#include "imagedev/printer.h"
77		#include "sound/sn76477.h"   /* for sn sound*/
78	77	#include "sound/wave.h"      /* for K7 sound*/
79	78	#include "sound/discrete.h"  /* for 1 Bit sound*/
80	79	#include "machine/upd765.h" /* for floppy disc controller */

trunk/src/mess/drivers/abc80.c

r26337	r26338
160	160
161	161	WRITE_LINE_MEMBER( abc80_state::vco_voltage_w )
162	162	{
163		sn76477_vco_voltage_w(m_psg, state ? 2.5 : 0);
	163	m_psg->vco_voltage_w(state ? 2.5 : 0);
164	164	}
165	165
166	166
r26337	r26338
229	229	PORT_DIPUNKNOWN_DIPLOC( 0x80, IP_ACTIVE_LOW, "SW2:8" )
230	230
231	231	PORT_START("SN76477")
232		PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_enable_w)
	232	PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, enable_w)
233	233	PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(DEVICE_SELF, abc80_state, vco_voltage_w)
234		PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_vco_w)
235		PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_mixer_b_w)
236		PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_mixer_a_w)
237		PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_mixer_c_w)
238		PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_envelope_2_w)
239		PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE(SN76477_TAG, sn76477_envelope_1_w)
	234	PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, vco_w)
	235	PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, mixer_b_w)
	236	PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, mixer_a_w)
	237	PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, mixer_c_w)
	238	PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, envelope_2_w)
	239	PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_SPECIAL) PORT_WRITE_LINE_DEVICE_MEMBER(SN76477_TAG, sn76477_device, envelope_1_w)
240	240	INPUT_PORTS_END
241	241
242	242

trunk/src/mess/drivers/interact.c

r26337	r26338
55	55	#include "formats/hect_tap.h"
56	56	#include "imagedev/printer.h"
57	57	#include "sound/wave.h"      /* for K7 sound*/
58		#include "sound/sn76477.h"   /* for sn sound*/
59	58	#include "sound/discrete.h"  /* for 1 Bit sound*/
60	59	#include "machine/upd765.h" /* for floppy disc controller */
61	60

trunk/src/mess/machine/hecdisk2.c

r26337	r26338
18	18
19	19	#include "emu.h"
20	20
21		#include "sound/sn76477.h"      /* for sn sound*/
22	21	#include "sound/wave.h"         /* for K7 sound*/
23	22	#include "sound/discrete.h"     /* for 1 Bit sound*/
24	23	#include "machine/upd765.h"     /* for floppy disc controller */

trunk/src/mess/machine/hec2hrp.c

r26337	r26338
41	41	#include "emu.h"
42	42	#include "imagedev/cassette.h"
43	43	#include "imagedev/printer.h"
44		#include "sound/sn76477.h"   /* for sn sound*/
45	44	#include "sound/wave.h"      /* for K7 sound*/
46	45	#include "sound/discrete.h"  /* for 1 Bit sound*/
47	46	#include "machine/upd765.h" /* for floppy disc controller */
r26337	r26338
773	772	void hec2hrp_state::Update_Sound(address_space &space, UINT8 data)
774	773	{
775	774	/* keep device*/
776		device_t *sn76477 = space.machine().device("sn76477");
777
778	775	/* MIXER*/
779		sn76477_mixer_a_w(sn76477, ((m_ValMixer & 0x04)==4) ? 1 : 0);
780		sn76477_mixer_b_w(sn76477, ((m_ValMixer & 0x01)==1) ? 1 : 0);
781		sn76477_mixer_c_w(sn76477, ((m_ValMixer & 0x02)==2) ? 1 : 0);/* Revu selon mesure electronique sur HRX*/
	776	m_sn->mixer_a_w(((m_ValMixer & 0x04)==4) ? 1 : 0);
	777	m_sn->mixer_b_w(((m_ValMixer & 0x01)==1) ? 1 : 0);
	778	m_sn->mixer_c_w(((m_ValMixer & 0x02)==2) ? 1 : 0);/* Revu selon mesure electronique sur HRX*/
782	779
783	780	/* VCO oscillateur*/
784	781	if (m_AU[12]==1)
785		sn76477_vco_res_w(      sn76477, m_Pin_Value[18][m_AU[10]]/12.0); /* en non AU11*/
	782	m_sn->vco_res_w(m_Pin_Value[18][m_AU[10]]/12.0); /* en non AU11*/
786	783	else
787		sn76477_vco_res_w(      sn76477, m_Pin_Value[18][m_AU[10]]); /* en non AU11*/
	784	m_sn->vco_res_w(m_Pin_Value[18][m_AU[10]]); /* en non AU11*/
788	785
789		sn76477_vco_cap_w(      sn76477, m_Pin_Value[17][m_AU[2 ]]);
790		sn76477_pitch_voltage_w(sn76477, m_Pin_Value[19][m_AU[15]]);
791		sn76477_vco_voltage_w(  sn76477, m_Pin_Value[16][m_AU[15]]);
792		sn76477_vco_w(          sn76477, m_Pin_Value[22][m_AU[12]]); /* VCO Select Ext/SLF*/
	786	m_sn->vco_cap_w(m_Pin_Value[17][m_AU[2 ]]);
	787	m_sn->pitch_voltage_w(m_Pin_Value[19][m_AU[15]]);
	788	m_sn->vco_voltage_w(m_Pin_Value[16][m_AU[15]]);
	789	m_sn->vco_w(m_Pin_Value[22][m_AU[12]]); /* VCO Select Ext/SLF*/
793	790
794	791	/* SLF*/
795		sn76477_slf_res_w( sn76477, m_Pin_Value[20][m_AU[ 9]]);/*AU10*/
796		sn76477_slf_cap_w( sn76477, m_Pin_Value[21][m_AU[1 ]]);
	792	m_sn->slf_res_w(m_Pin_Value[20][m_AU[ 9]]);/*AU10*/
	793	m_sn->slf_cap_w(m_Pin_Value[21][m_AU[1 ]]);
797	794
798	795	/* One Shot*/
799		sn76477_one_shot_res_w(sn76477, m_Pin_Value[24][     0]); /* NC*/
800		sn76477_one_shot_cap_w(sn76477, m_Pin_Value[23][m_AU[13]]);
	796	m_sn->one_shot_res_w(m_Pin_Value[24][     0]); /* NC*/
	797	m_sn->one_shot_cap_w(m_Pin_Value[23][m_AU[13]]);
801	798
802	799	/* Ampli value*/
803		sn76477_amplitude_res_w(sn76477, m_Pin_Value[11][m_AU[5]]);
	800	m_sn->amplitude_res_w(m_Pin_Value[11][m_AU[5]]);
804	801
805	802	/* Attack / Decay*/
806		sn76477_attack_res_w(sn76477, m_Pin_Value[10][m_AU[ 8]]);
807		sn76477_decay_res_w( sn76477, m_Pin_Value[7 ][m_AU[11]]);/*AU9*/
808		sn76477_attack_decay_cap_w(sn76477, m_Pin_Value[8][m_AU[0]]);
	803	m_sn->attack_res_w(m_Pin_Value[10][m_AU[ 8]]);
	804	m_sn->decay_res_w(m_Pin_Value[7 ][m_AU[11]]);/*AU9*/
	805	m_sn->attack_decay_cap_w(m_Pin_Value[8][m_AU[0]]);
809	806
810	807	/* Filtre*/
811		sn76477_noise_filter_res_w(sn76477, m_Pin_Value[5][m_AU[4]]);
812		sn76477_noise_filter_cap_w(sn76477, m_Pin_Value[6][m_AU[3]]);
	808	m_sn->noise_filter_res_w(m_Pin_Value[5][m_AU[4]]);
	809	m_sn->noise_filter_cap_w(m_Pin_Value[6][m_AU[3]]);
813	810
814	811	/* Clock Extern Noise*/
815		sn76477_noise_clock_res_w(sn76477, m_Pin_Value[4][0]);   /* fix*/
816		sn76477_feedback_res_w(sn76477, m_Pin_Value[12][0]);     /*fix*/
	812	m_sn->noise_clock_res_w(m_Pin_Value[4][0]);   /* fix*/
	813	m_sn->feedback_res_w(m_Pin_Value[12][0]);     /*fix*/
817	814
818	815	/*  Envelope*/
819		sn76477_envelope_1_w(sn76477, m_Pin_Value[1 ][m_AU[6]]);
820		sn76477_envelope_2_w(sn76477, m_Pin_Value[28][m_AU[7]]);
	816	m_sn->envelope_1_w(m_Pin_Value[1 ][m_AU[6]]);
	817	m_sn->envelope_2_w(m_Pin_Value[28][m_AU[7]]);
821	818
822	819	/* En dernier on lance (ou pas !)*/
823		sn76477_enable_w(sn76477, m_Pin_Value[9][m_AU[14]]);
	820	m_sn->enable_w(m_Pin_Value[9][m_AU[14]]);
824	821	}
825	822
826	823	const sn76477_interface hector_sn76477_interface =

trunk/src/mess/includes/hec2hrp.h

r26337	r26338
41	41	#include "machine/wd17xx.h"
42	42	#include "imagedev/flopdrv.h"
43	43	#include "imagedev/cassette.h"
	44	#include "sound/sn76477.h"   /* for sn sound*/
44	45
45	46	/* Enum status for high memory bank (c000 - ffff)*/
46	47	enum
r26337	r26338
77	78	m_hector_videoram(*this,"hector_videoram") ,
78	79	m_maincpu(*this, "maincpu"),
79	80	m_disc2cpu(*this, "disc2cpu"),
80		m_cassette(*this, "cassette") { }
	81	m_cassette(*this, "cassette"),
	82	m_sn(*this, "sn76477") { }
81	83
82	84	optional_shared_ptr<UINT8> m_videoram;
83	85	optional_shared_ptr<UINT8> m_hector_videoram;
r26337	r26338
148	150	required_device<cpu_device> m_maincpu;
149	151	optional_device<cpu_device> m_disc2cpu;
150	152	required_device<cassette_image_device> m_cassette;
	153	required_device<sn76477_device> m_sn;
151	154	int isHectorWithDisc2();
152	155	int isHectorWithMiniDisc();
153	156	int isHectorHR();

trunk/src/mess/video/hec2video.c

r26337	r26338
32	32	*/
33	33
34	34	#include "emu.h"
35		#include "sound/sn76477.h"   // for sn sound
36	35
37	36	#include "includes/hec2hrp.h"
38	37

trunk/src/mame/drivers/astrof.c

r26337	r26338
510	510	/* the 74175 outputs all HI's if not otherwise set */
511	511	tomahawk_set_video_control_2(0xff);
512	512
513		m_sn = machine().device("snsnd");
514
515	513	/* register for state saving */
516	514	save_item(NAME(m_red_on));
517	515	save_item(NAME(m_flipscreen));

trunk/src/mame/drivers/spectra.c

r26337	r26338
148	148	if (BIT(data, 1)) vco -= 0.625;
149	149	if (BIT(data, 2)) vco -= 1.25;
150	150	if (BIT(data, 3)) vco -= 2.5;
151		sn76477_vco_voltage_w(m_snsnd, 5.4 - vco);
152		sn76477_enable_w(m_snsnd, !BIT(data, 4)); // strobe: toggles enable
153		sn76477_envelope_1_w(m_snsnd, !BIT(data, 5)); //decay: toggles envelope
154		sn76477_vco_w(m_snsnd, BIT(data, 6)); // "phaser" sound: VCO toggled
155		sn76477_mixer_b_w(m_snsnd, BIT(data, 7)); // "pulse" sound: pins 25 & 27 changed
156		sn76477_mixer_c_w(m_snsnd, BIT(data, 7)); // "pulse" sound: pins 25 & 27 changed
	151	m_snsnd->vco_voltage_w(5.4 - vco);
	152	m_snsnd->enable_w(!BIT(data, 4)); // strobe: toggles enable
	153	m_snsnd->envelope_1_w(!BIT(data, 5)); //decay: toggles envelope
	154	m_snsnd->vco_w(BIT(data, 6)); // "phaser" sound: VCO toggled
	155	m_snsnd->mixer_b_w(BIT(data, 7)); // "pulse" sound: pins 25 & 27 changed
	156	m_snsnd->mixer_c_w(BIT(data, 7)); // "pulse" sound: pins 25 & 27 changed
157	157	}
158	158
159	159

trunk/src/mame/drivers/8080bw.c

r26337	r26338
2488	2488	{
2489	2489	/* do nothing for now - different interrupt system */
2490	2490	m_fleet_step = 3;
2491		m_sn = machine().device("snsnd");
2492	2491	}
2493	2492
2494	2493

trunk/src/mame/drivers/crbaloon.c

r26337	r26338
155	155
156	156	WRITE8_MEMBER(crbaloon_state::port_sound_w)
157	157	{
158		device_t *sn = machine().device("snsnd");
159
160	158	/* D0 - interrupt enable - also goes to PC3259 as /HTCTRL */
161	159	m_irq_mask = data & 0x01;
162	160	crbaloon_set_clear_collision_address((data & 0x01) ? TRUE : FALSE);
r26337	r26338
168	166	crbaloon_audio_set_music_enable(space, 0, (data & 0x04) ? TRUE : FALSE);
169	167
170	168	/* D3 - EXPLOSION */
171		crbaloon_audio_set_explosion_enable(sn, (data & 0x08) ? TRUE : FALSE);
	169	crbaloon_audio_set_explosion_enable((data & 0x08) ? TRUE : FALSE);
172	170
173	171	/* D4 - BREATH */
174		crbaloon_audio_set_breath_enable(sn, (data & 0x10) ? TRUE : FALSE);
	172	crbaloon_audio_set_breath_enable((data & 0x10) ? TRUE : FALSE);
175	173
176	174	/* D5 - APPEAR */
177		crbaloon_audio_set_appear_enable(sn, (data & 0x20) ? TRUE : FALSE);
	175	crbaloon_audio_set_appear_enable((data & 0x20) ? TRUE : FALSE);
178	176
179	177	/* D6 - unlabeled - laugh enable */
180	178	crbaloon_audio_set_laugh_enable(space, 0, (data & 0x40) ? TRUE : FALSE);

trunk/src/mame/drivers/laserbat.c

r26337	r26338
20	20	#include "cpu/m6800/m6800.h"
21	21	#include "cpu/s2650/s2650.h"
22	22	#include "machine/6821pia.h"
23		#include "sound/sn76477.h"
24	23	#include "sound/tms3615.h"
25	24	#include "includes/laserbat.h"
26	25
r26337	r26338
675	674	void laserbat_state::machine_start()
676	675	{
677	676	m_pia = machine().device<pia6821_device>("pia");
678		m_sn = machine().device("snsnd");
679	677	m_tms1 = machine().device<tms3615_device>("tms1");
680	678	m_tms2 = machine().device<tms3615_device>("tms2");
681	679

trunk/src/mame/drivers/dai3wksi.c

r26337	r26338
51	51	: driver_device(mconfig, type, tag),
52	52	m_dai3wksi_videoram(*this, "videoram"),
53	53	m_maincpu(*this, "maincpu"),
54		m_samples(*this, "samples") { }
	54	m_samples(*this, "samples"),
	55	m_ic77(*this, "ic77"),
	56	m_ic78(*this, "ic78"),
	57	m_ic79(*this, "ic79"),
	58	m_ic80(*this, "ic80"),
	59	m_ic81(*this, "ic81") { }
55	60
56	61	/* video */
57	62	required_shared_ptr<UINT8> m_dai3wksi_videoram;
r26337	r26338
72	77	UINT32 screen_update_dai3wksi(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
73	78	required_device<cpu_device> m_maincpu;
74	79	required_device<samples_device> m_samples;
	80	optional_device<sn76477_device> m_ic77;
	81	optional_device<sn76477_device> m_ic78;
	82	optional_device<sn76477_device> m_ic79;
	83	optional_device<sn76477_device> m_ic80;
	84	optional_device<sn76477_device> m_ic81;
75	85	};
76	86
77	87
r26337	r26338
286	296
287	297	WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_1_w)
288	298	{
289		device_t *ic79 = machine().device("ic79");
290
291	299	machine().sound().system_enable(data & 0x80);
292	300
293		sn76477_enable_w(ic79, (~data >> 5) & 0x01);        /* invader movement enable */
294		sn76477_envelope_1_w(ic79, (~data >> 2) & 0x01);    /* invader movement envelope control*/
	301	m_ic79->enable_w((~data >> 5) & 0x01);        /* invader movement enable */
	302	m_ic79->envelope_1_w((~data >> 2) & 0x01);    /* invader movement envelope control*/
295	303	}
296	304
297	305	WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_2_w)
298	306	{
299		device_t *ic77 = machine().device("ic77");
300		device_t *ic78 = machine().device("ic78");
301		device_t *ic80 = machine().device("ic80");
302
303	307	m_dai3wksi_flipscreen =  data & 0x10;
304	308	m_dai3wksi_redscreen  = ~data & 0x20;
305	309	m_dai3wksi_redterop   =  data & 0x40;
306	310
307		sn76477_enable_w(ic77, (~data >> 0) & 0x01);    /* ship movement */
308		sn76477_enable_w(ic78, (~data >> 1) & 0x01);    /* danger text */
	311	m_ic77->enable_w((~data >> 0) & 0x01);    /* ship movement */
	312	m_ic78->enable_w((~data >> 1) & 0x01);    /* danger text */
309	313	/* ic76 - invader hit  (~data >> 2) & 0x01 */
310		sn76477_enable_w(ic80, (~data >> 3) & 0x01);    /* planet explosion */
	314	m_ic80->enable_w((~data >> 3) & 0x01);    /* planet explosion */
311	315	}
312	316
313	317	WRITE8_MEMBER(dai3wksi_state::dai3wksi_audio_3_w)
314	318	{
315		device_t *ic81 = machine().device("ic81");
316
317		sn76477_enable_w(ic81, (~data >> 2) & 0x01);    /* player shoot enable */
318		sn76477_vco_w(ic81, (~data >> 3) & 0x01);       /* player shoot vco control */
	319	m_ic81->enable_w((~data >> 2) & 0x01);    /* player shoot enable */
	320	m_ic81->vco_w((~data >> 3) & 0x01);       /* player shoot vco control */
319	321	}
320	322
321	323

trunk/src/mame/drivers/toratora.c

r26337	r26338
29	29	toratora_state(const machine_config &mconfig, device_type type, const char *tag)
30	30	: driver_device(mconfig, type, tag),
31	31	m_videoram(*this, "videoram"),
32		m_maincpu(*this, "maincpu"){ }
	32	m_maincpu(*this, "maincpu"),
	33	m_sn1(*this, "sn1"),
	34	m_sn2(*this, "sn2"),
	35	m_pia_u1(*this, "pia_u1"),
	36	m_pia_u2(*this, "pia_u2"),
	37	m_pia_u3(*this, "pia_u3") { }
33	38
34	39	/* memory pointers */
35	40	required_shared_ptr<UINT8> m_videoram;
r26337	r26338
41	46
42	47	/* devices */
43	48	required_device<cpu_device> m_maincpu;
44		pia6821_device *m_pia_u1;
45		pia6821_device *m_pia_u2;
46		pia6821_device *m_pia_u3;
	49	required_device<sn76477_device> m_sn1;
	50	required_device<sn76477_device> m_sn2;
	51	required_device<pia6821_device> m_pia_u1;
	52	required_device<pia6821_device> m_pia_u2;
	53	required_device<pia6821_device> m_pia_u3;
47	54	DECLARE_WRITE8_MEMBER(clear_tv_w);
48	55	DECLARE_READ8_MEMBER(timer_r);
49	56	DECLARE_WRITE8_MEMBER(clear_timer_w);
r26337	r26338
128	135
129	136	WRITE8_MEMBER(toratora_state::port_b_u1_w)
130	137	{
131		pia6821_device *pia = machine().device<pia6821_device>("pia_u1");
132		if (pia->port_b_z_mask() & 0x20)
	138	if (m_pia_u1->port_b_z_mask() & 0x20)
133	139	coin_counter_w(machine(), 0, 1);
134	140	else
135	141	coin_counter_w(machine(), 0, data & 0x20);
r26337	r26338
144	150
145	151	WRITE_LINE_MEMBER(toratora_state::main_cpu_irq)
146	152	{
147		pia6821_device *pia = machine().device<pia6821_device>("pia_u1");
148		int combined_state = pia->irq_a_state() | pia->irq_b_state();
	153	int combined_state = m_pia_u1->irq_a_state() | m_pia_u1->irq_b_state();
149	154
150	155	logerror("GEN IRQ: %x\n", combined_state);
151	156	m_maincpu->set_input_line(0, combined_state ? ASSERT_LINE : CLEAR_LINE);
r26337	r26338
218	223
219	224	WRITE8_MEMBER(toratora_state::sn1_port_a_u2_u3_w)
220	225	{
221		device_t *device = machine().device("sn1");
222		sn76477_vco_voltage_w(device, 2.35 * (data & 0x7f) / 128.0);
223		sn76477_enable_w(device, (data >> 7) & 0x01);
	226	m_sn1->vco_voltage_w(2.35 * (data & 0x7f) / 128.0);
	227	m_sn1->enable_w((data >> 7) & 0x01);
224	228	}
225	229
226	230
227	231	WRITE8_MEMBER(toratora_state::sn1_port_b_u2_u3_w)
228	232	{
229		device_t *device = machine().device("sn1");
230	233	static const double resistances[] =
231	234	{
232	235	0,  /* N/C */
r26337	r26338
239	242	RES_K(47)
240	243	};
241	244
242		sn76477_mixer_a_w      (device, (data >> 0) & 0x01);
243		sn76477_mixer_b_w      (device, (data >> 1) & 0x01);
244		sn76477_mixer_c_w      (device, (data >> 2) & 0x01);
245		sn76477_envelope_1_w   (device, (data >> 3) & 0x01);
246		sn76477_envelope_2_w   (device, (data >> 4) & 0x01);
247		sn76477_amplitude_res_w(device, resistances[(data >> 5)] * 2);  /* the *2 shouldn't be neccassary, but... */
	245	m_sn1->mixer_a_w      ((data >> 0) & 0x01);
	246	m_sn1->mixer_b_w      ((data >> 1) & 0x01);
	247	m_sn1->mixer_c_w      ((data >> 2) & 0x01);
	248	m_sn1->envelope_1_w   ((data >> 3) & 0x01);
	249	m_sn1->envelope_2_w   ((data >> 4) & 0x01);
	250	m_sn1->amplitude_res_w(resistances[(data >> 5)] * 2);  /* the *2 shouldn't be neccassary, but... */
248	251	}
249	252
250	253
251	254	WRITE_LINE_MEMBER(toratora_state::sn1_ca2_u2_u3_w)
252	255	{
253		device_t *device = machine().device("sn1");
254		sn76477_vco_w(device, state);
	256	m_sn1->vco_w(state);
255	257	}
256	258
257	259	WRITE8_MEMBER(toratora_state::sn2_port_a_u2_u3_w)
258	260	{
259		device_t *device = machine().device("sn2");
260		sn76477_vco_voltage_w(device, 2.35 * (data & 0x7f) / 128.0);
261		sn76477_enable_w(device, (data >> 7) & 0x01);
	261	m_sn2->vco_voltage_w(2.35 * (data & 0x7f) / 128.0);
	262	m_sn2->enable_w((data >> 7) & 0x01);
262	263	}
263	264
264	265
265	266	WRITE8_MEMBER(toratora_state::sn2_port_b_u2_u3_w)
266	267	{
267		device_t *device = machine().device("sn2");
268	268	static const double resistances[] =
269	269	{
270	270	0,  /* N/C */
r26337	r26338
277	277	RES_K(47)
278	278	};
279	279
280		sn76477_mixer_a_w      (device, (data >> 0) & 0x01);
281		sn76477_mixer_b_w      (device, (data >> 1) & 0x01);
282		sn76477_mixer_c_w      (device, (data >> 2) & 0x01);
283		sn76477_envelope_1_w   (device, (data >> 3) & 0x01);
284		sn76477_envelope_2_w   (device, (data >> 4) & 0x01);
285		sn76477_amplitude_res_w(device, resistances[(data >> 5)] * 2);  /* the *2 shouldn't be neccassary, but... */
	280	m_sn2->mixer_a_w      ((data >> 0) & 0x01);
	281	m_sn2->mixer_b_w      ((data >> 1) & 0x01);
	282	m_sn2->mixer_c_w      ((data >> 2) & 0x01);
	283	m_sn2->envelope_1_w   ((data >> 3) & 0x01);
	284	m_sn2->envelope_2_w   ((data >> 4) & 0x01);
	285	m_sn2->amplitude_res_w(resistances[(data >> 5)] * 2);  /* the *2 shouldn't be neccassary, but... */
286	286	}
287	287
288	288
289	289	WRITE_LINE_MEMBER(toratora_state::sn2_ca2_u2_u3_w)
290	290	{
291		device_t *device = machine().device("sn2");
292		sn76477_vco_w(device, state);
	291	m_sn2->vco_w(state);
293	292	}
294	293
295	294	/*************************************
r26337	r26338
426	425
427	426	void toratora_state::machine_start()
428	427	{
429		m_pia_u1 = machine().device<pia6821_device>("pia_u1");
430		m_pia_u2 = machine().device<pia6821_device>("pia_u2");
431		m_pia_u3 = machine().device<pia6821_device>("pia_u3");
432
433	428	save_item(NAME(m_timer));
434	429	save_item(NAME(m_last));
435	430	save_item(NAME(m_clear_tv));

trunk/src/mame/drivers/rotaryf.c

r26337	r26338
111	111	if (BIT(rising_bits, 6)) m_samples->start (2, 2);   /* Hit */
112	112	if (BIT(rising_bits, 7)) m_samples->start (0, 0);   /* Shoot */
113	113
114		sn76477_enable_w(m_sn, (data & 3) ? 1 : 0);     /* Saucer Sound */
	114	m_sn->enable_w((data & 3) ? 1 : 0);     /* Saucer Sound */
115	115
116	116	if (BIT(rising_bits, 4))
117	117	{

trunk/src/mame/drivers/route16.c

r26337	r26338
70	70	#include "emu.h"
71	71	#include "cpu/z80/z80.h"
72	72	#include "sound/dac.h"
73		#include "sound/sn76477.h"
74	73	#include "sound/ay8910.h"
75	74	#include "includes/route16.h"
76	75
r26337	r26338
121	120
122	121	WRITE8_MEMBER(route16_state::stratvox_sn76477_w)
123	122	{
124		device_t *device = machine().device("snsnd");
125	123	/***************************************************************
126	124	* AY8910 output bits are connected to...
127	125	* 7    - direct: 5V * 30k/(100+30k) = 1.15V - via DAC??
r26337	r26338
133	131	* 1    - SN76477 vco
134	132	* 0    - SN76477 enable
135	133	***************************************************************/
136		sn76477_enable_w(device, (data >> 0) & 1);
137		sn76477_vco_w(device, (data >> 1) & 1);
138		sn76477_envelope_1_w(device, (data >> 2) & 1);
139		sn76477_envelope_2_w(device, (data >> 3) & 1);
140		sn76477_mixer_a_w(device, (data >> 4) & 1);
141		sn76477_mixer_b_w(device, (data >> 5) & 1);
142		sn76477_mixer_c_w(device, (data >> 6) & 1);
	134	m_sn->enable_w((data >> 0) & 1);
	135	m_sn->vco_w((data >> 1) & 1);
	136	m_sn->envelope_1_w((data >> 2) & 1);
	137	m_sn->envelope_2_w((data >> 3) & 1);
	138	m_sn->mixer_a_w((data >> 4) & 1);
	139	m_sn->mixer_b_w((data >> 5) & 1);
	140	m_sn->mixer_c_w((data >> 6) & 1);
143	141	}
144	142
145	143

trunk/src/mame/drivers/snk6502.c

r26337	r26338
281	281	#include "emu.h"
282	282	#include "cpu/m6502/m6502.h"
283	283	#include "video/mc6845.h"
284		#include "sound/sn76477.h"
285	284	#include "sound/samples.h"
286	285	#include "includes/snk6502.h"
287	286

trunk/src/mame/audio/snk6502.c

r26337	r26338
11	11
12	12
13	13	#include "emu.h"
14		#include "sound/sn76477.h"
15	14	#include "sound/samples.h"
16	15	#include "includes/snk6502.h"
17	16	#include "sound/discrete.h"
r26337	r26338
771	770	}
772	771
773	772	/* SHOT B */
774		sn76477_enable_w(space.machine().device("sn76477.2"), (data & 0x40) ? 0 : 1);
	773	machine().device<sn76477_device>("sn76477.2")->enable_w((data & 0x40) ? 0 : 1);
775	774
776	775	m_LastPort1 = data;
777	776	break;

trunk/src/mame/audio/8080bw.c

r26337	r26338
2	2
3	3	#include "emu.h"
4	4	#include "sound/samples.h"
5		#include "sound/sn76477.h"
6	5	#include "sound/discrete.h"
7		#include "sound/speaker.h"
8	6	#include "includes/8080bw.h"
9	7
10	8
r26337	r26338
33	31	{
34	32	UINT8 rising_bits = data & ~m_port_1_last_extra;
35	33
36		sn76477_enable_w(m_sn, !(data & 0x01));         /* SAUCER SOUND */
	34	m_sn->enable_w(!(data & 0x01));         /* SAUCER SOUND */
37	35
38	36	if (rising_bits & 0x02) m_samples->start(0, 0);     /* MISSLE SOUND */
39	37	if (rising_bits & 0x04) m_samples->start(1, 1);     /* EXPLOSION */
r26337	r26338
102	100	{
103	101	UINT8 rising_bits = data & ~m_port_1_last_extra;
104	102
105		sn76477_enable_w(m_sn, !(data & 0x01));         /* Saucer Sound */
	103	m_sn->enable_w(!(data & 0x01));         /* Saucer Sound */
106	104
107	105	if (rising_bits & 0x02) m_samples->start(0, 0);     /* Shot Sound */
108	106	if (rising_bits & 0x04) m_samples->start(1, 1);     /* Base Hit */
r26337	r26338
931	929	m_schaser_explosion = BIT(data, 5);
932	930	if (m_schaser_explosion)
933	931	{
934		sn76477_amplitude_res_w(m_sn, 1.0 / (1.0/RES_K(200) + 1.0/RES_K(68)));
	932	m_sn->amplitude_res_w(1.0 / (1.0/RES_K(200) + 1.0/RES_K(68)));
935	933	}
936	934	else
937	935	{
938		sn76477_amplitude_res_w(m_sn, RES_K(200));
	936	m_sn->amplitude_res_w(RES_K(200));
939	937	}
940		sn76477_enable_w(m_sn, !(m_schaser_effect_555_is_low || m_schaser_explosion));
941		sn76477_one_shot_cap_voltage_w(m_sn, !(m_schaser_effect_555_is_low || m_schaser_explosion) ? 0 : SN76477_EXTERNAL_VOLTAGE_DISCONNECT);
942		sn76477_mixer_b_w(m_sn, m_schaser_explosion);
	938	m_sn->enable_w(!(m_schaser_effect_555_is_low || m_schaser_explosion));
	939	m_sn->one_shot_cap_voltage_w(!(m_schaser_effect_555_is_low || m_schaser_explosion) ? 0 : SN76477_EXTERNAL_VOLTAGE_DISCONNECT);
	940	m_sn->mixer_b_w(m_schaser_explosion);
943	941	}
944	942
945	943	WRITE8_MEMBER(_8080bw_state::schaser_sh_port_2_w)
r26337	r26338
987	985	new_time = attotime::never;
988	986	}
989	987	m_schaser_effect_555_timer->adjust(new_time, effect);
990		sn76477_enable_w(m_sn, !(m_schaser_effect_555_is_low || m_schaser_explosion));
991		sn76477_one_shot_cap_voltage_w(m_sn, !(m_schaser_effect_555_is_low || m_schaser_explosion) ? 0 : SN76477_EXTERNAL_VOLTAGE_DISCONNECT);
	988	m_sn->enable_w(!(m_schaser_effect_555_is_low || m_schaser_explosion));
	989	m_sn->one_shot_cap_voltage_w(!(m_schaser_effect_555_is_low || m_schaser_explosion) ? 0 : SN76477_EXTERNAL_VOLTAGE_DISCONNECT);
992	990	}
993	991
994	992
r26337	r26338
1139	1137	lupin3_step ^= 1;
1140	1138	}
1141	1139
1142		sn76477_enable_w(m_sn, data & 0x02 ? 0:1);          /* Helicopter */
	1140	m_sn->enable_w(data & 0x02 ? 0:1);          /* Helicopter */
1143	1141
1144	1142	if (rising_bits & 0x04) m_samples->start(1, 4);     /* Translocate */
1145	1143	if (rising_bits & 0x08) m_samples->start(0, 0);     /* Jail */
r26337	r26338
1228	1226	if (rising_bits & 0x01) m_samples->start(1, 6);         /* Ready? , Game Over */
1229	1227	if (rising_bits & 0x04) m_samples->start(3, 7);         /* Big bird dead */
1230	1228
1231		sn76477_enable_w(m_sn, data & 0x08 ? 0:1);              /* Big bird */
	1229	m_sn->enable_w(data & 0x08 ? 0:1);              /* Big bird */
1232	1230
1233	1231	if (rising_bits & 0x10) m_samples->start(2, 7);         /* Game Over */
1234	1232
r26337	r26338
1252	1250	if (rising_bits & 0x01) m_samples->start(4, 4);         /* Fleet move */
1253	1251	if (rising_bits & 0x02) m_samples->start(5, 8);         /* Extra Tank */
1254	1252
1255		sn76477_enable_w(m_sn, data & 0x04 ? 0:1);              /* UFO */
	1253	m_sn->enable_w(data & 0x04 ? 0:1);              /* UFO */
1256	1254
1257	1255	m_port_1_last_extra = data;
1258	1256	}
r26337	r26338
1300	1298	if (rising_bits & 0x04) m_samples->start(3, 7);     /* Hit UFO */
1301	1299	if (rising_bits & 0x10) m_samples->start(5, 8);     /* Bonus */
1302	1300
1303		sn76477_enable_w(m_sn, data & 0x20 ? 0:1);          /* UFO */
	1301	m_sn->enable_w(data & 0x20 ? 0:1);          /* UFO */
1304	1302
1305	1303	if (rising_bits & 0x40) m_samples->start(1, 1);     /* Death */
1306	1304	if (rising_bits & 0x80) m_samples->start(2, 2);     /* Hit */

trunk/src/mame/audio/mw8080bw.c

r26337	r26338
5	5	****************************************************************************/
6	6
7	7	#include "emu.h"
8		#include "sound/samples.h"
9		#include "sound/sn76477.h"
10		#include "sound/discrete.h"
11	8	#include "includes/mw8080bw.h"
12	9
13	10
r26337	r26338
3283	3280
3284	3281	discrete_sound_w(m_discrete, space, SPCENCTR_BONUS_EN, (data >> 4) & 0x01);
3285	3282
3286		sn76477_enable_w(m_sn, (data >> 5) & 0x01); /* saucer sound */
	3283	m_sn->enable_w((data >> 5) & 0x01); /* saucer sound */
3287	3284
3288	3285	/* D6 and D7 are not connected */
3289	3286	}
r26337	r26338
4174	4171
4175	4172	WRITE8_MEMBER(mw8080bw_state::invaders_audio_1_w)
4176	4173	{
4177		sn76477_enable_w(m_sn, (~data >> 0) & 0x01);    /* saucer sound */
	4174	m_sn->enable_w((~data >> 0) & 0x01);    /* saucer sound */
4178	4175
4179	4176	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_MISSILE_EN, 1), data & 0x02);
4180	4177	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_EXPLOSION_EN, 1), data & 0x04);
r26337	r26338
4803	4800
4804	4801	WRITE8_MEMBER(mw8080bw_state::invad2ct_audio_1_w)
4805	4802	{
4806		sn76477_enable_w(m_sn1, (~data >> 0) & 0x01);   /* saucer sound */
	4803	m_sn1->enable_w((~data >> 0) & 0x01);   /* saucer sound */
4807	4804
4808	4805	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_MISSILE_EN, 1), data & 0x02);
4809	4806	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_EXPLOSION_EN, 1), data & 0x04);
r26337	r26338
4827	4824
4828	4825	WRITE8_MEMBER(mw8080bw_state::invad2ct_audio_3_w)
4829	4826	{
4830		sn76477_enable_w(m_sn2, (~data >> 0) & 0x01);   /* saucer sound */
	4827	m_sn2->enable_w((~data >> 0) & 0x01);   /* saucer sound */
4831	4828
4832	4829	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_MISSILE_EN, 2), data & 0x02);
4833	4830	discrete_sound_w(m_discrete, space, INVADERS_NODE(INVADERS_EXPLOSION_EN, 2), data & 0x04);

trunk/src/mame/audio/laserbat.c

r26337	r26338
1	1	#include "emu.h"
2		#include "sound/sn76477.h"
3	2	#include "sound/tms3615.h"
4	3	#include "includes/laserbat.h"
5	4
r26337	r26338
52	51	break;
53	52	}
54	53
55		sn76477_noise_filter_res_w(m_sn, noise_filter_res);
56		sn76477_vco_res_w(m_sn, vco_res);
	54	m_sn->noise_filter_res_w(noise_filter_res);
	55	m_sn->vco_res_w(vco_res);
57	56
58		sn76477_enable_w(m_sn, (m_csound1 & 0x08) ? 1 : 0); // AB SOUND
59		sn76477_mixer_b_w(m_sn, (m_csound1 & 0x10) ? 1 : 0); // _VCO/NOISE
	57	m_sn->enable_w((m_csound1 & 0x08) ? 1 : 0); // AB SOUND
	58	m_sn->mixer_b_w((m_csound1 & 0x10) ? 1 : 0); // _VCO/NOISE
60	59
61	60	m_degr = (m_csound1 & 0x20) ? 1 : 0;
62	61	m_filt = (m_csound1 & 0x40) ? 1 : 0;
r26337	r26338
64	63	m_us = 0; // sn76477 pin 12
65	64	}
66	65
67		sn76477_vco_w(m_sn, (data & 0x40) ? 0 : 1);
	66	m_sn->vco_w((data & 0x40) ? 0 : 1);
68	67
69	68	switch((data & 0x1c) >> 2)
70	69	{
71	70	case 0x00:
72		sn76477_slf_res_w(m_sn, RES_K(27));
	71	m_sn->slf_res_w(RES_K(27));
73	72	break;
74	73	case 0x01:
75		sn76477_slf_res_w(m_sn, RES_K(22));
	74	m_sn->slf_res_w(RES_K(22));
76	75	break;
77	76	case 0x02:
78		sn76477_slf_res_w(m_sn, RES_K(22));
	77	m_sn->slf_res_w(RES_K(22));
79	78	break;
80	79	case 0x03:
81		sn76477_slf_res_w(m_sn, RES_K(12));
	80	m_sn->slf_res_w(RES_K(12));
82	81	break;
83	82	case 0x04: // not connected
84	83	break;

trunk/src/mame/audio/astrof.c

r26337	r26338
5	5	****************************************************************************/
6	6
7	7	#include "emu.h"
8		#include "sound/samples.h"
9		#include "sound/sn76477.h"
10	8	#include "includes/astrof.h"
11	9
12	10
r26337	r26338
192	190	/* D4 - UFO */
193	191
194	192	/* D5 - UFO under water */
195		sn76477_enable_w(m_sn, (~data >> 5) & 0x01);
	193	m_sn->enable_w((~data >> 5) & 0x01);
196	194
197	195	/* D6 - explosion */
198	196

trunk/src/mame/audio/crbaloon.c

r26337	r26338
8	8
9	9	#include "emu.h"
10	10	#include "includes/crbaloon.h"
11		#include "sound/sn76477.h"
12		#include "sound/discrete.h"
13	11
14	12
15	13	/* timing sources */
r26337	r26338
42	40	}
43	41
44	42
45		void crbaloon_audio_set_explosion_enable(device_t *sn, int enabled)
	43	void crbaloon_state::crbaloon_audio_set_explosion_enable(int enabled)
46	44	{
47		sn76477_enable_w(sn, enabled);
	45	m_sn->enable_w(enabled);
48	46	}
49	47
50	48
51		void crbaloon_audio_set_breath_enable(device_t *sn, int enabled)
	49	void crbaloon_state::crbaloon_audio_set_breath_enable(int enabled)
52	50	{
53	51	/* changes slf_res to 10k (middle of two 10k resistors)
54	52	it also puts a tantal capacitor against GND on the output,
55	53	but this section of the schematics is not readable. */
56		sn76477_slf_res_w(sn, enabled ? RES_K(10) : RES_K(20) );
	54	m_sn->slf_res_w(enabled ? RES_K(10) : RES_K(20) );
57	55	}
58	56
59	57
60		void crbaloon_audio_set_appear_enable(device_t *sn, int enabled)
	58	void crbaloon_state::crbaloon_audio_set_appear_enable(int enabled)
61	59	{
62	60	/* APPEAR is connected to MIXER B */
63		sn76477_mixer_b_w(sn, enabled);
	61	m_sn->mixer_b_w(enabled);
64	62	}
65	63
66	64

trunk/src/mame/audio/n8080.c

r26337	r26338
5	5	***************************************************************************/
6	6
7	7	#include "emu.h"
8		#include "cpu/mcs48/mcs48.h"
9		#include "sound/sn76477.h"
10		#include "sound/dac.h"
11	8	#include "includes/n8080.h"
12	9
13	10	static const double ATTACK_RATE = 10e-6 * 500;
r26337	r26338
69	66	};
70	67
71	68
72		static void spacefev_update_SN76477_status( device_t *sn )
	69	void n8080_state::spacefev_update_SN76477_status()
73	70	{
74		n8080_state *state = sn->machine().driver_data<n8080_state>();
75	71	double dblR0 = RES_M(1.0);
76	72	double dblR1 = RES_M(1.5);
77	73
78		if (!state->m_mono_flop[0])
	74	if (!m_mono_flop[0])
79	75	{
80	76	dblR0 = 1 / (1 / RES_K(150) + 1 / dblR0); /* ? */
81	77	}
82		if (!state->m_mono_flop[1])
	78	if (!m_mono_flop[1])
83	79	{
84	80	dblR1 = 1 / (1 / RES_K(620) + 1 / dblR1); /* ? */
85	81	}
86	82
87		sn76477_decay_res_w(sn, dblR0);
	83	m_sn->decay_res_w(dblR0);
88	84
89		sn76477_vco_res_w(sn, dblR1);
	85	m_sn->vco_res_w(dblR1);
90	86
91		sn76477_enable_w(sn,
92		!state->m_mono_flop[0] &&
93		!state->m_mono_flop[1] &&
94		!state->m_mono_flop[2]);
	87	m_sn->enable_w(
	88	!m_mono_flop[0] &&
	89	!m_mono_flop[1] &&
	90	!m_mono_flop[2]);
95	91
96		sn76477_vco_w(sn, state->m_mono_flop[1]);
	92	m_sn->vco_w(m_mono_flop[1]);
97	93
98		sn76477_mixer_b_w(sn, state->m_mono_flop[0]);
	94	m_sn->mixer_b_w(m_mono_flop[0]);
99	95	}
100	96
101	97
102		static void sheriff_update_SN76477_status( device_t *sn )
	98	void n8080_state::sheriff_update_SN76477_status()
103	99	{
104		n8080_state *state = sn->machine().driver_data<n8080_state>();
105		if (state->m_mono_flop[1])
	100	if (m_mono_flop[1])
106	101	{
107		sn76477_vco_voltage_w(sn, 5);
	102	m_sn->vco_voltage_w(5);
108	103	}
109	104	else
110	105	{
111		sn76477_vco_voltage_w(sn, 0);
	106	m_sn->vco_voltage_w(0);
112	107	}
113	108
114		sn76477_enable_w(sn,
115		!state->m_mono_flop[0] &&
116		!state->m_mono_flop[1]);
	109	m_sn->enable_w(
	110	!m_mono_flop[0] &&
	111	!m_mono_flop[1]);
117	112
118		sn76477_vco_w(sn, state->m_mono_flop[0]);
	113	m_sn->vco_w(m_mono_flop[0]);
119	114
120		sn76477_mixer_b_w(sn, !state->m_mono_flop[0]);
	115	m_sn->mixer_b_w(!m_mono_flop[0]);
121	116	}
122	117
123	118
124		static void update_SN76477_status( device_t *device )
	119	void n8080_state::update_SN76477_status()
125	120	{
126		n8080_state *state = device->machine().driver_data<n8080_state>();
127		if (state->m_n8080_hardware == 1)
	121	if (m_n8080_hardware == 1)
128	122	{
129		spacefev_update_SN76477_status(device);
	123	spacefev_update_SN76477_status();
130	124	}
131		if (state->m_n8080_hardware == 2)
	125	if (m_n8080_hardware == 2)
132	126	{
133		sheriff_update_SN76477_status(device);
	127	sheriff_update_SN76477_status();
134	128	}
135	129	}
136	130
137	131
138		static void start_mono_flop( device_t *sn, int n, attotime expire )
	132	void n8080_state::start_mono_flop( int n, attotime expire )
139	133	{
140		n8080_state *state = sn->machine().driver_data<n8080_state>();
141		state->m_mono_flop[n] = 1;
	134	m_mono_flop[n] = 1;
142	135
143		update_SN76477_status(sn);
	136	update_SN76477_status();
144	137
145		state->m_sound_timer[n]->adjust(expire, n);
	138	m_sound_timer[n]->adjust(expire, n);
146	139	}
147	140
148	141
149		static void stop_mono_flop( device_t *sn, int n )
	142	void n8080_state::stop_mono_flop( int n )
150	143	{
151		n8080_state *state = sn->machine().driver_data<n8080_state>();
152		state->m_mono_flop[n] = 0;
	144	m_mono_flop[n] = 0;
153	145
154		update_SN76477_status(sn);
	146	update_SN76477_status();
155	147
156		state->m_sound_timer[n]->adjust(attotime::never, n);
	148	m_sound_timer[n]->adjust(attotime::never, n);
157	149	}
158	150
159	151
160		static TIMER_CALLBACK( stop_mono_flop_callback )
	152	TIMER_CALLBACK_MEMBER( n8080_state::stop_mono_flop_callback )
161	153	{
162		stop_mono_flop(machine.device("snsnd"), param);
	154	stop_mono_flop(param);
163	155	}
164	156
165	157
166		static void spacefev_sound_pins_changed( running_machine &machine )
	158	void n8080_state::spacefev_sound_pins_changed()
167	159	{
168		device_t *sn = machine.device("snsnd");
169		n8080_state *state = machine.driver_data<n8080_state>();
170		UINT16 changes = ~state->m_curr_sound_pins & state->m_prev_sound_pins;
	160	UINT16 changes = ~m_curr_sound_pins & m_prev_sound_pins;
171	161
172	162	if (changes & (1 << 0x3))
173	163	{
174		stop_mono_flop(sn, 1);
	164	stop_mono_flop(1);
175	165	}
176	166	if (changes & ((1 << 0x3) | (1 << 0x6)))
177	167	{
178		stop_mono_flop(sn, 2);
	168	stop_mono_flop(2);
179	169	}
180	170	if (changes & (1 << 0x3))
181	171	{
182		start_mono_flop(sn, 0, attotime::from_usec(550 * 36 * 100));
	172	start_mono_flop(0, attotime::from_usec(550 * 36 * 100));
183	173	}
184	174	if (changes & (1 << 0x6))
185	175	{
186		start_mono_flop(sn, 1, attotime::from_usec(550 * 22 * 33));
	176	start_mono_flop(1, attotime::from_usec(550 * 22 * 33));
187	177	}
188	178	if (changes & (1 << 0x4))
189	179	{
190		start_mono_flop(sn, 2, attotime::from_usec(550 * 22 * 33));
	180	start_mono_flop(2, attotime::from_usec(550 * 22 * 33));
191	181	}
192	182	if (changes & ((1 << 0x2) | (1 << 0x3) | (1 << 0x5)))
193	183	{
194		generic_pulse_irq_line(machine.device("audiocpu"), 0, 2);
	184	generic_pulse_irq_line(m_audiocpu, 0, 2);
195	185	}
196	186	}
197	187
198	188
199		static void sheriff_sound_pins_changed( running_machine &machine )
	189	void n8080_state::sheriff_sound_pins_changed()
200	190	{
201		device_t *sn = machine.device("snsnd");
202		n8080_state *state = machine.driver_data<n8080_state>();
203		UINT16 changes = ~state->m_curr_sound_pins & state->m_prev_sound_pins;
	191	UINT16 changes = ~m_curr_sound_pins & m_prev_sound_pins;
204	192
205	193	if (changes & (1 << 0x6))
206	194	{
207		stop_mono_flop(sn, 1);
	195	stop_mono_flop(1);
208	196	}
209	197	if (changes & (1 << 0x6))
210	198	{
211		start_mono_flop(sn, 0, attotime::from_usec(550 * 33 * 33));
	199	start_mono_flop(0, attotime::from_usec(550 * 33 * 33));
212	200	}
213	201	if (changes & (1 << 0x4))
214	202	{
215		start_mono_flop(sn, 1, attotime::from_usec(550 * 33 * 33));
	203	start_mono_flop(1, attotime::from_usec(550 * 33 * 33));
216	204	}
217	205	if (changes & ((1 << 0x2) | (1 << 0x3) | (1 << 0x5)))
218	206	{
219		generic_pulse_irq_line(machine.device("audiocpu"), 0, 2);
	207	generic_pulse_irq_line(m_audiocpu, 0, 2);
220	208	}
221	209	}
222	210
223	211
224		static void helifire_sound_pins_changed( running_machine &machine )
	212	void n8080_state::helifire_sound_pins_changed()
225	213	{
226		n8080_state *state = machine.driver_data<n8080_state>();
227		UINT16 changes = ~state->m_curr_sound_pins & state->m_prev_sound_pins;
	214	UINT16 changes = ~m_curr_sound_pins & m_prev_sound_pins;
228	215
229	216	/* ((state->m_curr_sound_pins >> 0xa) & 1) not emulated */
230	217	/* ((state->m_curr_sound_pins >> 0xb) & 1) not emulated */
r26337	r26338
232	219
233	220	if (changes & (1 << 6))
234	221	{
235		generic_pulse_irq_line(machine.device("audiocpu"), 0, 2);
	222	generic_pulse_irq_line(m_audiocpu, 0, 2);
236	223	}
237	224	}
238	225
239	226
240		static void sound_pins_changed( running_machine &machine )
	227	void n8080_state::sound_pins_changed()
241	228	{
242		n8080_state *state = machine.driver_data<n8080_state>();
	229	if (m_n8080_hardware == 1)
	230	spacefev_sound_pins_changed();
	231	if (m_n8080_hardware == 2)
	232	sheriff_sound_pins_changed();
	233	if (m_n8080_hardware == 3)
	234	helifire_sound_pins_changed();
243	235
244		if (state->m_n8080_hardware == 1)
245		spacefev_sound_pins_changed(machine);
246		if (state->m_n8080_hardware == 2)
247		sheriff_sound_pins_changed(machine);
248		if (state->m_n8080_hardware == 3)
249		helifire_sound_pins_changed(machine);
250
251		state->m_prev_sound_pins = state->m_curr_sound_pins;
	236	m_prev_sound_pins = m_curr_sound_pins;
252	237	}
253	238
254	239
255		static void delayed_sound_1( running_machine &machine, int data )
	240	void n8080_state::delayed_sound_1( int data )
256	241	{
257		n8080_state *state = machine.driver_data<n8080_state>();
258
259		state->m_curr_sound_pins &= ~(
	242	m_curr_sound_pins &= ~(
260	243	(1 << 0x7) |
261	244	(1 << 0x5) |
262	245	(1 << 0x6) |
r26337	r26338
264	247	(1 << 0x4) |
265	248	(1 << 0x1));
266	249
267		if (~data & 0x01) state->m_curr_sound_pins |= 1 << 0x7;
268		if (~data & 0x02) state->m_curr_sound_pins |= 1 << 0x5; /* pulse */
269		if (~data & 0x04) state->m_curr_sound_pins |= 1 << 0x6; /* pulse */
270		if (~data & 0x08) state->m_curr_sound_pins |= 1 << 0x3; /* pulse (except in Helifire) */
271		if (~data & 0x10) state->m_curr_sound_pins |= 1 << 0x4; /* pulse (except in Helifire) */
272		if (~data & 0x20) state->m_curr_sound_pins |= 1 << 0x1;
	250	if (~data & 0x01) m_curr_sound_pins |= 1 << 0x7;
	251	if (~data & 0x02) m_curr_sound_pins |= 1 << 0x5; /* pulse */
	252	if (~data & 0x04) m_curr_sound_pins |= 1 << 0x6; /* pulse */
	253	if (~data & 0x08) m_curr_sound_pins |= 1 << 0x3; /* pulse (except in Helifire) */
	254	if (~data & 0x10) m_curr_sound_pins |= 1 << 0x4; /* pulse (except in Helifire) */
	255	if (~data & 0x20) m_curr_sound_pins |= 1 << 0x1;
273	256
274		if (state->m_n8080_hardware == 1)
	257	if (m_n8080_hardware == 1)
275	258	{
276		if (data & ~state->m_prev_snd_data & 0x10)
	259	if (data & ~m_prev_snd_data & 0x10)
277	260	{
278		state->spacefev_start_red_cannon();
	261	spacefev_start_red_cannon();
279	262	}
280	263
281		state->m_spacefev_red_screen = data & 0x08;
	264	m_spacefev_red_screen = data & 0x08;
282	265	}
283	266
284		sound_pins_changed(machine);
	267	sound_pins_changed();
285	268
286		state->m_prev_snd_data = data;
	269	m_prev_snd_data = data;
287	270	}
288	271
289	272
290		static TIMER_CALLBACK( delayed_sound_1_callback )
	273	TIMER_CALLBACK_MEMBER( n8080_state::delayed_sound_1_callback )
291	274	{
292		delayed_sound_1(machine, param);
	275	delayed_sound_1(param);
293	276	}
294	277
295	278
296		static void delayed_sound_2( running_machine &machine, int data )
	279	void n8080_state::delayed_sound_2( int data )
297	280	{
298		n8080_state *state = machine.driver_data<n8080_state>();
299
300		state->m_curr_sound_pins &= ~(
	281	m_curr_sound_pins &= ~(
301	282	(1 << 0x8) |
302	283	(1 << 0x9) |
303	284	(1 << 0xa) |
r26337	r26338
305	286	(1 << 0x2) |
306	287	(1 << 0xc));
307	288
308		if (~data & 0x01) state->m_curr_sound_pins |= 1 << 0x8;
309		if (~data & 0x02) state->m_curr_sound_pins |= 1 << 0x9;
310		if (~data & 0x04) state->m_curr_sound_pins |= 1 << 0xa;
311		if (~data & 0x08) state->m_curr_sound_pins |= 1 << 0xb;
312		if (~data & 0x10) state->m_curr_sound_pins |= 1 << 0x2; /* pulse */
313		if (~data & 0x20) state->m_curr_sound_pins |= 1 << 0xc;
	289	if (~data & 0x01) m_curr_sound_pins |= 1 << 0x8;
	290	if (~data & 0x02) m_curr_sound_pins |= 1 << 0x9;
	291	if (~data & 0x04) m_curr_sound_pins |= 1 << 0xa;
	292	if (~data & 0x08) m_curr_sound_pins |= 1 << 0xb;
	293	if (~data & 0x10) m_curr_sound_pins |= 1 << 0x2; /* pulse */
	294	if (~data & 0x20) m_curr_sound_pins |= 1 << 0xc;
314	295
315		if (state->m_n8080_hardware == 1)
316		state->flip_screen_set_no_update(data & 0x20);
317		if (state->m_n8080_hardware == 3)
318		state->m_helifire_flash = data & 0x20;
	296	if (m_n8080_hardware == 1)
	297	flip_screen_set_no_update(data & 0x20);
	298	if (m_n8080_hardware == 3)
	299	m_helifire_flash = data & 0x20;
319	300
320		sound_pins_changed(machine);
	301	sound_pins_changed();
321	302	}
322	303
323	304
324		static TIMER_CALLBACK( delayed_sound_2_callback )
	305	TIMER_CALLBACK_MEMBER( n8080_state::delayed_sound_2_callback )
325	306	{
326		delayed_sound_2(machine, param);
	307	delayed_sound_2(param);
327	308	}
328	309
329	310
330	311	WRITE8_MEMBER(n8080_state::n8080_sound_1_w)
331	312	{
332		machine().scheduler().synchronize(FUNC(delayed_sound_1_callback), data); /* force CPUs to sync */
	313	machine().scheduler().synchronize(timer_expired_delegate(FUNC(n8080_state::delayed_sound_1_callback), this), data); /* force CPUs to sync */
333	314	}
334	315
335	316	WRITE8_MEMBER(n8080_state::n8080_sound_2_w)
336	317	{
337		machine().scheduler().synchronize(FUNC(delayed_sound_2_callback), data); /* force CPUs to sync */
	318	machine().scheduler().synchronize(timer_expired_delegate(FUNC(n8080_state::delayed_sound_2_callback), this), data); /* force CPUs to sync */
338	319	}
339	320
340	321
r26337	r26338
428	409
429	410	TIMER_DEVICE_CALLBACK_MEMBER(n8080_state::spacefev_vco_voltage_timer)
430	411	{
431		device_t *sn = machine().device("snsnd");
432	412	double voltage = 0;
433	413
434	414	if (m_mono_flop[2])
r26337	r26338
436	416	voltage = 5 * (1 - exp(- m_sound_timer[2]->elapsed().as_double() / 0.22));
437	417	}
438	418
439		sn76477_vco_voltage_w(sn, voltage);
	419	m_sn->vco_voltage_w(voltage);
440	420	}
441	421
442	422
r26337	r26338
457	437
458	438	SOUND_START_MEMBER(n8080_state,spacefev)
459	439	{
460		m_sound_timer[0] = machine().scheduler().timer_alloc(FUNC(stop_mono_flop_callback));
461		m_sound_timer[1] = machine().scheduler().timer_alloc(FUNC(stop_mono_flop_callback));
462		m_sound_timer[2] = machine().scheduler().timer_alloc(FUNC(stop_mono_flop_callback));
	440	m_sound_timer[0] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(n8080_state::stop_mono_flop_callback), this));
	441	m_sound_timer[1] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(n8080_state::stop_mono_flop_callback), this));
	442	m_sound_timer[2] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(n8080_state::stop_mono_flop_callback), this));
463	443
464	444	save_item(NAME(m_prev_snd_data));
465	445	save_item(NAME(m_prev_sound_pins));
r26337	r26338
479	459	m_prev_sound_pins = 0;
480	460	m_curr_sound_pins = 0;
481	461
482		delayed_sound_1(machine(), 0);
483		delayed_sound_2(machine(), 0);
	462	delayed_sound_1(0);
	463	delayed_sound_2(0);
484	464	}
485	465
486	466
487	467	SOUND_START_MEMBER(n8080_state,sheriff)
488	468	{
489		m_sound_timer[0] = machine().scheduler().timer_alloc(FUNC(stop_mono_flop_callback));
490		m_sound_timer[1] = machine().scheduler().timer_alloc(FUNC(stop_mono_flop_callback));
	469	m_sound_timer[0] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(n8080_state::stop_mono_flop_callback), this));
	470	m_sound_timer[1] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(n8080_state::stop_mono_flop_callback), this));
491	471
492	472	save_item(NAME(m_prev_snd_data));
493	473	save_item(NAME(m_prev_sound_pins));
r26337	r26338
506	486	m_prev_sound_pins = 0;
507	487	m_curr_sound_pins = 0;
508	488
509		delayed_sound_1(machine(), 0);
510		delayed_sound_2(machine(), 0);
	489	delayed_sound_1(0);
	490	delayed_sound_2(0);
511	491	}
512	492
513	493
r26337	r26338
533	513	m_prev_sound_pins = 0;
534	514	m_curr_sound_pins = 0;
535	515
536		delayed_sound_1(machine(), 0);
537		delayed_sound_2(machine(), 0);
	516	delayed_sound_1(0);
	517	delayed_sound_2(0);
538	518	}
539	519
540	520

trunk/src/mame/machine/mw8080bw.c

r26337	r26338
94	94	MACHINE_START_MEMBER(mw8080bw_state,mw8080bw)
95	95	{
96	96	mw8080bw_create_interrupt_timer();
97
98		m_sn = machine().device("snsnd");
99		m_sn1 = machine().device("sn1");
100		m_sn2 = machine().device("sn2");
101	97	}
102	98
103	99

trunk/src/mame/video/route16.c

r26337	r26338
7	7	***************************************************************************/
8	8
9	9	#include "emu.h"
10		#include "sound/sn76477.h"
11	10	#include "includes/route16.h"
12	11
13	12

trunk/src/mame/includes/astrof.h

r26337	r26338
5	5	****************************************************************************/
6	6
7	7	#include "sound/samples.h"
	8	#include "sound/sn76477.h"
8	9
9	10	class astrof_state : public driver_device
10	11	{
r26337	r26338
15	16	m_astrof_color(*this, "astrof_color"),
16	17	m_tomahawk_protection(*this, "tomahawk_prot"),
17	18	m_maincpu(*this, "maincpu"),
18		m_samples(*this, "samples") { }
	19	m_samples(*this, "samples"),
	20	m_sn(*this, "snsnd") { }
19	21
20	22	/* video-related */
21	23	required_shared_ptr<UINT8> m_videoram;
r26337	r26338
40	42	/* devices */
41	43	required_device<cpu_device> m_maincpu;
42	44	optional_device<samples_device> m_samples;  // astrof & abattle
43		device_t *m_sn; // tomahawk
	45	optional_device<sn76477_device> m_sn; // tomahawk
44	46	DECLARE_READ8_MEMBER(irq_clear_r);
45	47	DECLARE_WRITE8_MEMBER(astrof_videoram_w);
46	48	DECLARE_WRITE8_MEMBER(tomahawk_videoram_w);

trunk/src/mame/includes/route16.h

r26337	r26338
	1	#include "sound/sn76477.h"
	2
1	3	class route16_state : public driver_device
2	4	{
3	5	public:
r26337	r26338
3	5	route16_state(const machine_config &mconfig, device_type type, const char *tag)
4	6	: driver_device(mconfig, type, tag),
	7	m_sn(*this, "snsnd"),
5	8	m_sharedram(*this, "sharedram"),
6	9	m_videoram1(*this, "videoram1"),
7	10	m_videoram2(*this, "videoram2"){ }
8	11
	12	optional_device<sn76477_device> m_sn;
9	13	required_shared_ptr<UINT8> m_sharedram;
10	14	UINT8 m_ttmahjng_port_select;

trunk/src/mame/includes/mw8080bw.h

r26337	r26338
45	45	m_discrete(*this, "discrete"),
46	46	m_samples(*this, "samples"),
47	47	m_samples1(*this, "samples1"),
48		m_samples2(*this, "samples2")
	48	m_samples2(*this, "samples2"),
	49	m_sn1(*this, "sn1"),
	50	m_sn2(*this, "sn2"),
	51	m_sn(*this, "snsnd")
49	52	{ }
50	53
51	54	/* device/memory pointers */
r26337	r26338
83	86	optional_device<samples_device> m_samples;
84	87	optional_device<samples_device> m_samples1;
85	88	optional_device<samples_device> m_samples2;
86		device_t *m_sn1;
87		device_t *m_sn2;
88		device_t *m_sn;
	89	optional_device<sn76477_device> m_sn1;
	90	optional_device<sn76477_device> m_sn2;
	91	optional_device<sn76477_device> m_sn;
89	92
90	93	DECLARE_READ8_MEMBER(mw8080bw_shift_result_rev_r);
91	94	DECLARE_READ8_MEMBER(mw8080bw_reversable_shift_result_r);

trunk/src/mame/includes/8080bw.h

r26337	r26338
5	5	****************************************************************************/
6	6
7	7	#include "includes/mw8080bw.h"
	8	#include "sound/sn76477.h"
8	9	#include "sound/speaker.h"
9	10	#include "machine/eepromser.h"
10	11	/* for games in 8080bw.c */
r26337	r26338
20	21	m_claybust_gun_on(*this, "claybust_gun"),
21	22	m_discrete(*this, "discrete"),
22	23	m_speaker(*this, "speaker"),
23		m_eeprom(*this, "eeprom")
	24	m_eeprom(*this, "eeprom"),
	25	m_sn(*this, "snsnd")
24	26	{ }
25	27
26	28	/* devices/memory pointers */
r26337	r26338
29	31	optional_device<discrete_device> m_discrete;
30	32	optional_device<speaker_sound_device> m_speaker;
31	33	optional_device<eeprom_serial_93cxx_device> m_eeprom;
	34	optional_device<sn76477_device> m_sn;
32	35
33	36
34	37	/* misc game specific */

trunk/src/mame/includes/crbaloon.h

r26337	r26338
5	5	*************************************************************************/
6	6
7	7	#include "sound/discrete.h"
	8	#include "sound/sn76477.h"
8	9
9	10	#define CRBALOON_MASTER_XTAL    (XTAL_9_987MHz)
10	11
r26337	r26338
18	19	m_colorram(*this, "colorram"),
19	20	m_spriteram(*this, "spriteram"),
20	21	m_pc3092_data(*this, "pc3092_data"),
21		m_discrete(*this, "discrete"),
22		m_maincpu(*this, "maincpu") { }
	22	m_maincpu(*this, "maincpu"),
	23	m_sn(*this, "snsnd"),
	24	m_discrete(*this, "discrete") { }
23	25
24	26	required_shared_ptr<UINT8> m_videoram;
25	27	required_shared_ptr<UINT8> m_colorram;
26	28	required_shared_ptr<UINT8> m_spriteram;
27	29	required_shared_ptr<UINT8> m_pc3092_data;
	30	required_device<cpu_device> m_maincpu;
	31	required_device<sn76477_device> m_sn;
28	32	required_device<discrete_device> m_discrete;
29	33	UINT16 m_collision_address;
30	34	UINT8 m_collision_address_clear;
r26337	r26338
51	55	void pc3092_reset(void);
52	56	void pc3092_update();
53	57	void pc3259_update(void);
54		required_device<cpu_device> m_maincpu;
	58	void crbaloon_audio_set_explosion_enable(int enabled);
	59	void crbaloon_audio_set_breath_enable(int enabled);
	60	void crbaloon_audio_set_appear_enable(int enabled);
55	61	};
56	62
57	63
58	64	/*----------- defined in audio/crbaloon.c -----------*/
59	65
60		void crbaloon_audio_set_explosion_enable(device_t *sn, int enabled);
61		void crbaloon_audio_set_breath_enable(device_t *sn, int enabled);
62		void crbaloon_audio_set_appear_enable(device_t *sn, int enabled);
63	66	MACHINE_CONFIG_EXTERN( crbaloon_audio );

trunk/src/mame/includes/laserbat.h

r26337	r26338
7	7	#include "machine/6821pia.h"
8	8	#include "sound/ay8910.h"
9	9	#include "machine/s2636.h"
	10	#include "sound/sn76477.h"
10	11
11	12	class laserbat_state : public driver_device
12	13	{
r26337	r26338
20	21	m_ay2(*this, "ay2"),
21	22	m_s2636_1(*this, "s2636_1"),
22	23	m_s2636_2(*this, "s2636_2"),
23		m_s2636_3(*this, "s2636_3")
	24	m_s2636_3(*this, "s2636_3"),
	25	m_sn(*this, "snsnd")
24	26	{
25	27	}
26	28
r26337	r26338
32	34	required_device<s2636_device> m_s2636_1;
33	35	required_device<s2636_device> m_s2636_2;
34	36	required_device<s2636_device> m_s2636_3;
	37	optional_device<sn76477_device> m_sn;
35	38
36	39	/* video-related */
37	40	tilemap_t    *m_bg_tilemap;
r26337	r26338
64	67
65	68	/* device */
66	69	pia6821_device *m_pia;
67		device_t *m_sn;
68	70	tms3615_device *m_tms1;
69	71	tms3615_device *m_tms2;
70	72

trunk/src/mame/includes/n8080.h

r26337	r26338
	1	#include "cpu/mcs48/mcs48.h"
1	2	#include "sound/dac.h"
	3	#include "sound/sn76477.h"
2	4
3	5	class n8080_state : public driver_device
4	6	{
r26337	r26338
8	10	m_videoram(*this, "videoram"),
9	11	m_colorram(*this, "colorram"),
10	12	m_maincpu(*this, "maincpu"),
11		m_dac(*this, "dac") { }
	13	m_audiocpu(*this, "audiocpu"),
	14	m_dac(*this, "dac"),
	15	m_sn(*this, "snsnd") { }
12	16
13	17	/* memory pointers */
14	18	required_shared_ptr<UINT8> m_videoram;
r26337	r26338
43	47
44	48	/* devices */
45	49	required_device<cpu_device> m_maincpu;
	50	required_device<cpu_device> m_audiocpu;
46	51	required_device<dac_device> m_dac;
	52	optional_device<sn76477_device> m_sn;
47	53	DECLARE_WRITE8_MEMBER(n8080_shift_bits_w);
48	54	DECLARE_WRITE8_MEMBER(n8080_shift_data_w);
49	55	DECLARE_READ8_MEMBER(n8080_shift_r);
r26337	r26338
90	96	TIMER_DEVICE_CALLBACK_MEMBER(helifire_dac_volume_timer);
91	97	void spacefev_start_red_cannon(  );
92	98	void helifire_next_line(  );
	99	void spacefev_update_SN76477_status();
	100	void sheriff_update_SN76477_status();
	101	void update_SN76477_status();
	102	void start_mono_flop( int n, attotime expire );
	103	void stop_mono_flop( int n );
	104	TIMER_CALLBACK_MEMBER( stop_mono_flop_callback );
	105	void spacefev_sound_pins_changed();
	106	void sheriff_sound_pins_changed();
	107	void helifire_sound_pins_changed();
	108	void sound_pins_changed();
	109	void delayed_sound_1( int data );
	110	TIMER_CALLBACK_MEMBER( delayed_sound_1_callback );
	111	void delayed_sound_2( int data );
	112	TIMER_CALLBACK_MEMBER( delayed_sound_2_callback );
93	113	};
94	114
95	115	/*----------- defined in audio/n8080.c -----------*/

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team