Previous

199869 Revisions

Next

r20637 Thursday 31st January, 2013 at 15:46:45 UTC by Andrew Gardner
Modernize the Volume and RC filter sound devices. [Andrew Gardner]

[src/emu/sound]	flt_rc.c flt_rc.h flt_vol.c flt_vol.h
[src/mame/audio]	scramble.c timeplt.c
[src/mame/drivers]	darius.c ddribble.c galaxold.c junofrst.c lockon.c megazone.c ninjaw.c othunder.c scramble.c taito_z.c tp84.c warriorb.c xexex.c
[src/mame/includes]	darius.h lockon.h ninjaw.h othunder.h warriorb.h xexex.h

trunk/src/mame/includes/darius.h

r20636	r20637
4	4
5	5	*************************************************************************/
6	6
	7	#include <sound/flt_vol.h>
	8
7	9	#define DARIUS_VOL_MAX    (3*2 + 2)
8	10	#define DARIUS_PAN_MAX    (2 + 2 + 1)   /* FM 2port + PSG 2port + DA 1port */
9	11
r20636	r20637
44	46	device_t *m_mscreen;
45	47	device_t *m_rscreen;
46	48
47		device_t *m_filter0_0l;
48		device_t *m_filter0_0r;
49		device_t *m_filter0_1l;
50		device_t *m_filter0_1r;
51		device_t *m_filter0_2l;
52		device_t *m_filter0_2r;
53		device_t *m_filter0_3l;
54		device_t *m_filter0_3r;
55		device_t *m_filter1_0l;
56		device_t *m_filter1_0r;
57		device_t *m_filter1_1l;
58		device_t *m_filter1_1r;
59		device_t *m_filter1_2l;
60		device_t *m_filter1_2r;
61		device_t *m_filter1_3l;
62		device_t *m_filter1_3r;
63		device_t *m_msm5205_l;
64		device_t *m_msm5205_r;
	49	filter_volume_device *m_filter0_0l;
	50	filter_volume_device *m_filter0_0r;
	51	filter_volume_device *m_filter0_1l;
	52	filter_volume_device *m_filter0_1r;
	53	filter_volume_device *m_filter0_2l;
	54	filter_volume_device *m_filter0_2r;
	55	filter_volume_device *m_filter0_3l;
	56	filter_volume_device *m_filter0_3r;
	57	filter_volume_device *m_filter1_0l;
	58	filter_volume_device *m_filter1_0r;
	59	filter_volume_device *m_filter1_1l;
	60	filter_volume_device *m_filter1_1r;
	61	filter_volume_device *m_filter1_2l;
	62	filter_volume_device *m_filter1_2r;
	63	filter_volume_device *m_filter1_3l;
	64	filter_volume_device *m_filter1_3r;
	65	filter_volume_device *m_msm5205_l;
	66	filter_volume_device *m_msm5205_r;
65	67	DECLARE_WRITE16_MEMBER(cpua_ctrl_w);
66	68	DECLARE_WRITE16_MEMBER(darius_watchdog_w);
67	69	DECLARE_READ16_MEMBER(darius_ioc_r);

trunk/src/mame/includes/xexex.h

r20636	r20637
5	5	*************************************************************************/
6	6
7	7	#include <video/k053250.h>
	8	#include <sound/flt_vol.h>
8	9
9	10	class xexex_state : public driver_device
10	11	{
r20636	r20637
38	39	cpu_device *m_maincpu;
39	40	cpu_device *m_audiocpu;
40	41	device_t *m_k054539;
41		device_t *m_filter1l;
42		device_t *m_filter1r;
43		device_t *m_filter2l;
44		device_t *m_filter2r;
	42	filter_volume_device *m_filter1l;
	43	filter_volume_device *m_filter1r;
	44	filter_volume_device *m_filter2l;
	45	filter_volume_device *m_filter2r;
45	46	device_t *m_k056832;
46	47	device_t *m_k053246;
47	48	k053250_t *m_k053250;

trunk/src/mame/includes/lockon.h

r20636	r20637
4	4
5	5	*************************************************************************/
6	6
	7	#include <sound/flt_vol.h>
	8
7	9	/* Calculated from CRT controller writes */
8	10	#define PIXEL_CLOCK            (XTAL_21MHz / 3)
9	11	#define FRAMEBUFFER_CLOCK      XTAL_10MHz
r20636	r20637
68	70	cpu_device *m_audiocpu;
69	71	device_t *m_ground;
70	72	device_t *m_object;
71		device_t *m_f2203_1l;
72		device_t *m_f2203_2l;
73		device_t *m_f2203_3l;
74		device_t *m_f2203_1r;
75		device_t *m_f2203_2r;
76		device_t *m_f2203_3r;
	73	filter_volume_device *m_f2203_1l;
	74	filter_volume_device *m_f2203_2l;
	75	filter_volume_device *m_f2203_3l;
	76	filter_volume_device *m_f2203_1r;
	77	filter_volume_device *m_f2203_2r;
	78	filter_volume_device *m_f2203_3r;
77	79	DECLARE_READ16_MEMBER(lockon_crtc_r);
78	80	DECLARE_WRITE16_MEMBER(lockon_crtc_w);
79	81	DECLARE_WRITE16_MEMBER(lockon_char_w);

trunk/src/mame/includes/ninjaw.h

r20636	r20637
4	4
5	5	*************************************************************************/
6	6
	7	#include <sound/flt_vol.h>
	8
7	9	class ninjaw_state : public driver_device
8	10	{
9	11	public:
r20636	r20637
30	32	device_t *m_lscreen;
31	33	device_t *m_mscreen;
32	34	device_t *m_rscreen;
33		device_t *m_2610_1l;
34		device_t *m_2610_1r;
35		device_t *m_2610_2l;
36		device_t *m_2610_2r;
	35	filter_volume_device *m_2610_1l;
	36	filter_volume_device *m_2610_1r;
	37	filter_volume_device *m_2610_2l;
	38	filter_volume_device *m_2610_2r;
37	39	DECLARE_WRITE16_MEMBER(cpua_ctrl_w);
38	40	DECLARE_WRITE8_MEMBER(sound_bankswitch_w);
39	41	DECLARE_WRITE16_MEMBER(ninjaw_sound_w);

trunk/src/mame/includes/warriorb.h

r20636	r20637
4	4
5	5	*************************************************************************/
6	6
	7	#include <sound/flt_vol.h>
	8
7	9	class warriorb_state : public driver_device
8	10	{
9	11	public:
r20636	r20637
26	28	device_t *m_tc0100scn_2;
27	29	device_t *m_lscreen;
28	30	device_t *m_rscreen;
29		device_t *m_2610_1l;
30		device_t *m_2610_1r;
31		device_t *m_2610_2l;
32		device_t *m_2610_2r;
	31	filter_volume_device *m_2610_1l;
	32	filter_volume_device *m_2610_1r;
	33	filter_volume_device *m_2610_2l;
	34	filter_volume_device *m_2610_2r;
33	35	DECLARE_WRITE8_MEMBER(sound_bankswitch_w);
34	36	DECLARE_WRITE16_MEMBER(warriorb_sound_w);
35	37	DECLARE_READ16_MEMBER(warriorb_sound_r);

trunk/src/mame/includes/othunder.h

r20636	r20637
5	5	*************************************************************************/
6	6
7	7	#include "machine/eeprom.h"
	8	#include <sound/flt_vol.h>
8	9
9	10	struct othunder_tempsprite
10	11	{
r20636	r20637
44	45	device_t *m_tc0100scn;
45	46	device_t *m_tc0110pcr;
46	47	device_t *m_tc0140syt;
47		device_t *m_2610_0l;
48		device_t *m_2610_0r;
49		device_t *m_2610_1l;
50		device_t *m_2610_1r;
51		device_t *m_2610_2l;
52		device_t *m_2610_2r;
	48	filter_volume_device *m_2610_0l;
	49	filter_volume_device *m_2610_0r;
	50	filter_volume_device *m_2610_1l;
	51	filter_volume_device *m_2610_1r;
	52	filter_volume_device *m_2610_2l;
	53	filter_volume_device *m_2610_2r;
53	54	DECLARE_WRITE16_MEMBER(irq_ack_w);
54	55	DECLARE_WRITE16_MEMBER(othunder_tc0220ioc_w);
55	56	DECLARE_READ16_MEMBER(othunder_tc0220ioc_r);

trunk/src/mame/drivers/galaxold.c

r20636	r20637
368	368	#include "sound/ay8910.h"
369	369	#include "sound/sn76496.h"
370	370	#include "sound/dac.h"
371		#include "sound/flt_rc.h"
372	371	#include "audio/galaxian.h"
373	372	#include "includes/galaxold.h"
374	373

trunk/src/mame/drivers/warriorb.c

r20636	r20637
195	195
196	196	WRITE8_MEMBER(warriorb_state::warriorb_pancontrol)
197	197	{
198		device_t *flt = NULL;
	198	filter_volume_device *flt = NULL;
199	199	offset &= 3;
200	200
201	201	switch (offset)
r20636	r20637
208	208
209	209	m_pandata[offset] = (data << 1) + data;   /* original volume*3 */
210	210	//popmessage(" pan %02x %02x %02x %02x", m_pandata[0], m_pandata[1], m_pandata[2], m_pandata[3] );
211		flt_volume_set_volume(flt, m_pandata[offset] / 100.0);
	211	flt->flt_volume_set_volume(m_pandata[offset] / 100.0);
212	212	}
213	213
214	214
r20636	r20637
517	517	m_lscreen = machine().device("lscreen");
518	518	m_rscreen = machine().device("rscreen");
519	519
520		m_2610_1l = machine().device("2610.1.l");
521		m_2610_1r = machine().device("2610.1.r");
522		m_2610_2l = machine().device("2610.2.l");
523		m_2610_2r = machine().device("2610.2.r");
	520	m_2610_1l = machine().device<filter_volume_device>("2610.1.l");
	521	m_2610_1r = machine().device<filter_volume_device>("2610.1.r");
	522	m_2610_2l = machine().device<filter_volume_device>("2610.2.l");
	523	m_2610_2r = machine().device<filter_volume_device>("2610.2.r");
524	524
525	525	save_item(NAME(m_banknum));
526	526	save_item(NAME(m_pandata));
r20636	r20637
585	585	MCFG_SOUND_ROUTE(2, "2610.2.l", 1.0)
586	586	MCFG_SOUND_ROUTE(2, "2610.2.r", 1.0)
587	587
588		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	588	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
589	589	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
590		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	590	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
591	591	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
592		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	592	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
593	593	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
594		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	594	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
595	595	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
596	596
597	597	MCFG_TC0140SYT_ADD("tc0140syt", warriorb_tc0140syt_intf)
r20636	r20637
648	648	MCFG_SOUND_ROUTE(2, "2610.2.l", 1.0)
649	649	MCFG_SOUND_ROUTE(2, "2610.2.r", 1.0)
650	650
651		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	651	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
652	652	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
653		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	653	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
654	654	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
655		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	655	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
656	656	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
657		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	657	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
658	658	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
659	659
660	660	MCFG_TC0140SYT_ADD("tc0140syt", warriorb_tc0140syt_intf)

trunk/src/mame/drivers/lockon.c

r20636	r20637
405	405	double lgain = gains[data & 0xf];
406	406	double rgain = gains[data >> 4];
407	407
408		flt_volume_set_volume(m_f2203_1l, lgain);
409		flt_volume_set_volume(m_f2203_2l, lgain);
410		flt_volume_set_volume(m_f2203_3l, lgain);
	408	m_f2203_1l->flt_volume_set_volume(lgain);
	409	m_f2203_2l->flt_volume_set_volume(lgain);
	410	m_f2203_3l->flt_volume_set_volume(lgain);
411	411
412		flt_volume_set_volume(m_f2203_1r, rgain);
413		flt_volume_set_volume(m_f2203_2r, rgain);
414		flt_volume_set_volume(m_f2203_3r, rgain);
	412	m_f2203_1r->flt_volume_set_volume(rgain);
	413	m_f2203_2r->flt_volume_set_volume(rgain);
	414	m_f2203_3r->flt_volume_set_volume(rgain);
415	415	}
416	416
417	417	static void ym2203_irq(device_t *device, int irq)
r20636	r20637
456	456	m_audiocpu = machine().device<cpu_device>("audiocpu");
457	457	m_ground = machine().device("ground");
458	458	m_object = machine().device("object");
459		m_f2203_1l = machine().device("f2203.1l");
460		m_f2203_2l = machine().device("f2203.2l");
461		m_f2203_3l = machine().device("f2203.3l");
462		m_f2203_1r = machine().device("f2203.1r");
463		m_f2203_2r = machine().device("f2203.2r");
464		m_f2203_3r = machine().device("f2203.3r");
	459	m_f2203_1l = machine().device<filter_volume_device>("f2203.1l");
	460	m_f2203_2l = machine().device<filter_volume_device>("f2203.2l");
	461	m_f2203_3l = machine().device<filter_volume_device>("f2203.3l");
	462	m_f2203_1r = machine().device<filter_volume_device>("f2203.1r");
	463	m_f2203_2r = machine().device<filter_volume_device>("f2203.2r");
	464	m_f2203_3r = machine().device<filter_volume_device>("f2203.3r");
465	465
466	466	save_item(NAME(m_ground_ctrl));
467	467	save_item(NAME(m_scroll_h));
r20636	r20637
544	544	MCFG_SOUND_ROUTE(3, "f2203.3l", 1.0)
545	545	MCFG_SOUND_ROUTE(3, "f2203.3r", 1.0)
546	546
547		MCFG_SOUND_ADD("f2203.1l", FILTER_VOLUME, 0)
	547	MCFG_FILTER_VOLUME_ADD("f2203.1l", 0)
548	548	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
549		MCFG_SOUND_ADD("f2203.1r", FILTER_VOLUME, 0)
	549	MCFG_FILTER_VOLUME_ADD("f2203.1r", 0)
550	550	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
551		MCFG_SOUND_ADD("f2203.2l", FILTER_VOLUME, 0)
	551	MCFG_FILTER_VOLUME_ADD("f2203.2l", 0)
552	552	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
553		MCFG_SOUND_ADD("f2203.2r", FILTER_VOLUME, 0)
	553	MCFG_FILTER_VOLUME_ADD("f2203.2r", 0)
554	554	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
555		MCFG_SOUND_ADD("f2203.3l", FILTER_VOLUME, 0)
	555	MCFG_FILTER_VOLUME_ADD("f2203.3l", 0)
556	556	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
557		MCFG_SOUND_ADD("f2203.3r", FILTER_VOLUME, 0)
	557	MCFG_FILTER_VOLUME_ADD("f2203.3r", 0)
558	558	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
559	559	MACHINE_CONFIG_END
560	560

trunk/src/mame/drivers/megazone.c

r20636	r20637
51	51	C += 220000;    /* 220000pF = 0.22uF */
52	52
53	53	data >>= 2;
54		filter_rc_set_RC(machine().device(fltname[i]),FLT_RC_LOWPASS,1000,2200,200,CAP_P(C));
	54	dynamic_cast<filter_rc_device*>(machine().device(fltname[i]))->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 2200, 200, CAP_P(C));
55	55	}
56	56	}
57	57
r20636	r20637
289	289	MCFG_DAC_ADD("dac")
290	290	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
291	291
292		MCFG_SOUND_ADD("filter.0.0", FILTER_RC, 0)
	292	MCFG_FILTER_RC_ADD("filter.0.0", 0)
293	293	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
294		MCFG_SOUND_ADD("filter.0.1", FILTER_RC, 0)
	294	MCFG_FILTER_RC_ADD("filter.0.1", 0)
295	295	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
296		MCFG_SOUND_ADD("filter.0.2", FILTER_RC, 0)
	296	MCFG_FILTER_RC_ADD("filter.0.2", 0)
297	297	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
298	298	MACHINE_CONFIG_END
299	299

trunk/src/mame/drivers/othunder.c

r20636	r20637
424	424	because we are using the AY-3-8910 emulation. */
425	425	volr = (m_pan[0] + m_pan[2]) * 100 / (2 * 0x1f);
426	426	voll = (m_pan[1] + m_pan[3]) * 100 / (2 * 0x1f);
427		flt_volume_set_volume(m_2610_0l, voll / 100.0);
428		flt_volume_set_volume(m_2610_0r, volr / 100.0);
	427	m_2610_0l->flt_volume_set_volume(voll / 100.0);
	428	m_2610_0r->flt_volume_set_volume(volr / 100.0);
429	429
430	430	/* CH1 */
431	431	volr = m_pan[0] * 100 / 0x1f;
432	432	voll = m_pan[1] * 100 / 0x1f;
433		flt_volume_set_volume(m_2610_1l, voll / 100.0);
434		flt_volume_set_volume(m_2610_1r, volr / 100.0);
	433	m_2610_1l->flt_volume_set_volume(voll / 100.0);
	434	m_2610_1r->flt_volume_set_volume(volr / 100.0);
435	435
436	436	/* CH2 */
437	437	volr = m_pan[2] * 100 / 0x1f;
438	438	voll = m_pan[3] * 100 / 0x1f;
439		flt_volume_set_volume(m_2610_2l, voll / 100.0);
440		flt_volume_set_volume(m_2610_2r, volr / 100.0);
	439	m_2610_2l->flt_volume_set_volume(voll / 100.0);
	440	m_2610_2r->flt_volume_set_volume(volr / 100.0);
441	441	}
442	442
443	443
r20636	r20637
674	674	m_tc0100scn = machine().device("tc0100scn");
675	675	m_tc0110pcr = machine().device("tc0110pcr");
676	676	m_tc0140syt = machine().device("tc0140syt");
677		m_2610_0l = machine().device("2610.0l");
678		m_2610_0r = machine().device("2610.0r");
679		m_2610_1l = machine().device("2610.1l");
680		m_2610_1r = machine().device("2610.1r");
681		m_2610_2l = machine().device("2610.2l");
682		m_2610_2r = machine().device("2610.2r");
	677	m_2610_0l = machine().device<filter_volume_device>("2610.0l");
	678	m_2610_0r = machine().device<filter_volume_device>("2610.0r");
	679	m_2610_1l = machine().device<filter_volume_device>("2610.1l");
	680	m_2610_1r = machine().device<filter_volume_device>("2610.1r");
	681	m_2610_2l = machine().device<filter_volume_device>("2610.2l");
	682	m_2610_2r = machine().device<filter_volume_device>("2610.2r");
683	683
684	684	save_item(NAME(m_vblank_irq));
685	685	save_item(NAME(m_ad_irq));
r20636	r20637
738	738	MCFG_SOUND_ROUTE(2, "2610.2l", 1.0)
739	739	MCFG_SOUND_ROUTE(2, "2610.2r", 1.0)
740	740
741		MCFG_SOUND_ADD("2610.0l", FILTER_VOLUME, 0)
	741	MCFG_FILTER_VOLUME_ADD("2610.0l", 0)
742	742	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
743		MCFG_SOUND_ADD("2610.0r", FILTER_VOLUME, 0)
	743	MCFG_FILTER_VOLUME_ADD("2610.0r", 0)
744	744	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
745		MCFG_SOUND_ADD("2610.1l", FILTER_VOLUME, 0)
	745	MCFG_FILTER_VOLUME_ADD("2610.1l", 0)
746	746	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
747		MCFG_SOUND_ADD("2610.1r", FILTER_VOLUME, 0)
	747	MCFG_FILTER_VOLUME_ADD("2610.1r", 0)
748	748	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
749		MCFG_SOUND_ADD("2610.2l", FILTER_VOLUME, 0)
	749	MCFG_FILTER_VOLUME_ADD("2610.2l", 0)
750	750	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
751		MCFG_SOUND_ADD("2610.2r", FILTER_VOLUME, 0)
	751	MCFG_FILTER_VOLUME_ADD("2610.2r", 0)
752	752	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
753	753
754	754	MCFG_TC0140SYT_ADD("tc0140syt", othunder_tc0140syt_intf)

trunk/src/mame/drivers/ddribble.c

r20636	r20637
98	98	vlm5030_set_rom(device, &SPEECH_ROM[data & 0x08 ? 0x10000 : 0]);
99	99
100	100	/* b2 : SSG-C rc filter enable */
101		filter_rc_set_RC(m_filter3, FLT_RC_LOWPASS, 1000, 2200, 1000, data & 0x04 ? CAP_N(150) : 0); /* YM2203-SSG-C */
	101	dynamic_cast<filter_rc_device*>(m_filter3)->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 2200, 1000, data & 0x04 ? CAP_N(150) : 0); /* YM2203-SSG-C */
102	102
103	103	/* b1 : SSG-B rc filter enable */
104		filter_rc_set_RC(m_filter2, FLT_RC_LOWPASS, 1000, 2200, 1000, data & 0x02 ? CAP_N(150) : 0); /* YM2203-SSG-B */
	104	dynamic_cast<filter_rc_device*>(m_filter2)->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 2200, 1000, data & 0x02 ? CAP_N(150) : 0); /* YM2203-SSG-B */
105	105
106	106	/* b0 : SSG-A rc filter enable */
107		filter_rc_set_RC(m_filter1, FLT_RC_LOWPASS, 1000, 2200, 1000, data & 0x01 ? CAP_N(150) : 0); /* YM2203-SSG-A */
	107	dynamic_cast<filter_rc_device*>(m_filter1)->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 2200, 1000, data & 0x01 ? CAP_N(150) : 0); /* YM2203-SSG-A */
108	108	}
109	109
110	110
r20636	r20637
320	320	MCFG_SOUND_CONFIG(vlm5030_config)
321	321	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
322	322
323		MCFG_SOUND_ADD("filter1", FILTER_RC, 0)
	323	MCFG_FILTER_RC_ADD("filter1", 0)
324	324	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
325		MCFG_SOUND_ADD("filter2", FILTER_RC, 0)
	325	MCFG_FILTER_RC_ADD("filter2", 0)
326	326	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
327		MCFG_SOUND_ADD("filter3", FILTER_RC, 0)
	327	MCFG_FILTER_RC_ADD("filter3", 0)
328	328	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
329	329	MACHINE_CONFIG_END
330	330

trunk/src/mame/drivers/tp84.c

r20636	r20637
98	98	C = 0;
99	99	if (offset & 0x008) C +=  47000;    /*  47000pF = 0.047uF */
100	100	if (offset & 0x010) C += 470000;    /* 470000pF = 0.47uF */
101		filter_rc_set_RC(machine().device("filter1"),FLT_RC_LOWPASS,1000,2200,1000,CAP_P(C));
	101	dynamic_cast<filter_rc_device*>(machine().device("filter1"))->filter_rc_set_RC(FLT_RC_LOWPASS,1000,2200,1000,CAP_P(C));
102	102
103	103	/* 76489 #1 (optional) */
104	104	C = 0;
105	105	if (offset & 0x020) C +=  47000;    /*  47000pF = 0.047uF */
106	106	if (offset & 0x040) C += 470000;    /* 470000pF = 0.47uF */
107		//  filter_rc_set_RC(machine().device("filter2"),1000,2200,1000,C);
	107	//  dynamic_cast<filter_rc_device*>(machine().device("filter2"))->filter_rc_set_RC(,1000,2200,1000,C);
108	108
109	109	/* 76489 #2 */
110	110	C = 0;
111	111	if (offset & 0x080) C += 470000;    /* 470000pF = 0.47uF */
112		filter_rc_set_RC(machine().device("filter2"),FLT_RC_LOWPASS,1000,2200,1000,CAP_P(C));
	112	dynamic_cast<filter_rc_device*>(machine().device("filter2"))->filter_rc_set_RC(FLT_RC_LOWPASS,1000,2200,1000,CAP_P(C));
113	113
114	114	/* 76489 #3 */
115	115	C = 0;
116	116	if (offset & 0x100) C += 470000;    /* 470000pF = 0.47uF */
117		filter_rc_set_RC(machine().device("filter3"),FLT_RC_LOWPASS,1000,2200,1000,CAP_P(C));
	117	dynamic_cast<filter_rc_device*>(machine().device("filter3"))->filter_rc_set_RC(FLT_RC_LOWPASS,1000,2200,1000,CAP_P(C));
118	118	}
119	119
120	120	WRITE8_MEMBER(tp84_state::tp84_sh_irqtrigger_w)
r20636	r20637
346	346	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "filter3", 0.75)
347	347	MCFG_SOUND_CONFIG(psg_intf)
348	348
349		MCFG_SOUND_ADD("filter1", FILTER_RC, 0)
	349	MCFG_FILTER_RC_ADD("filter1", 0)
350	350	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
351		MCFG_SOUND_ADD("filter2", FILTER_RC, 0)
	351	MCFG_FILTER_RC_ADD("filter2", 0)
352	352	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
353		MCFG_SOUND_ADD("filter3", FILTER_RC, 0)
	353	MCFG_FILTER_RC_ADD("filter3", 0)
354	354	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
355	355	MACHINE_CONFIG_END
356	356

trunk/src/mame/drivers/scramble.c

r20636	r20637
30	30	#include "cpu/s2650/s2650.h"
31	31	#include "sound/ay8910.h"
32	32	#include "sound/dac.h"
33		#include "sound/flt_rc.h"
34	33	#include "machine/7474.h"
35	34	#include "machine/i8255.h"
36	35	#include "includes/scramble.h"

trunk/src/mame/drivers/junofrst.c

r20636	r20637
230	230	C += 220000;    /* 220000pF = 0.22uF */
231	231
232	232	data >>= 2;
233		filter_rc_set_RC(filter[i], FLT_RC_LOWPASS, 1000, 2200, 200, CAP_P(C));
	233	dynamic_cast<filter_rc_device*>(filter[i])->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 2200, 200, CAP_P(C));
234	234	}
235	235	}
236	236
r20636	r20637
453	453	MCFG_DAC_ADD("dac")
454	454	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
455	455
456		MCFG_SOUND_ADD("filter.0.0", FILTER_RC, 0)
	456	MCFG_FILTER_RC_ADD("filter.0.0", 0)
457	457	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
458		MCFG_SOUND_ADD("filter.0.1", FILTER_RC, 0)
	458	MCFG_FILTER_RC_ADD("filter.0.1", 0)
459	459	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
460		MCFG_SOUND_ADD("filter.0.2", FILTER_RC, 0)
	460	MCFG_FILTER_RC_ADD("filter.0.2", 0)
461	461	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
462	462	MACHINE_CONFIG_END
463	463

trunk/src/mame/drivers/taito_z.c

r20636	r20637
1475	1475	WRITE8_MEMBER(taitoz_state::taitoz_pancontrol)
1476	1476	{
1477	1477	static const char *const fltname[] = { "2610.1.r", "2610.1.l", "2610.2.r", "2610.2.l" };
1478		flt_volume_set_volume(machine().device(fltname[offset & 3]), data / 255.0f);
	1478	dynamic_cast<filter_volume_device*>(machine().device(fltname[offset & 3]))->flt_volume_set_volume(data / 255.0f);
1479	1479	}
1480	1480
1481	1481	WRITE16_MEMBER(taitoz_state::spacegun_pancontrol)
r20636	r20637
3122	3122	MCFG_SOUND_ROUTE(2, "2610.2.l", 2.0)
3123	3123	MCFG_SOUND_ROUTE(2, "2610.2.r", 2.0)
3124	3124
3125		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3125	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3126	3126	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rear", 1.0)
3127		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3127	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3128	3128	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "front", 1.0)
3129		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3129	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3130	3130	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rear", 1.0)
3131		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3131	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3132	3132	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "front", 1.0)
3133	3133
3134	3134	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3184	3184	MCFG_SOUND_ROUTE(2, "2610.2.l", 1.0)
3185	3185	MCFG_SOUND_ROUTE(2, "2610.2.r", 1.0)
3186	3186
3187		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3187	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3188	3188	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rear", 1.0)
3189		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3189	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3190	3190	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "front", 1.0)
3191		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3191	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3192	3192	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rear", 1.0)
3193		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3193	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3194	3194	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "front", 1.0)
3195	3195
3196	3196	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3247	3247	MCFG_SOUND_ROUTE(2, "2610.2.l", 20.0)
3248	3248	MCFG_SOUND_ROUTE(2, "2610.2.r", 20.0)
3249	3249
3250		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3250	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3251	3251	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3252		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3252	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3253	3253	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3254		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3254	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3255	3255	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3256		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3256	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3257	3257	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3258	3258
3259	3259	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3306	3306	MCFG_SOUND_ROUTE(2, "2610.2.l", 28.0)
3307	3307	MCFG_SOUND_ROUTE(2, "2610.2.r", 28.0)
3308	3308
3309		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3309	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3310	3310	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3311		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3311	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3312	3312	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3313		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3313	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3314	3314	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3315		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3315	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3316	3316	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3317	3317
3318	3318	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3377	3377	MCFG_SOUND_ROUTE(2, "2610.2.l", 2.0)
3378	3378	MCFG_SOUND_ROUTE(2, "2610.2.r", 2.0)
3379	3379
3380		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3380	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3381	3381	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3382		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3382	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3383	3383	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3384		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3384	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3385	3385	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3386		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3386	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3387	3387	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3388	3388
3389	3389	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3441	3441	MCFG_SOUND_ROUTE(2, "2610.2.l", 2.0)
3442	3442	MCFG_SOUND_ROUTE(2, "2610.2.r", 2.0)
3443	3443
3444		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3444	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3445	3445	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rear", 1.0)
3446		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3446	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3447	3447	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "front", 1.0)
3448		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3448	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3449	3449	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rear", 1.0)
3450		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3450	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3451	3451	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "front", 1.0)
3452	3452
3453	3453	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3504	3504	MCFG_SOUND_ROUTE(2, "2610.2.l", 2.0)
3505	3505	MCFG_SOUND_ROUTE(2, "2610.2.r", 2.0)
3506	3506
3507		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3507	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3508	3508	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3509		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3509	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3510	3510	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3511		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3511	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3512	3512	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3513		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3513	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3514	3514	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3515	3515
3516	3516	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3563	3563	MCFG_SOUND_ROUTE(2, "2610.2.l", 8.0)
3564	3564	MCFG_SOUND_ROUTE(2, "2610.2.r", 8.0)
3565	3565
3566		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3566	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3567	3567	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3568		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3568	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3569	3569	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3570		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3570	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3571	3571	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3572		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3572	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3573	3573	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3574	3574
3575	3575	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3625	3625	MCFG_SOUND_ROUTE(2, "2610.2.l", 8.0)
3626	3626	MCFG_SOUND_ROUTE(2, "2610.2.r", 8.0)
3627	3627
3628		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3628	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3629	3629	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3630		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3630	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3631	3631	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3632		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3632	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3633	3633	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3634		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3634	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3635	3635	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3636	3636
3637	3637	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)
r20636	r20637
3687	3687	MCFG_SOUND_ROUTE(2, "2610.2.l", 8.0)
3688	3688	MCFG_SOUND_ROUTE(2, "2610.2.r", 8.0)
3689	3689
3690		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	3690	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
3691	3691	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3692		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	3692	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
3693	3693	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3694		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	3694	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
3695	3695	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
3696		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	3696	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
3697	3697	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
3698	3698
3699	3699	MCFG_TC0140SYT_ADD("tc0140syt", taitoz_tc0140syt_intf)

trunk/src/mame/drivers/ninjaw.c

r20636	r20637
389	389
390	390	WRITE8_MEMBER(ninjaw_state::ninjaw_pancontrol)
391	391	{
392		device_t *flt = NULL;
	392	filter_volume_device *flt = NULL;
393	393	offset &= 3;
394	394
395	395	switch (offset)
r20636	r20637
402	402
403	403	m_pandata[offset] = (float)data * (100.f / 255.0f);
404	404	//popmessage(" pan %02x %02x %02x %02x", m_pandata[0], m_pandata[1], m_pandata[2], m_pandata[3] );
405		flt_volume_set_volume(flt, m_pandata[offset] / 100.0);
	405	flt->flt_volume_set_volume(m_pandata[offset] / 100.0);
406	406	}
407	407
408	408
r20636	r20637
811	811	m_mscreen = machine().device("mscreen");
812	812	m_rscreen = machine().device("rscreen");
813	813
814		m_2610_1l = machine().device("2610.1.l");
815		m_2610_1r = machine().device("2610.1.r");
816		m_2610_2l = machine().device("2610.2.l");
817		m_2610_2r = machine().device("2610.2.r");
	814	m_2610_1l = machine().device<filter_volume_device>("2610.1.l");
	815	m_2610_1r = machine().device<filter_volume_device>("2610.1.r");
	816	m_2610_2l = machine().device<filter_volume_device>("2610.2.l");
	817	m_2610_2r = machine().device<filter_volume_device>("2610.2.r");
818	818
819	819	save_item(NAME(m_cpua_ctrl));
820	820	save_item(NAME(m_banknum));
r20636	r20637
897	897	MCFG_SOUND_ROUTE(2, "2610.2.l", 1.0)
898	898	MCFG_SOUND_ROUTE(2, "2610.2.r", 1.0)
899	899
900		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	900	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
901	901	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
902		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	902	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
903	903	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
904		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	904	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
905	905	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
906		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	906	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
907	907	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
908	908
909	909	//  MCFG_SOUND_ADD("subwoofer", SUBWOOFER, 0)
r20636	r20637
977	977	MCFG_SOUND_ROUTE(2, "2610.2.l", 1.0)
978	978	MCFG_SOUND_ROUTE(2, "2610.2.r", 1.0)
979	979
980		MCFG_SOUND_ADD("2610.1.l", FILTER_VOLUME, 0)
	980	MCFG_FILTER_VOLUME_ADD("2610.1.l", 0)
981	981	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
982		MCFG_SOUND_ADD("2610.1.r", FILTER_VOLUME, 0)
	982	MCFG_FILTER_VOLUME_ADD("2610.1.r", 0)
983	983	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
984		MCFG_SOUND_ADD("2610.2.l", FILTER_VOLUME, 0)
	984	MCFG_FILTER_VOLUME_ADD("2610.2.l", 0)
985	985	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
986		MCFG_SOUND_ADD("2610.2.r", FILTER_VOLUME, 0)
	986	MCFG_FILTER_VOLUME_ADD("2610.2.r", 0)
987	987	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
988	988
989	989	//  MCFG_SOUND_ADD("subwoofer", SUBWOOFER, 0)

trunk/src/mame/drivers/xexex.c

r20636	r20637
245	245	static void ym_set_mixing(device_t *device, double left, double right)
246	246	{
247	247	xexex_state *state = device->machine().driver_data<xexex_state>();
248		flt_volume_set_volume(state->m_filter1l, (71.0 * left) / 55.0);
249		flt_volume_set_volume(state->m_filter1r, (71.0 * right) / 55.0);
250		flt_volume_set_volume(state->m_filter2l, (71.0 * left) / 55.0);
251		flt_volume_set_volume(state->m_filter2r, (71.0 * right) / 55.0);
	248	state->m_filter1l->flt_volume_set_volume((71.0 * left) / 55.0);
	249	state->m_filter1r->flt_volume_set_volume((71.0 * right) / 55.0);
	250	state->m_filter2l->flt_volume_set_volume((71.0 * left) / 55.0);
	251	state->m_filter2r->flt_volume_set_volume((71.0 * right) / 55.0);
252	252	}
253	253
254	254	TIMER_CALLBACK_MEMBER(xexex_state::dmaend_callback)
r20636	r20637
462	462	m_k056832 = machine().device("k056832");
463	463	m_k054338 = machine().device("k054338");
464	464	m_k054539 = machine().device("k054539");
465		m_filter1l = machine().device("filter1l");
466		m_filter1r = machine().device("filter1r");
467		m_filter2l = machine().device("filter2l");
468		m_filter2r = machine().device("filter2r");
	465	m_filter1l = machine().device<filter_volume_device>("filter1l");
	466	m_filter1r = machine().device<filter_volume_device>("filter1r");
	467	m_filter2l = machine().device<filter_volume_device>("filter2l");
	468	m_filter2r = machine().device<filter_volume_device>("filter2r");
469	469
470	470	save_item(NAME(m_cur_alpha));
471	471	save_item(NAME(m_sprite_colorbase));
r20636	r20637
555	555	MCFG_SOUND_ROUTE(1, "lspeaker", 1.0)
556	556	MCFG_SOUND_ROUTE(1, "rspeaker", 1.0)
557	557
558		MCFG_SOUND_ADD("filter1l", FILTER_VOLUME, 0)
	558	MCFG_FILTER_VOLUME_ADD("filter1l", 0)
559	559	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
560		MCFG_SOUND_ADD("filter1r", FILTER_VOLUME, 0)
	560	MCFG_FILTER_VOLUME_ADD("filter1r", 0)
561	561	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
562		MCFG_SOUND_ADD("filter2l", FILTER_VOLUME, 0)
	562	MCFG_FILTER_VOLUME_ADD("filter2l", 0)
563	563	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
564		MCFG_SOUND_ADD("filter2r", FILTER_VOLUME, 0)
	564	MCFG_FILTER_VOLUME_ADD("filter2r", 0)
565	565	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
566	566	MACHINE_CONFIG_END
567	567

trunk/src/mame/drivers/darius.c

r20636	r20637
307	307	int right = ((0xff - state->m_pan[0]) * state->m_vol[6]) >> 8;
308	308
309	309	if (state->m_filter0_3l != NULL)
310		flt_volume_set_volume(state->m_filter0_3l, left / 100.0);
	310	state->m_filter0_3l->flt_volume_set_volume(left / 100.0);
311	311	if (state->m_filter0_3r != NULL)
312		flt_volume_set_volume(state->m_filter0_3r, right / 100.0); /* FM #0 */
	312	state->m_filter0_3r->flt_volume_set_volume(right / 100.0); /* FM #0 */
313	313	}
314	314
315	315	static void update_fm1( running_machine &machine )
r20636	r20637
319	319	int right = ((0xff - state->m_pan[1]) * state->m_vol[7]) >> 8;
320	320
321	321	if (state->m_filter1_3l != NULL)
322		flt_volume_set_volume(state->m_filter1_3l, left / 100.0);
	322	state->m_filter1_3l->flt_volume_set_volume(left / 100.0);
323	323	if (state->m_filter1_3r != NULL)
324		flt_volume_set_volume(state->m_filter1_3r, right / 100.0); /* FM #1 */
	324	state->m_filter1_3r->flt_volume_set_volume(right / 100.0); /* FM #1 */
325	325	}
326	326
327	327	static void update_psg0( running_machine &machine, int port )
328	328	{
329	329	darius_state *state = machine.driver_data<darius_state>();
330		device_t *lvol = NULL, *rvol = NULL;
	330	filter_volume_device *lvol = NULL, *rvol = NULL;
331	331	int left, right;
332	332
333	333	switch (port)
r20636	r20637
342	342	right = ((0xff - state->m_pan[2]) * state->m_vol[port]) >> 8;
343	343
344	344	if (lvol != NULL)
345		flt_volume_set_volume(lvol, left / 100.0);
	345	lvol->flt_volume_set_volume(left / 100.0);
346	346	if (rvol != NULL)
347		flt_volume_set_volume(rvol, right / 100.0);
	347	rvol->flt_volume_set_volume(right / 100.0);
348	348	}
349	349
350	350	static void update_psg1( running_machine &machine, int port )
351	351	{
352	352	darius_state *state = machine.driver_data<darius_state>();
353		device_t *lvol = NULL, *rvol = NULL;
	353	filter_volume_device *lvol = NULL, *rvol = NULL;
354	354	int left, right;
355	355
356	356	switch (port)
r20636	r20637
365	365	right = ((0xff - state->m_pan[3]) * state->m_vol[port + 3]) >> 8;
366	366
367	367	if (lvol != NULL)
368		flt_volume_set_volume(lvol, left / 100.0);
	368	lvol->flt_volume_set_volume(left / 100.0);
369	369	if (rvol != NULL)
370		flt_volume_set_volume(rvol, right / 100.0);
	370	rvol->flt_volume_set_volume(right / 100.0);
371	371	}
372	372
373	373	static void update_da( running_machine &machine )
r20636	r20637
377	377	int right = state->m_def_vol[(state->m_pan[4] >> 0) & 0x0f];
378	378
379	379	if (state->m_msm5205_l != NULL)
380		flt_volume_set_volume(state->m_msm5205_l, left / 100.0);
	380	state->m_msm5205_l->flt_volume_set_volume(left / 100.0);
381	381	if (state->m_msm5205_r != NULL)
382		flt_volume_set_volume(state->m_msm5205_r, right / 100.0);
	382	state->m_msm5205_r->flt_volume_set_volume(right / 100.0);
383	383	}
384	384
385	385	WRITE8_MEMBER(darius_state::darius_fm0_pan)
r20636	r20637
843	843	m_mscreen = machine().device("mscreen");
844	844	m_rscreen = machine().device("rscreen");
845	845
846		m_filter0_0l = machine().device("filter0.0l");
847		m_filter0_0r = machine().device("filter0.0r");
848		m_filter0_1l = machine().device("filter0.1l");
849		m_filter0_1r = machine().device("filter0.1r");
850		m_filter0_2l = machine().device("filter0.2l");
851		m_filter0_2r = machine().device("filter0.2r");
852		m_filter0_3l = machine().device("filter0.3l");
853		m_filter0_3r = machine().device("filter0.3r");
	846	m_filter0_0l = machine().device<filter_volume_device>("filter0.0l");
	847	m_filter0_0r = machine().device<filter_volume_device>("filter0.0r");
	848	m_filter0_1l = machine().device<filter_volume_device>("filter0.1l");
	849	m_filter0_1r = machine().device<filter_volume_device>("filter0.1r");
	850	m_filter0_2l = machine().device<filter_volume_device>("filter0.2l");
	851	m_filter0_2r = machine().device<filter_volume_device>("filter0.2r");
	852	m_filter0_3l = machine().device<filter_volume_device>("filter0.3l");
	853	m_filter0_3r = machine().device<filter_volume_device>("filter0.3r");
854	854
855		m_filter1_0l = machine().device("filter1.0l");
856		m_filter1_0r = machine().device("filter1.0r");
857		m_filter1_1l = machine().device("filter1.1l");
858		m_filter1_1r = machine().device("filter1.1r");
859		m_filter1_2l = machine().device("filter1.2l");
860		m_filter1_2r = machine().device("filter1.2r");
861		m_filter1_3l = machine().device("filter1.3l");
862		m_filter1_3r = machine().device("filter1.3r");
	855	m_filter1_0l = machine().device<filter_volume_device>("filter1.0l");
	856	m_filter1_0r = machine().device<filter_volume_device>("filter1.0r");
	857	m_filter1_1l = machine().device<filter_volume_device>("filter1.1l");
	858	m_filter1_1r = machine().device<filter_volume_device>("filter1.1r");
	859	m_filter1_2l = machine().device<filter_volume_device>("filter1.2l");
	860	m_filter1_2r = machine().device<filter_volume_device>("filter1.2r");
	861	m_filter1_3l = machine().device<filter_volume_device>("filter1.3l");
	862	m_filter1_3r = machine().device<filter_volume_device>("filter1.3r");
863	863
864		m_msm5205_l = machine().device("msm5205.l");
865		m_msm5205_r = machine().device("msm5205.r");
	864	m_msm5205_l = machine().device<filter_volume_device>("msm5205.l");
	865	m_msm5205_r = machine().device<filter_volume_device>("msm5205.r");
866	866
867	867	save_item(NAME(m_cpua_ctrl));
868	868	save_item(NAME(m_coin_word));
r20636	r20637
982	982	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "msm5205.l", 1.0)
983	983	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "msm5205.r", 1.0)
984	984
985		MCFG_SOUND_ADD("filter0.0l", FILTER_VOLUME, 0)
	985	MCFG_FILTER_VOLUME_ADD("filter0.0l", 0)
986	986	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
987		MCFG_SOUND_ADD("filter0.0r", FILTER_VOLUME, 0)
	987	MCFG_FILTER_VOLUME_ADD("filter0.0r", 0)
988	988	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
989		MCFG_SOUND_ADD("filter0.1l", FILTER_VOLUME, 0)
	989	MCFG_FILTER_VOLUME_ADD("filter0.1l", 0)
990	990	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
991		MCFG_SOUND_ADD("filter0.1r", FILTER_VOLUME, 0)
	991	MCFG_FILTER_VOLUME_ADD("filter0.1r", 0)
992	992	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
993		MCFG_SOUND_ADD("filter0.2l", FILTER_VOLUME, 0)
	993	MCFG_FILTER_VOLUME_ADD("filter0.2l", 0)
994	994	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
995		MCFG_SOUND_ADD("filter0.2r", FILTER_VOLUME, 0)
	995	MCFG_FILTER_VOLUME_ADD("filter0.2r", 0)
996	996	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
997		MCFG_SOUND_ADD("filter0.3l", FILTER_VOLUME, 0)
	997	MCFG_FILTER_VOLUME_ADD("filter0.3l", 0)
998	998	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
999		MCFG_SOUND_ADD("filter0.3r", FILTER_VOLUME, 0)
	999	MCFG_FILTER_VOLUME_ADD("filter0.3r", 0)
1000	1000	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
1001	1001
1002		MCFG_SOUND_ADD("filter1.0l", FILTER_VOLUME, 0)
	1002	MCFG_FILTER_VOLUME_ADD("filter1.0l", 0)
1003	1003	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
1004		MCFG_SOUND_ADD("filter1.0r", FILTER_VOLUME, 0)
	1004	MCFG_FILTER_VOLUME_ADD("filter1.0r", 0)
1005	1005	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
1006		MCFG_SOUND_ADD("filter1.1l", FILTER_VOLUME, 0)
	1006	MCFG_FILTER_VOLUME_ADD("filter1.1l", 0)
1007	1007	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
1008		MCFG_SOUND_ADD("filter1.1r", FILTER_VOLUME, 0)
	1008	MCFG_FILTER_VOLUME_ADD("filter1.1r", 0)
1009	1009	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
1010		MCFG_SOUND_ADD("filter1.2l", FILTER_VOLUME, 0)
	1010	MCFG_FILTER_VOLUME_ADD("filter1.2l", 0)
1011	1011	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
1012		MCFG_SOUND_ADD("filter1.2r", FILTER_VOLUME, 0)
	1012	MCFG_FILTER_VOLUME_ADD("filter1.2r", 0)
1013	1013	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
1014		MCFG_SOUND_ADD("filter1.3l", FILTER_VOLUME, 0)
	1014	MCFG_FILTER_VOLUME_ADD("filter1.3l", 0)
1015	1015	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
1016		MCFG_SOUND_ADD("filter1.3r", FILTER_VOLUME, 0)
	1016	MCFG_FILTER_VOLUME_ADD("filter1.3r", 0)
1017	1017	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
1018	1018
1019		MCFG_SOUND_ADD("msm5205.l", FILTER_VOLUME, 0)
	1019	MCFG_FILTER_VOLUME_ADD("msm5205.l", 0)
1020	1020	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
1021		MCFG_SOUND_ADD("msm5205.r", FILTER_VOLUME, 0)
	1021	MCFG_FILTER_VOLUME_ADD("msm5205.r", 0)
1022	1022	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
1023	1023
1024	1024	MCFG_TC0140SYT_ADD("tc0140syt", darius_tc0140syt_intf)

trunk/src/mame/audio/scramble.c

r20636	r20637
141	141	if (data & 2)
142	142	C +=  47000;    /*  47000pF = 0.047uF */
143	143	if (device != NULL)
144		filter_rc_set_RC(device,FLT_RC_LOWPASS,1000,5100,0,CAP_P(C));
	144	dynamic_cast<filter_rc_device*>(device)->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 5100, 0, CAP_P(C));
145	145	}
146	146
147	147	WRITE8_MEMBER(scramble_state::scramble_filter_w)

trunk/src/mame/audio/timeplt.c

r20636	r20637
118	118	if (data & 2)
119	119	C +=  47000;    /*  47000pF = 0.047uF */
120	120
121		filter_rc_set_RC(device, FLT_RC_LOWPASS, 1000, 5100, 0, CAP_P(C));
	121	dynamic_cast<filter_rc_device*>(device)->filter_rc_set_RC(FLT_RC_LOWPASS, 1000, 5100, 0, CAP_P(C));
122	122	}
123	123
124	124
r20636	r20637
233	233	MCFG_SOUND_ROUTE(1, "filter.1.1", 0.60)
234	234	MCFG_SOUND_ROUTE(2, "filter.1.2", 0.60)
235	235
236		MCFG_SOUND_ADD("filter.0.0", FILTER_RC, 0)
	236	MCFG_FILTER_RC_ADD("filter.0.0", 0)
237	237	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
238		MCFG_SOUND_ADD("filter.0.1", FILTER_RC, 0)
	238	MCFG_FILTER_RC_ADD("filter.0.1", 0)
239	239	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
240		MCFG_SOUND_ADD("filter.0.2", FILTER_RC, 0)
	240	MCFG_FILTER_RC_ADD("filter.0.2", 0)
241	241	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
242	242
243		MCFG_SOUND_ADD("filter.1.0", FILTER_RC, 0)
	243	MCFG_FILTER_RC_ADD("filter.1.0", 0)
244	244	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
245		MCFG_SOUND_ADD("filter.1.1", FILTER_RC, 0)
	245	MCFG_FILTER_RC_ADD("filter.1.1", 0)
246	246	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
247		MCFG_SOUND_ADD("filter.1.2", FILTER_RC, 0)
	247	MCFG_FILTER_RC_ADD("filter.1.2", 0)
248	248	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
249	249	MACHINE_CONFIG_END
250	250

trunk/src/emu/sound/flt_rc.c

r20636	r20637
1	1	#include "emu.h"
2	2	#include "flt_rc.h"
3	3
4		struct filter_rc_state
	4
	5	const flt_rc_config flt_rc_ac_default = {FLT_RC_AC, 10000, 0, 0, CAP_U(1)};
	6
	7
	8	// device type definition
	9	const device_type FILTER_RC = &device_creator<filter_rc_device>;
	10
	11
	12	//**************************************************************************
	13	//  LIVE DEVICE
	14	//**************************************************************************
	15
	16	//-------------------------------------------------
	17	//  qsound_device - constructor
	18	//-------------------------------------------------
	19
	20	filter_rc_device::filter_rc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	21	: device_t(mconfig, FILTER_RC, "RC Filter", tag, owner, clock),
	22	device_sound_interface(mconfig, *this),
	23	m_stream(NULL),
	24	m_k(0),
	25	m_memory(0),
	26	m_type(0)
5	27	{
6		device_t *device;
7		sound_stream *  stream;
8		int             k;
9		int             memory;
10		int             type;
11		};
	28	}
12	29
13		INLINE filter_rc_state *get_safe_token(device_t *device)
	30
	31	//-------------------------------------------------
	32	//  device_start - device-specific startup
	33	//-------------------------------------------------
	34
	35	void filter_rc_device::device_start()
14	36	{
15		assert(device != NULL);
16		assert(device->type() == FILTER_RC);
17		return (filter_rc_state *)downcast<filter_rc_device *>(device)->token();
	37	const flt_rc_config *conf = (const flt_rc_config *)static_config();
	38
	39	m_stream = stream_alloc(1, 1, machine().sample_rate());
	40	if (conf)
	41	set_RC_info(conf->type, conf->R1, conf->R2, conf->R3, conf->C);
	42	else
	43	set_RC_info(FLT_RC_LOWPASS, 1, 1, 1, 0);
18	44	}
19	45
20		const flt_rc_config flt_rc_ac_default = {FLT_RC_AC, 10000, 0, 0, CAP_U(1)};
21	46
	47	//-------------------------------------------------
	48	//  sound_stream_update - handle a stream update
	49	//-------------------------------------------------
22	50
23		static STREAM_UPDATE( filter_rc_update )
	51	void filter_rc_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
24	52	{
25	53	stream_sample_t *src = inputs[0];
26	54	stream_sample_t *dst = outputs[0];
27		filter_rc_state *info = (filter_rc_state *)param;
28		int memory = info->memory;
	55	int memory = m_memory;
29	56
30		switch (info->type)
	57	switch (m_type)
31	58	{
32	59	case FLT_RC_LOWPASS:
33	60	while (samples--)
34	61	{
35		memory += ((*src++ - memory) * info->k) / 0x10000;
	62	memory += ((*src++ - memory) * m_k) / 0x10000;
36	63	*dst++ = memory;
37	64	}
38	65	break;
r20636	r20637
41	68	while (samples--)
42	69	{
43	70	*dst++ = *src - memory;
44		memory += ((*src++ - memory) * info->k) / 0x10000;
	71	memory += ((*src++ - memory) * m_k) / 0x10000;
45	72	}
46	73	break;
47	74	}
48		info->memory = memory;
	75	m_memory = memory;
49	76	}
50	77
51		static void set_RC_info(filter_rc_state *info, int type, double R1, double R2, double R3, double C)
	78
	79	void filter_rc_device::set_RC_info(int type, double R1, double R2, double R3, double C)
52	80	{
53	81	double Req;
54	82
55		info->type = type;
	83	m_type = type;
56	84
57		switch (info->type)
	85	switch (m_type)
58	86	{
59	87	case FLT_RC_LOWPASS:
60	88	if (C == 0.0)
61	89	{
62	90	/* filter disabled */
63		info->k = 0x10000;
	91	m_k = 0x10000;
64	92	return;
65	93	}
66	94	Req = (R1 * (R2 + R3)) / (R1 + R2 + R3);
r20636	r20637
70	98	if (C == 0.0)
71	99	{
72	100	/* filter disabled */
73		info->k = 0x0;
74		info->memory = 0x0;
	101	m_k = 0x0;
	102	m_memory = 0x0;
75	103	return;
76	104	}
77	105	Req = R1;
78	106	break;
79	107	default:
80		fatalerror("filter_rc_setRC: Wrong filter type %d\n", info->type);
	108	fatalerror("filter_rc_setRC: Wrong filter type %d\n", m_type);
81	109	}
82	110
83	111	/* Cut Frequency = 1/(2*Pi*Req*C) */
84	112	/* k = (1-(EXP(-TIMEDELTA/RC)))    */
85		info->k = 0x10000 - 0x10000 * (exp(-1 / (Req * C) / info->device->machine().sample_rate()));
	113	m_k = 0x10000 - 0x10000 * (exp(-1 / (Req * C) / machine().sample_rate()));
86	114	}
87	115
88	116
89		static DEVICE_START( filter_rc )
	117	void filter_rc_device::filter_rc_set_RC(int type, double R1, double R2, double R3, double C)
90	118	{
91		filter_rc_state *info = get_safe_token(device);
92		const flt_rc_config *conf = (const flt_rc_config *)device->static_config();
93
94		info->device = device;
95		info->stream = device->machine().sound().stream_alloc(*device, 1, 1, device->machine().sample_rate(), info, filter_rc_update);
96		if (conf)
97		set_RC_info(info, conf->type, conf->R1, conf->R2, conf->R3, conf->C);
98		else
99		set_RC_info(info, FLT_RC_LOWPASS, 1, 1, 1, 0);
	119	m_stream->update();
	120	set_RC_info(type, R1, R2, R3, C);
100	121	}
101	122
102
103		void filter_rc_set_RC(device_t *device, int type, double R1, double R2, double R3, double C)
104		{
105		filter_rc_state *info = get_safe_token(device);
106
107		info->stream->update();
108
109		set_RC_info(info, type, R1, R2, R3, C);
110
111		}
112
113		const device_type FILTER_RC = &device_creator<filter_rc_device>;
114
115		filter_rc_device::filter_rc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
116		: device_t(mconfig, FILTER_RC, "RC Filter", tag, owner, clock),
117		device_sound_interface(mconfig, *this)
118		{
119		m_token = global_alloc_clear(filter_rc_state);
120		}
121
122		//-------------------------------------------------
123		//  device_config_complete - perform any
124		//  operations now that the configuration is
125		//  complete
126		//-------------------------------------------------
127
128		void filter_rc_device::device_config_complete()
129		{
130		}
131
132		//-------------------------------------------------
133		//  device_start - device-specific startup
134		//-------------------------------------------------
135
136		void filter_rc_device::device_start()
137		{
138		DEVICE_START_NAME( filter_rc )(this);
139		}
140
141		//-------------------------------------------------
142		//  sound_stream_update - handle a stream update
143		//-------------------------------------------------
144
145		void filter_rc_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
146		{
147		// should never get here
148		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
149		}

trunk/src/emu/sound/flt_rc.h

r20636	r20637
1	1	#pragma once
2	2
3	3	#ifndef __FLT_RC_H__
4		#define FLT_RC_H
	4	#define __FLT_RC_H__
5	5
6	6	#include "machine/rescap.h"
7		#include "devlegcy.h"
8	7
9		#define FLT_RC_LOWPASS      0
10		#define FLT_RC_HIGHPASS     1
11		#define FLT_RC_AC           2
12
13	8	/*
14	9	* FLT_RC_LOWPASS:
15	10	*
r20636	r20637
45	40	*
46	41	*/
47	42
	43	//**************************************************************************
	44	//  INTERFACE CONFIGURATION MACROS
	45	//**************************************************************************
	46
	47	#define MCFG_FILTER_RC_ADD(_tag, _clock) \
	48	MCFG_DEVICE_ADD(_tag, FILTER_RC, _clock)
	49	#define MCFG_FILTER_RC_REPLACE(_tag, _clock) \
	50	MCFG_DEVICE_REPLACE(_tag, FILTER_RC, _clock)
	51
	52
	53	//**************************************************************************
	54	//  TYPE DEFINITIONS
	55	//**************************************************************************
	56
	57	#define FLT_RC_LOWPASS      0
	58	#define FLT_RC_HIGHPASS     1
	59	#define FLT_RC_AC           2
	60
48	61	struct flt_rc_config
49	62	{
50	63	int type;
r20636	r20637
56	69
57	70	extern const flt_rc_config flt_rc_ac_default;
58	71
59		void filter_rc_set_RC(device_t *device, int type, double R1, double R2, double R3, double C);
60	72
	73	// ======================> filter_rc_device
	74
61	75	class filter_rc_device : public device_t,
62		public device_sound_interface
	76	public device_sound_interface
63	77	{
64	78	public:
65	79	filter_rc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
66		~filter_rc_device() { global_free(m_token); }
	80	~filter_rc_device() { }
67	81
68		// access to legacy token
69		void *token() const { assert(m_token != NULL); return m_token; }
	82	void filter_rc_set_RC(int type, double R1, double R2, double R3, double C);
	83
70	84	protected:
71	85	// device-level overrides
72		virtual void device_config_complete();
73	86	virtual void device_start();
74	87
75	88	// sound stream update overrides
76	89	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	90
77	91	private:
78		// internal state
79		void *m_token;
	92	void set_RC_info(int type, double R1, double R2, double R3, double C);
	93
	94	private:
	95	sound_stream*  m_stream;
	96	int            m_k;
	97	int            m_memory;
	98	int            m_type;
80	99	};
81	100
82	101	extern const device_type FILTER_RC;

trunk/src/emu/sound/flt_vol.c

r20636	r20637
2	2	#include "flt_vol.h"
3	3
4	4
5		struct filter_volume_state
6		{
7		sound_stream *  stream;
8		int             gain;
9		};
10
11		INLINE filter_volume_state *get_safe_token(device_t *device)
12		{
13		assert(device != NULL);
14		assert(device->type() == FILTER_VOLUME);
15		return (filter_volume_state *)downcast<filter_volume_device *>(device)->token();
16		}
17
18
19
20		static STREAM_UPDATE( filter_volume_update )
21		{
22		stream_sample_t *src = inputs[0];
23		stream_sample_t *dst = outputs[0];
24		filter_volume_state *info = (filter_volume_state *)param;
25
26		while (samples--)
27		*dst++ = (*src++ * info->gain) >> 8;
28		}
29
30
31		static DEVICE_START( filter_volume )
32		{
33		filter_volume_state *info = get_safe_token(device);
34
35		info->gain = 0x100;
36		info->stream = device->machine().sound().stream_alloc(*device, 1, 1, device->machine().sample_rate(), info, filter_volume_update);
37		}
38
39
40		void flt_volume_set_volume(device_t *device, float volume)
41		{
42		filter_volume_state *info = get_safe_token(device);
43		info->gain = (int)(volume * 256);
44		}
45
	5	// device type definition
46	6	const device_type FILTER_VOLUME = &device_creator<filter_volume_device>;
47	7
48		filter_volume_device::filter_volume_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
49		: device_t(mconfig, FILTER_VOLUME, "Volume Filter", tag, owner, clock),
50		device_sound_interface(mconfig, *this)
51		{
52		m_token = global_alloc_clear(filter_volume_state);
53		}
54
55	8	//-------------------------------------------------
56		//  device_config_complete - perform any
57		//  operations now that the configuration is
58		//  complete
	9	//  qsound_device - constructor
59	10	//-------------------------------------------------
60	11
61		void filter_volume_device::device_config_complete()
	12	filter_volume_device::filter_volume_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	13	: device_t(mconfig, FILTER_VOLUME, "Volume Filter", tag, owner, clock),
	14	device_sound_interface(mconfig, *this),
	15	m_stream(NULL),
	16	m_gain(0)
62	17	{
63	18	}
64	19
	20
65	21	//-------------------------------------------------
66	22	//  device_start - device-specific startup
67	23	//-------------------------------------------------
68	24
69	25	void filter_volume_device::device_start()
70	26	{
71		DEVICE_START_NAME( filter_volume )(this);
	27	m_gain = 0x100;
	28	m_stream = stream_alloc(1, 1, machine().sample_rate());
72	29	}
73	30
	31
74	32	//-------------------------------------------------
75	33	//  sound_stream_update - handle a stream update
76	34	//-------------------------------------------------
77	35
78	36	void filter_volume_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
79	37	{
80		// should never get here
81		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
	38	stream_sample_t *src = inputs[0];
	39	stream_sample_t *dst = outputs[0];
	40
	41	while (samples--)
	42	*dst++ = (*src++ * m_gain) >> 8;
82	43	}
	44
	45
	46
	47	void filter_volume_device::flt_volume_set_volume(float volume)
	48	{
	49	m_gain = (int)(volume * 256);
	50	}
	51

trunk/src/emu/sound/flt_vol.h

r20636	r20637
3	3	#ifndef __FLT_VOL_H__
4	4	#define __FLT_VOL_H__
5	5
6		#include "devlegcy.h"
7	6
8	7
9		void flt_volume_set_volume(device_t *device, float volume);
	8	//**************************************************************************
	9	//  INTERFACE CONFIGURATION MACROS
	10	//**************************************************************************
10	11
	12	#define MCFG_FILTER_VOLUME_ADD(_tag, _clock) \
	13	MCFG_DEVICE_ADD(_tag, FILTER_VOLUME, _clock)
	14	#define MCFG_FILTER_VOLUME_REPLACE(_tag, _clock) \
	15	MCFG_DEVICE_REPLACE(_tag, FILTER_VOLUME, _clock)
	16
	17
	18	//**************************************************************************
	19	//  TYPE DEFINITIONS
	20	//**************************************************************************
	21
	22	// ======================> filter_volume_device
	23
11	24	class filter_volume_device : public device_t,
12		public device_sound_interface
	25	public device_sound_interface
13	26	{
14	27	public:
15	28	filter_volume_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
16		~filter_volume_device() { global_free(m_token); }
	29	~filter_volume_device() { }
17	30
18		// access to legacy token
19		void *token() const { assert(m_token != NULL); return m_token; }
	31	void flt_volume_set_volume(float volume);
	32
20	33	protected:
21	34	// device-level overrides
22		virtual void device_config_complete();
23	35	virtual void device_start();
24	36
25	37	// sound stream update overrides
26	38	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	39
27	40	private:
28		// internal state
29		void *m_token;
	41	sound_stream*  m_stream;
	42	int            m_gain;
30	43	};
31	44
32	45	extern const device_type FILTER_VOLUME;

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team