Previous

199869 Revisions

Next

r32680 Sunday 12th October, 2014 at 06:37:59 UTC by Fabio Priuli
(MESS) svision: handling sound IRQ via a device delegate allows to finally untangle the sound device from the main state. also given the sound device its own .h file. nw.

[src/mess]	mess.mak
[src/mess/audio]	svis_snd.c* svis_snd.h* svision.c
[src/mess/drivers]	svision.c
[src/mess/includes]	svision.h

trunk/src/mess/drivers/svision.c

r32679	r32680
5	5	******************************************************************************/
6	6
7	7	#include "emu.h"
8
9	8	#include "includes/svision.h"
10	9
11	10	#include "svision.lh"
r32679	r32680
172	171	break;
173	172
174	173	case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c:
175		m_sound->svision_sounddma_w(space, offset - 0x18, data);
	174	m_sound->sounddma_w(space, offset - 0x18, data);
176	175	break;
177	176
178	177	case 0x28: case 0x29: case 0x2a:
179		m_sound->svision_noise_w(space, offset - 0x28, data);
	178	m_sound->noise_w(space, offset - 0x28, data);
180	179	break;
181	180
182	181	default:
r32679	r32680
255	254	}
256	255
257	256	static ADDRESS_MAP_START( svision_mem , AS_PROGRAM, 8, svision_state )
258		AM_RANGE( 0x0000, 0x1fff) AM_RAM
259		AM_RANGE( 0x2000, 0x3fff) AM_READWRITE(svision_r, svision_w) AM_SHARE("reg")
260		AM_RANGE( 0x4000, 0x5fff) AM_RAM AM_SHARE("videoram")
261		AM_RANGE( 0x6000, 0x7fff) AM_NOP
262		AM_RANGE( 0x8000, 0xbfff) AM_ROMBANK("bank1")
263		AM_RANGE( 0xc000, 0xffff) AM_ROMBANK("bank2")
	257	AM_RANGE(0x0000, 0x1fff) AM_RAM
	258	AM_RANGE(0x2000, 0x3fff) AM_READWRITE(svision_r, svision_w) AM_SHARE("reg")
	259	AM_RANGE(0x4000, 0x5fff) AM_RAM AM_SHARE("videoram")
	260	AM_RANGE(0x6000, 0x7fff) AM_NOP
	261	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("bank1")
	262	AM_RANGE(0xc000, 0xffff) AM_ROMBANK("bank2")
264	263	ADDRESS_MAP_END
265	264
266	265	static ADDRESS_MAP_START( tvlink_mem , AS_PROGRAM, 8, svision_state )
267		AM_RANGE( 0x0000, 0x1fff) AM_RAM
268		AM_RANGE( 0x2000, 0x3fff) AM_READWRITE(tvlink_r, tvlink_w) AM_SHARE("reg")
269		AM_RANGE( 0x4000, 0x5fff) AM_RAM AM_SHARE("videoram")
270		AM_RANGE( 0x6000, 0x7fff) AM_NOP
271		AM_RANGE( 0x8000, 0xbfff) AM_ROMBANK("bank1")
272		AM_RANGE( 0xc000, 0xffff) AM_ROMBANK("bank2")
	266	AM_RANGE(0x0000, 0x1fff) AM_RAM
	267	AM_RANGE(0x2000, 0x3fff) AM_READWRITE(tvlink_r, tvlink_w) AM_SHARE("reg")
	268	AM_RANGE(0x4000, 0x5fff) AM_RAM AM_SHARE("videoram")
	269	AM_RANGE(0x6000, 0x7fff) AM_NOP
	270	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("bank1")
	271	AM_RANGE(0xc000, 0xffff) AM_ROMBANK("bank2")
273	272	ADDRESS_MAP_END
274	273
275	274	static INPUT_PORTS_START( svision )
r32679	r32680
351	350
352	351	PALETTE_INIT_MEMBER(svision_state, svision)
353	352	{
354		int i;
355
356		for( i = 0; i < sizeof(svision_palette) / 3; i++ ) {
357		palette.set_pen_color(i, svision_palette[i*3], svision_palette[i*3+1], svision_palette[i*3+2] );
358		}
	353	for (int i = 0; i < sizeof(svision_palette) / 3; i++)
	354	palette.set_pen_color(i, svision_palette[i*3], svision_palette[i*3+1], svision_palette[i*3+2]);
359	355	}
360	356	PALETTE_INIT_MEMBER(svision_state,svisionn)
361	357	{
362		int i;
363
364		for ( i = 0; i < sizeof(svisionn_palette) / 3; i++ ) {
365		palette.set_pen_color(i, svisionn_palette[i*3], svisionn_palette[i*3+1], svisionn_palette[i*3+2] );
366		}
	358	for (int i = 0; i < sizeof(svisionn_palette) / 3; i++)
	359	palette.set_pen_color(i, svisionn_palette[i*3], svisionn_palette[i*3+1], svisionn_palette[i*3+2]);
367	360	}
368	361	PALETTE_INIT_MEMBER(svision_state,svisionp)
369	362	{
370		int i;
371
372		for ( i = 0; i < sizeof(svisionn_palette) / 3; i++ ) {
373		palette.set_pen_color(i, svisionp_palette[i*3], svisionp_palette[i*3+1], svisionp_palette[i*3+2] );
374		}
	363	for (int i = 0; i < sizeof(svisionn_palette) / 3; i++)
	364	palette.set_pen_color(i, svisionp_palette[i*3], svisionp_palette[i*3+1], svisionp_palette[i*3+2]);
375	365	}
376	366
377	367	UINT32 svision_state::screen_update_svision(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
r32679	r32680
438	428
439	429	INTERRUPT_GEN_MEMBER(svision_state::svision_frame_int)
440	430	{
441		if (BANK&1)
	431	if (BANK & 1)
442	432	device.execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
443	433
444	434	m_sound->sound_decrement();
445	435	}
446	436
447		DRIVER_INIT_MEMBER(svision_state,svision)
	437	DRIVER_INIT_MEMBER(svision_state, svision)
448	438	{
449	439	m_svision.timer1 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(svision_state::svision_timer),this));
450		m_sound = machine().device<svision_sound_device>("custom");
451	440	m_dma_finished = m_sound->dma_finished();
452	441	m_pet.on = FALSE;
453	442	}
454	443
455		DRIVER_INIT_MEMBER(svision_state,svisions)
	444	DRIVER_INIT_MEMBER(svision_state, svisions)
456	445	{
457	446	m_svision.timer1 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(svision_state::svision_timer),this));
458		m_sound = machine().device<svision_sound_device>("custom");
459	447	m_dma_finished = m_sound->dma_finished();
460	448	m_pet.on = TRUE;
461	449	m_pet.timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(svision_state::svision_pet_timer),this));
r32679	r32680
534	522
535	523	/* sound hardware */
536	524	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
537		MCFG_SOUND_ADD("custom", SVISION, 0)
	525	MCFG_SOUND_ADD("custom", SVISION_SND, 0)
538	526	MCFG_SOUND_ROUTE(0, "lspeaker", 0.50)
539	527	MCFG_SOUND_ROUTE(1, "rspeaker", 0.50)
	528	SVISION_SND_IRQ_CB(svision_state, svision_irq)
540	529
541	530	/* cartridge */
542	531	MCFG_GENERIC_CARTSLOT_ADD("cartslot", generic_plain_slot, "svision_cart")
r32679	r32680
545	534	MCFG_GENERIC_LOAD(svision_state, svision_cart)
546	535
547	536	/* Software lists */
548		MCFG_SOFTWARE_LIST_ADD("cart_list","svision")
	537	MCFG_SOFTWARE_LIST_ADD("cart_list", "svision")
549	538	MACHINE_CONFIG_END
550	539
551	540	static MACHINE_CONFIG_DERIVED( svisions, svision )
r32679	r32680
558	547	MCFG_SCREEN_MODIFY("screen")
559	548	MCFG_SCREEN_REFRESH_RATE(50)
560	549	MCFG_PALETTE_MODIFY("palette")
561		MCFG_PALETTE_INIT_OWNER(svision_state, svisionp )
	550	MCFG_PALETTE_INIT_OWNER(svision_state, svisionp)
562	551	MACHINE_CONFIG_END
563	552
564	553	static MACHINE_CONFIG_DERIVED( svisionn, svision )
r32679	r32680
567	556	MCFG_SCREEN_MODIFY("screen")
568	557	MCFG_SCREEN_REFRESH_RATE(60)
569	558	MCFG_PALETTE_MODIFY("palette")
570		MCFG_PALETTE_INIT_OWNER(svision_state, svisionn )
	559	MCFG_PALETTE_INIT_OWNER(svision_state, svisionn)
571	560	MACHINE_CONFIG_END
572	561
573	562	static MACHINE_CONFIG_DERIVED( tvlinkp, svisionp )
574	563	MCFG_CPU_MODIFY("maincpu")
575	564	MCFG_CPU_PROGRAM_MAP(tvlink_mem)
576	565
577		MCFG_MACHINE_RESET_OVERRIDE(svision_state, tvlink )
	566	MCFG_MACHINE_RESET_OVERRIDE(svision_state, tvlink)
578	567
579	568	MCFG_SCREEN_MODIFY("screen")
580	569	MCFG_SCREEN_NO_PALETTE

trunk/src/mess/mess.mak

r32679	r32680
1640	1640	$(MESS_DRIVERS)/svi318.o $(MESS_MACHINE)/svi318.o \
1641	1641
1642	1642	$(MESSOBJ)/svision.a:           \
1643		$(MESS_DRIVERS)/svision.o $(MESS_AUDIO)/svision.o \
	1643	$(MESS_DRIVERS)/svision.o $(MESS_AUDIO)/svis_snd.o \
1644	1644
1645	1645	$(MESSOBJ)/swtpc09.a:           \
1646	1646	$(MESS_DRIVERS)/swtpc09.o $(MESS_MACHINE)/swtpc09.o \

trunk/src/mess/audio/svision.c

r32679	r32680
1		/***************************************************************************
2		supervision sound hardware
3
4		PeT mess@utanet.at
5		***************************************************************************/
6
7		#include "emu.h"
8		#include "includes/svision.h"
9
10
11		// device type definition
12		const device_type SVISION = &device_creator<svision_sound_device>;
13
14
15		//**************************************************************************
16		//  LIVE DEVICE
17		//**************************************************************************
18
19		//-------------------------------------------------
20		//  svision_sound_device - constructor
21		//-------------------------------------------------
22
23		svision_sound_device::svision_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
24		: device_t(mconfig, SVISION, "Super Vision Audio Custom", tag, owner, clock, "svision_sound", __FILE__),
25		device_sound_interface(mconfig, *this),
26		m_mixer_channel(NULL)
27		{
28		}
29
30
31		//-------------------------------------------------
32		//  device_start - device-specific startup
33		//-------------------------------------------------
34
35		void svision_sound_device::device_start()
36		{
37		memset(&m_dma, 0, sizeof(m_dma));
38		memset(&m_noise, 0, sizeof(m_noise));
39		memset(m_channel, 0, sizeof(m_channel));
40
41		m_mixer_channel = stream_alloc(0, 2, machine().sample_rate());
42		}
43
44
45		//-------------------------------------------------
46		//  sound_stream_update - handle a stream update
47		//-------------------------------------------------
48
49		void svision_sound_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
50		{
51		stream_sample_t *left=outputs[0], *right=outputs[1];
52		int i, j;
53		SVISION_CHANNEL *channel;
54
55		for (i = 0; i < samples; i++, left++, right++)
56		{
57		*left = 0;
58		*right = 0;
59		for (channel=m_channel, j=0; j<ARRAY_LENGTH(m_channel); j++, channel++)
60		{
61		if (channel->size != 0)
62		{
63		if (channel->on||channel->count)
64		{
65		int on = FALSE;
66		switch (channel->waveform)
67		{
68		case 0:
69		on = channel->pos <= (28 * channel->size) >> 5;
70		break;
71		case 1:
72		on = channel->pos <= (24 * channel->size) >> 5;
73		break;
74		default:
75		case 2:
76		on = channel->pos <= channel->size / 2;
77		break;
78		case 3:
79		on = channel->pos <= (9 * channel->size) >> 5;
80		break;
81		}
82		{
83		INT16 s = on ? channel->volume << 8 : 0;
84		if (j == 0)
85		*right += s;
86		else
87		*left += s;
88		}
89		}
90		channel->pos++;
91		if (channel->pos >= channel->size)
92		channel->pos = 0;
93		}
94		}
95		if (m_noise.on && (m_noise.play || m_noise.count))
96		{
97		INT16 s = (m_noise.value ? 1 << 8: 0) * m_noise.volume;
98		int b1, b2;
99		if (m_noise.left)
100		*left += s;
101		if (m_noise.right)
102		*right += s;
103		m_noise.pos += m_noise.step;
104		if (m_noise.pos >= 1.0)
105		{
106		switch (m_noise.type)
107		{
108		case SVISION_NOISE_Type7Bit:
109		m_noise.value = m_noise.state & 0x40 ? 1 : 0;
110		b1 = (m_noise.state & 0x40) != 0;
111		b2 = (m_noise.state & 0x20) != 0;
112		m_noise.state=(m_noise.state<<1)+(b1!=b2?1:0);
113		break;
114		case SVISION_NOISE_Type14Bit:
115		default:
116		m_noise.value = m_noise.state & 0x2000 ? 1 : 0;
117		b1 = (m_noise.state & 0x2000) != 0;
118		b2 = (m_noise.state & 0x1000) != 0;
119		m_noise.state = (m_noise.state << 1) + (b1 != b2 ? 1 : 0);
120		}
121		m_noise.pos -= 1;
122		}
123		}
124		if (m_dma.on)
125		{
126		UINT8 sample;
127		INT16 s;
128		UINT16 addr = m_dma.start + (unsigned) m_dma.pos / 2;
129		if (addr >= 0x8000 && addr < 0xc000)
130		{
131		sample = machine().root_device().memregion("user1")->base()[(addr & 0x3fff) | m_dma.ca14to16];
132		}
133		else
134		{
135		sample = machine().device("maincpu")->memory().space(AS_PROGRAM).read_byte(addr);
136		}
137		if (((unsigned)m_dma.pos) & 1)
138		s = (sample & 0xf);
139		else
140		s = (sample & 0xf0) >> 4;
141		s <<= 8;
142		if (m_dma.left)
143		*left += s;
144		if (m_dma.right)
145		*right += s;
146		m_dma.pos += m_dma.step;
147		if (m_dma.pos >= m_dma.size)
148		{
149		svision_state *sv_state = machine().driver_data<svision_state>();
150		m_dma.finished = TRUE;
151		m_dma.on = FALSE;
152		sv_state->svision_irq();
153		}
154		}
155		}
156		}
157
158
159		WRITE8_MEMBER( svision_sound_device::svision_sounddma_w )
160		{
161		logerror("%.6f svision snddma write %04x %02x\n", space.machine().time().as_double(),offset+0x18,data);
162		m_dma.reg[offset] = data;
163		switch (offset)
164		{
165		case 0:
166		case 1:
167		m_dma.start = (m_dma.reg[0] | (m_dma.reg[1] << 8));
168		break;
169		case 2:
170		m_dma.size = (data ? data : 0x100) * 32;
171		break;
172		case 3:
173		m_dma.step = space.machine().device("maincpu")->unscaled_clock() / (256.0 * space.machine().sample_rate() * (1 + (data & 3)));
174		m_dma.right = data & 4;
175		m_dma.left = data & 8;
176		m_dma.ca14to16 = ((data & 0x70) >> 4) << 14;
177		break;
178		case 4:
179		m_dma.on = data & 0x80;
180		if (m_dma.on)
181		{
182		m_dma.pos = 0.0;
183		}
184		break;
185		}
186		}
187
188
189		WRITE8_MEMBER( svision_sound_device::svision_noise_w )
190		{
191		//  logerror("%.6f svision noise write %04x %02x\n",machine.time(),offset+0x28,data);
192		m_noise.reg[offset]=data;
193		switch (offset)
194		{
195		case 0:
196		m_noise.volume=data&0xf;
197		m_noise.step= space.machine().device("maincpu")->unscaled_clock() / (256.0*space.machine().sample_rate()*(1+(data>>4)));
198		break;
199		case 1:
200		m_noise.count = data + 1;
201		break;
202		case 2:
203		m_noise.type = (SVISION_NOISE_Type) (data & 1);
204		m_noise.play = data & 2;
205		m_noise.right = data & 4;
206		m_noise.left = data & 8;
207		m_noise.on = data & 0x10; /* honey bee start */
208		m_noise.state = 1;
209		break;
210		}
211		m_noise.pos=0.0;
212		}
213
214
215		int *svision_sound_device::dma_finished()
216		{
217		return &m_dma.finished;
218		}
219
220
221		void svision_sound_device::sound_decrement()
222		{
223		if (m_channel[0].count > 0)
224		m_channel[0].count--;
225		if (m_channel[1].count > 0)
226		m_channel[1].count--;
227		if (m_noise.count > 0)
228		m_noise.count--;
229		}
230
231
232		void svision_sound_device::soundport_w(int which, int offset, int data)
233		{
234		SVISION_CHANNEL *channel = &m_channel[which];
235		UINT16 size;
236
237		m_mixer_channel->update();
238		channel->reg[offset] = data;
239
240		switch (offset)
241		{
242		case 0:
243		case 1:
244		size = channel->reg[0] | ((channel->reg[1] & 7) << 8);
245		if (size)
246		{
247		//  channel->size=(int)(device->machine().sample_rate()*(size<<5)/4e6);
248		channel->size= (int) (machine().sample_rate() * (size << 5) / machine().device("maincpu")->unscaled_clock());
249		}
250		else
251		{
252		channel->size = 0;
253		}
254		channel->pos = 0;
255		break;
256		case 2:
257		channel->on = data & 0x40;
258		channel->waveform = (data & 0x30) >> 4;
259		channel->volume = data & 0xf;
260		break;
261		case 3:
262		channel->count = data + 1;
263		break;
264		}
265		}

trunk/src/mess/audio/svis_snd.c

r0	r32680
	1	/***************************************************************************
	2	supervision sound hardware
	3
	4	PeT mess@utanet.at
	5	***************************************************************************/
	6
	7	#include "emu.h"
	8	#include "svis_snd.h"
	9
	10
	11	// device type definition
	12	const device_type SVISION_SND = &device_creator<svision_sound_device>;
	13
	14
	15	//**************************************************************************
	16	//  LIVE DEVICE
	17	//**************************************************************************
	18
	19	//-------------------------------------------------
	20	//  svision_sound_device - constructor
	21	//-------------------------------------------------
	22
	23	svision_sound_device::svision_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	24	: device_t(mconfig, SVISION_SND, "Super Vision Audio Custom", tag, owner, clock, "svision_sound", __FILE__),
	25	device_sound_interface(mconfig, *this),
	26	m_mixer_channel(NULL)
	27	{
	28	}
	29
	30
	31	//-------------------------------------------------
	32	//  device_start - device-specific startup
	33	//-------------------------------------------------
	34
	35	void svision_sound_device::device_start()
	36	{
	37	// bind callbacks
	38	m_irq_cb.bind_relative_to(*owner());
	39
	40	memset(&m_dma, 0, sizeof(m_dma));
	41	memset(&m_noise, 0, sizeof(m_noise));
	42	memset(m_channel, 0, sizeof(m_channel));
	43
	44	m_mixer_channel = stream_alloc(0, 2, machine().sample_rate());
	45	}
	46
	47
	48	//-------------------------------------------------
	49	//  sound_stream_update - handle a stream update
	50	//-------------------------------------------------
	51
	52	void svision_sound_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
	53	{
	54	stream_sample_t *left=outputs[0], *right=outputs[1];
	55	int i, j;
	56	SVISION_CHANNEL *channel;
	57
	58	for (i = 0; i < samples; i++, left++, right++)
	59	{
	60	*left = 0;
	61	*right = 0;
	62	for (channel=m_channel, j=0; j<ARRAY_LENGTH(m_channel); j++, channel++)
	63	{
	64	if (channel->size != 0)
	65	{
	66	if (channel->on||channel->count)
	67	{
	68	int on = FALSE;
	69	switch (channel->waveform)
	70	{
	71	case 0:
	72	on = channel->pos <= (28 * channel->size) >> 5;
	73	break;
	74	case 1:
	75	on = channel->pos <= (24 * channel->size) >> 5;
	76	break;
	77	default:
	78	case 2:
	79	on = channel->pos <= channel->size / 2;
	80	break;
	81	case 3:
	82	on = channel->pos <= (9 * channel->size) >> 5;
	83	break;
	84	}
	85	{
	86	INT16 s = on ? channel->volume << 8 : 0;
	87	if (j == 0)
	88	*right += s;
	89	else
	90	*left += s;
	91	}
	92	}
	93	channel->pos++;
	94	if (channel->pos >= channel->size)
	95	channel->pos = 0;
	96	}
	97	}
	98	if (m_noise.on && (m_noise.play || m_noise.count))
	99	{
	100	INT16 s = (m_noise.value ? 1 << 8: 0) * m_noise.volume;
	101	int b1, b2;
	102	if (m_noise.left)
	103	*left += s;
	104	if (m_noise.right)
	105	*right += s;
	106	m_noise.pos += m_noise.step;
	107	if (m_noise.pos >= 1.0)
	108	{
	109	switch (m_noise.type)
	110	{
	111	case SVISION_NOISE_Type7Bit:
	112	m_noise.value = m_noise.state & 0x40 ? 1 : 0;
	113	b1 = (m_noise.state & 0x40) != 0;
	114	b2 = (m_noise.state & 0x20) != 0;
	115	m_noise.state=(m_noise.state<<1)+(b1!=b2?1:0);
	116	break;
	117	case SVISION_NOISE_Type14Bit:
	118	default:
	119	m_noise.value = m_noise.state & 0x2000 ? 1 : 0;
	120	b1 = (m_noise.state & 0x2000) != 0;
	121	b2 = (m_noise.state & 0x1000) != 0;
	122	m_noise.state = (m_noise.state << 1) + (b1 != b2 ? 1 : 0);
	123	}
	124	m_noise.pos -= 1;
	125	}
	126	}
	127	if (m_dma.on)
	128	{
	129	UINT8 sample;
	130	INT16 s;
	131	UINT16 addr = m_dma.start + (unsigned) m_dma.pos / 2;
	132	if (addr >= 0x8000 && addr < 0xc000)
	133	{
	134	sample = machine().root_device().memregion("user1")->base()[(addr & 0x3fff) | m_dma.ca14to16];
	135	}
	136	else
	137	{
	138	sample = machine().device("maincpu")->memory().space(AS_PROGRAM).read_byte(addr);
	139	}
	140	if (((unsigned)m_dma.pos) & 1)
	141	s = (sample & 0xf);
	142	else
	143	s = (sample & 0xf0) >> 4;
	144	s <<= 8;
	145	if (m_dma.left)
	146	*left += s;
	147	if (m_dma.right)
	148	*right += s;
	149	m_dma.pos += m_dma.step;
	150	if (m_dma.pos >= m_dma.size)
	151	{
	152	m_dma.finished = TRUE;
	153	m_dma.on = FALSE;
	154	m_irq_cb();
	155	}
	156	}
	157	}
	158	}
	159
	160
	161	WRITE8_MEMBER( svision_sound_device::sounddma_w )
	162	{
	163	logerror("%.6f svision snddma write %04x %02x\n", space.machine().time().as_double(),offset+0x18,data);
	164	m_dma.reg[offset] = data;
	165	switch (offset)
	166	{
	167	case 0:
	168	case 1:
	169	m_dma.start = (m_dma.reg[0] | (m_dma.reg[1] << 8));
	170	break;
	171	case 2:
	172	m_dma.size = (data ? data : 0x100) * 32;
	173	break;
	174	case 3:
	175	m_dma.step = space.machine().device("maincpu")->unscaled_clock() / (256.0 * space.machine().sample_rate() * (1 + (data & 3)));
	176	m_dma.right = data & 4;
	177	m_dma.left = data & 8;
	178	m_dma.ca14to16 = ((data & 0x70) >> 4) << 14;
	179	break;
	180	case 4:
	181	m_dma.on = data & 0x80;
	182	if (m_dma.on)
	183	{
	184	m_dma.pos = 0.0;
	185	}
	186	break;
	187	}
	188	}
	189
	190
	191	WRITE8_MEMBER( svision_sound_device::noise_w )
	192	{
	193	//  logerror("%.6f svision noise write %04x %02x\n",machine.time(),offset+0x28,data);
	194	m_noise.reg[offset]=data;
	195	switch (offset)
	196	{
	197	case 0:
	198	m_noise.volume=data&0xf;
	199	m_noise.step= space.machine().device("maincpu")->unscaled_clock() / (256.0*space.machine().sample_rate()*(1+(data>>4)));
	200	break;
	201	case 1:
	202	m_noise.count = data + 1;
	203	break;
	204	case 2:
	205	m_noise.type = (SVISION_NOISE_Type) (data & 1);
	206	m_noise.play = data & 2;
	207	m_noise.right = data & 4;
	208	m_noise.left = data & 8;
	209	m_noise.on = data & 0x10; /* honey bee start */
	210	m_noise.state = 1;
	211	break;
	212	}
	213	m_noise.pos=0.0;
	214	}
	215
	216
	217	int *svision_sound_device::dma_finished()
	218	{
	219	return &m_dma.finished;
	220	}
	221
	222
	223	void svision_sound_device::sound_decrement()
	224	{
	225	if (m_channel[0].count > 0)
	226	m_channel[0].count--;
	227	if (m_channel[1].count > 0)
	228	m_channel[1].count--;
	229	if (m_noise.count > 0)
	230	m_noise.count--;
	231	}
	232
	233
	234	void svision_sound_device::soundport_w(int which, int offset, int data)
	235	{
	236	SVISION_CHANNEL *channel = &m_channel[which];
	237	UINT16 size;
	238
	239	m_mixer_channel->update();
	240	channel->reg[offset] = data;
	241
	242	switch (offset)
	243	{
	244	case 0:
	245	case 1:
	246	size = channel->reg[0] | ((channel->reg[1] & 7) << 8);
	247	if (size)
	248	{
	249	//  channel->size=(int)(device->machine().sample_rate()*(size<<5)/4e6);
	250	channel->size= (int) (machine().sample_rate() * (size << 5) / machine().device("maincpu")->unscaled_clock());
	251	}
	252	else
	253	{
	254	channel->size = 0;
	255	}
	256	channel->pos = 0;
	257	break;
	258	case 2:
	259	channel->on = data & 0x40;
	260	channel->waveform = (data & 0x30) >> 4;
	261	channel->volume = data & 0xf;
	262	break;
	263	case 3:
	264	channel->count = data + 1;
	265	break;
	266	}
	267	}

Property changes on: trunk/src/mess/audio/svis_snd.c

Added: svn:eol-style    + native Added: svn:mime-type    + text/plain

trunk/src/mess/audio/svis_snd.h

r0	r32680
	1	/*****************************************************************************
	2	*
	3	*  svis_snd.h
	4	*
	5	****************************************************************************/
	6
	7	#ifndef SVIS_SND_H_
	8	#define SVIS_SND_H_
	9
	10
	11	//**************************************************************************
	12	//  TYPE DEFINITIONS
	13	//**************************************************************************
	14
	15	enum SVISION_NOISE_Type
	16	{
	17	SVISION_NOISE_Type7Bit,
	18	SVISION_NOISE_Type14Bit
	19	};
	20
	21	struct SVISION_NOISE
	22	{
	23	SVISION_NOISE() :
	24	on(0),
	25	right(0),
	26	left(0),
	27	play(0),
	28	type(SVISION_NOISE_Type7Bit),
	29	state(0),
	30	volume(0),
	31	count(0),
	32	step(0.0),
	33	pos(0.0),
	34	value(0)
	35	{
	36	memset(reg, 0, sizeof(UINT8)*3);
	37	}
	38
	39	UINT8 reg[3];
	40	int on, right, left, play;
	41	SVISION_NOISE_Type type;
	42	int state;
	43	int volume;
	44	int count;
	45	double step, pos;
	46	int value; // currently simple random function
	47	};
	48
	49	struct SVISION_DMA
	50	{
	51	SVISION_DMA() :
	52	on(0),
	53	right(0),
	54	left(0),
	55	ca14to16(0),
	56	start(0),
	57	size(0),
	58	pos(0.0),
	59	step(0.0),
	60	finished(0)
	61	{
	62	memset(reg, 0, sizeof(UINT8)*5);
	63	}
	64
	65	UINT8 reg[5];
	66	int on, right, left;
	67	int ca14to16;
	68	int start,size;
	69	double pos, step;
	70	int finished;
	71	};
	72
	73	struct SVISION_CHANNEL
	74	{
	75	SVISION_CHANNEL() :
	76	on(0),
	77	waveform(0),
	78	volume(0),
	79	pos(0),
	80	size(0),
	81	count(0)
	82	{
	83	memset(reg, 0, sizeof(UINT8)*4);
	84	}
	85
	86	UINT8 reg[4];
	87	int on;
	88	int waveform, volume;
	89	int pos;
	90	int size;
	91	int count;
	92	};
	93
	94	typedef device_delegate<void (void)> svision_snd_irq_delegate;
	95	#define SVISION_SND_IRQ_MEMBER(_name)   void _name(void)
	96
	97	#define SVISION_SND_IRQ_CB(_class, _method) \
	98	svision_sound_device::set_irq_callback(*device, svision_snd_irq_delegate(&_class::_method, #_class "::" #_method, downcast<_class *>(owner)));
	99
	100	// ======================> svision_sound_device
	101
	102	class svision_sound_device : public device_t,
	103	public device_sound_interface
	104	{
	105	public:
	106	svision_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	107	~svision_sound_device() { }
	108
	109	// static configuration
	110	static void set_irq_callback(device_t &device, svision_snd_irq_delegate callback) { downcast<svision_sound_device &>(device).m_irq_cb = callback; }
	111
	112	protected:
	113	// device-level overrides
	114	virtual void device_start();
	115
	116	// sound stream update overrides
	117	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	118
	119	public:
	120	DECLARE_WRITE8_MEMBER( sounddma_w );
	121	DECLARE_WRITE8_MEMBER( noise_w );
	122
	123	public:
	124	int *dma_finished();
	125	void sound_decrement();
	126	void soundport_w(int which, int offset, int data);
	127
	128	private:
	129	svision_snd_irq_delegate m_irq_cb;
	130
	131	sound_stream *m_mixer_channel;
	132	SVISION_DMA m_dma;
	133	SVISION_NOISE m_noise;
	134	SVISION_CHANNEL m_channel[2];
	135	};
	136
	137	extern const device_type SVISION_SND;
	138
	139
	140	#endif /* SVIS_SND_H_ */

Property changes on: trunk/src/mess/audio/svis_snd.h

Added: svn:mime-type    + text/plain Added: svn:eol-style    + native

trunk/src/mess/includes/svision.h

r32679	r32680
8	8	#define SVISION_H_
9	9
10	10	#include "cpu/m6502/m65c02.h"
	11	#include "audio/svis_snd.h"
11	12	#include "bus/generic/slot.h"
12	13	#include "bus/generic/carts.h"
13	14
r32679	r32680
31	32	int palette_on;
32	33	};
33	34
34		class svision_sound_device; // defined below
35
36	35	class svision_state : public driver_device
37	36	{
38	37	public:
39	38	svision_state(const machine_config &mconfig, device_type type, const char *tag)
40	39	: driver_device(mconfig, type, tag),
41	40	m_maincpu(*this, "maincpu"),
	41	m_sound(*this, "custom"),
42	42	m_cart(*this, "cartslot"),
43	43	m_reg(*this, "reg"),
44	44	m_videoram(*this, "videoram"),
r32679	r32680
46	46	m_joy2(*this, "JOY2"),
47	47	m_palette(*this, "palette")  { }
48	48
49		svision_sound_device *m_sound;
50	49	int *m_dma_finished;
51	50	svision_t m_svision;
52	51	svision_pet_t m_pet;
r32679	r32680
75	74
76	75	protected:
77	76	required_device<cpu_device> m_maincpu;
	77	required_device<svision_sound_device> m_sound;
78	78	required_device<generic_slot_device> m_cart;
79	79	required_shared_ptr<UINT8> m_reg;
80	80	required_shared_ptr<UINT8> m_videoram;
r32679	r32680
87	87	memory_bank *m_bank2;
88	88	};
89	89
90
91		/*----------- defined in drivers/svision.c -----------*/
92
93		void svision_irq( running_machine &machine );
94
95
96		/*----------- defined in audio/svision.c -----------*/
97
98
99		//**************************************************************************
100		//  TYPE DEFINITIONS
101		//**************************************************************************
102
103		enum SVISION_NOISE_Type
104		{
105		SVISION_NOISE_Type7Bit,
106		SVISION_NOISE_Type14Bit
107		};
108
109		struct SVISION_NOISE
110		{
111		SVISION_NOISE() :
112		on(0),
113		right(0),
114		left(0),
115		play(0),
116		type(SVISION_NOISE_Type7Bit),
117		state(0),
118		volume(0),
119		count(0),
120		step(0.0),
121		pos(0.0),
122		value(0)
123		{
124		memset(reg, 0, sizeof(UINT8)*3);
125		}
126
127		UINT8 reg[3];
128		int on, right, left, play;
129		SVISION_NOISE_Type type;
130		int state;
131		int volume;
132		int count;
133		double step, pos;
134		int value; // currently simple random function
135		};
136
137		struct SVISION_DMA
138		{
139		SVISION_DMA() :
140		on(0),
141		right(0),
142		left(0),
143		ca14to16(0),
144		start(0),
145		size(0),
146		pos(0.0),
147		step(0.0),
148		finished(0)
149		{
150		memset(reg, 0, sizeof(UINT8)*5);
151		}
152
153		UINT8 reg[5];
154		int on, right, left;
155		int ca14to16;
156		int start,size;
157		double pos, step;
158		int finished;
159		};
160
161		struct SVISION_CHANNEL
162		{
163		SVISION_CHANNEL() :
164		on(0),
165		waveform(0),
166		volume(0),
167		pos(0),
168		size(0),
169		count(0)
170		{
171		memset(reg, 0, sizeof(UINT8)*4);
172		}
173
174		UINT8 reg[4];
175		int on;
176		int waveform, volume;
177		int pos;
178		int size;
179		int count;
180		};
181
182
183		// ======================> svision_sound_device
184
185		class svision_sound_device : public device_t,
186		public device_sound_interface
187		{
188		public:
189		svision_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
190		~svision_sound_device() { }
191
192		protected:
193		// device-level overrides
194		virtual void device_start();
195
196		// sound stream update overrides
197		virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
198
199		public:
200		DECLARE_WRITE8_MEMBER( svision_sounddma_w );
201		DECLARE_WRITE8_MEMBER( svision_noise_w );
202
203		public:
204		int *dma_finished();
205		void sound_decrement();
206		void soundport_w(int which, int offset, int data);
207
208		private:
209		sound_stream *m_mixer_channel;
210		SVISION_DMA m_dma;
211		SVISION_NOISE m_noise;
212		SVISION_CHANNEL m_channel[2];
213		};
214
215		extern const device_type SVISION;
216
217
218	90	#endif /* SVISION_H_ */

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team