Previous

199869 Revisions

Next

r31475 Wednesday 30th July, 2014 at 20:35:53 UTC by hap
fix prev commit again + removed unneeded class member names prefixes

[src/emu/video]	epic12.c epic12.h epic12in.inc
[src/mame/drivers]	cv1k.c

trunk/src/mame/drivers/cv1k.c

r31474	r31475
349	349	AM_RANGE(SH3_PORT_E, SH3_PORT_E+7) AM_READ( cv1k_flash_port_e_r )
350	350	AM_RANGE(SH3_PORT_F, SH3_PORT_F+7) AM_READ_PORT("PORT_F")
351	351	AM_RANGE(SH3_PORT_L, SH3_PORT_L+7) AM_READ_PORT("PORT_L")
352		AM_RANGE(SH3_PORT_J, SH3_PORT_J+7) AM_DEVREADWRITE( "blitter", epic12_device, epic12_device_fpga_r, epic12_device_fpga_w )
	352	AM_RANGE(SH3_PORT_J, SH3_PORT_J+7) AM_DEVREADWRITE( "blitter", epic12_device, fpga_r, fpga_w )
353	353	ADDRESS_MAP_END
354	354
355	355

trunk/src/emu/video/epic12in.inc

r31474	r31475
	1	/* blitter function */
1	2
2
3
4	3	const void epic12_device::FUNCNAME(BLIT_PARAMS)
5	4	{
6	5	UINT32* gfx2;

trunk/src/emu/video/epic12.c

r31474	r31475
13	13	{
14	14	m_is_unsafe = 0;
15	15	m_delay_scale = 0;
16		m_maincpu = 0;
17		queue = 0;
18		blitter_request = 0;
19		epic12_device_blitter_delay_timer = 0;
20		blitter_busy = 0;
21		use_ram = 0;
22		epic12_device_ram16 = 0;
23		epic12_device_gfx_addr = 0;
24		epic12_device_gfx_scroll_0_x = 0;
25		epic12_device_gfx_scroll_0_y = 0;
26		epic12_device_gfx_scroll_1_x = 0;
27		epic12_device_gfx_scroll_1_y = 0;
28		epic12_device_gfx_size = 0;
29		epic12_device_gfx_addr_shadowcopy = 0;
30		epic12_device_gfx_scroll_0_x_shadowcopy = 0;
31		epic12_device_gfx_scroll_0_y_shadowcopy = 0;
32		epic12_device_gfx_scroll_1_x_shadowcopy = 0;
33		epic12_device_gfx_scroll_1_y_shadowcopy = 0;
34		epic12_device_ram16_copy = 0;
	16	m_blitter_request = 0;
	17	m_blitter_delay_timer = 0;
	18	m_blitter_busy = 0;
	19	m_gfx_addr = 0;
	20	m_gfx_scroll_0_x = 0;
	21	m_gfx_scroll_0_y = 0;
	22	m_gfx_scroll_1_x = 0;
	23	m_gfx_scroll_1_y = 0;
	24	m_gfx_addr_shadowcopy = 0;
	25	m_gfx_scroll_0_x_shadowcopy = 0;
	26	m_gfx_scroll_0_y_shadowcopy = 0;
	27	m_gfx_scroll_1_x_shadowcopy = 0;
	28	m_gfx_scroll_1_y_shadowcopy = 0;
35	29	epic12_device_blit_delay = 0;
36	30	}
37	31
38		TIMER_CALLBACK_MEMBER( epic12_device::epic12_device_blitter_delay_callback )
	32	TIMER_CALLBACK_MEMBER( epic12_device::blitter_delay_callback )
39	33	{
40		blitter_busy = 0;
	34	m_blitter_busy = 0;
41	35	}
42	36
43	37
44	38	void epic12_device::device_start()
45	39	{
46		epic12_device_gfx_size = 0x2000 * 0x1000;
47		epic12_device_bitmaps = auto_bitmap_rgb32_alloc(machine(), 0x2000, 0x1000);
48		epic12_device_clip = epic12_device_bitmaps->cliprect();
49		epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1);
	40	m_gfx_size = 0x2000 * 0x1000;
	41	m_bitmaps = auto_bitmap_rgb32_alloc(machine(), 0x2000, 0x1000);
	42	m_clip = m_bitmaps->cliprect();
	43	m_clip.set(0, 0x2000-1, 0, 0x1000-1);
50	44
51		epic12_device_ram16_copy = auto_alloc_array(machine(), UINT16, m_main_ramsize/2);
	45	m_ram16_copy = auto_alloc_array(machine(), UINT16, m_main_ramsize/2);
52	46
53		epic12_device_blitter_delay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(epic12_device::epic12_device_blitter_delay_callback),this));
54		epic12_device_blitter_delay_timer->adjust(attotime::never);
	47	m_blitter_delay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(epic12_device::blitter_delay_callback),this));
	48	m_blitter_delay_timer->adjust(attotime::never);
55	49	}
56	50
57	51	void epic12_device::device_reset()
58	52	{
59	53	if (m_is_unsafe)
60	54	{
61		use_ram = epic12_device_ram16;
62		queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ|WORK_QUEUE_FLAG_MULTI);
	55	m_use_ram = m_ram16;
	56	m_work_queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ|WORK_QUEUE_FLAG_MULTI);
63	57	}
64	58	else
65	59	{
66		use_ram = epic12_device_ram16_copy; // slow mode
67		queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ);
	60	m_use_ram = m_ram16_copy; // slow mode
	61	m_work_queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ);
68	62	}
69	63
70
71	64	// cache table to avoid divides in blit code, also pre-clamped
72	65	int x,y;
73	66	for (y=0;y<0x40;y++)
r31474	r31475
92	85	}
93	86	}
94	87
95		blitter_busy = 0;
96
	88	m_blitter_busy = 0;
97	89	}
98	90
99	91	// todo, get these into the device class without ruining performance
r31474	r31475
105	97	inline UINT16 epic12_device::READ_NEXT_WORD(offs_t *addr)
106	98	{
107	99	//  UINT16 data = space.read_word(*addr); // going through the memory system is 'more correct' but noticably slower
108		UINT16 data = use_ram[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)];
	100	UINT16 data = m_use_ram[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)];
109	101
110	102	*addr += 2;
111	103
r31474	r31475
116	108	inline UINT16 epic12_device::COPY_NEXT_WORD(address_space &space, offs_t *addr)
117	109	{
118	110	//  UINT16 data = space.read_word(*addr); // going through the memory system is 'more correct' but noticably slower
119		UINT16 data = epic12_device_ram16[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)];
120		epic12_device_ram16_copy[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)] = data;
	111	UINT16 data = m_ram16[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)];
	112	m_ram16_copy[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)] = data;
121	113
122	114	*addr += 2;
123	115
r31474	r31475
126	118	}
127	119
128	120
129		inline void epic12_device::epic12_device_gfx_upload_shadow_copy(address_space &space, offs_t *addr)
	121	inline void epic12_device::gfx_upload_shadow_copy(address_space &space, offs_t *addr)
130	122	{
131	123	UINT32 x,y, dimx,dimy;
132	124	COPY_NEXT_WORD(space, addr);
r31474	r31475
148	140	}
149	141	}
150	142
151		inline void epic12_device::epic12_device_gfx_upload(offs_t *addr)
	143	inline void epic12_device::gfx_upload(offs_t *addr)
152	144	{
153	145	UINT32 x,y, dst_p,dst_x_start,dst_y_start, dimx,dimy;
154	146	UINT32 *dst;
r31474	r31475
175	167
176	168	for (y = 0; y < dimy; y++)
177	169	{
178		dst = &epic12_device_bitmaps->pix(dst_y_start + y, 0);
	170	dst = &m_bitmaps->pix(dst_y_start + y, 0);
179	171	dst += dst_x_start;
180	172
181	173	for (x = 0; x < dimx; x++)
r31474	r31475
191	183	}
192	184	}
193	185
194		#define draw_params epic12_device_bitmaps, &epic12_device_clip, &epic12_device_bitmaps->pix(0,0),src_x,src_y, x,y, dimx,dimy, flipy, s_alpha, d_alpha, &tint_clr
	186	#define draw_params m_bitmaps, &m_clip, &m_bitmaps->pix(0,0),src_x,src_y, x,y, dimx,dimy, flipy, s_alpha, d_alpha, &tint_clr
195	187
196	188
197	189
r31474	r31475
295	287
296	288
297	289
298		inline void epic12_device::epic12_device_gfx_draw_shadow_copy(address_space &space, offs_t *addr)
	290	inline void epic12_device::gfx_draw_shadow_copy(address_space &space, offs_t *addr)
299	291	{
300	292	COPY_NEXT_WORD(space, addr);
301	293	COPY_NEXT_WORD(space, addr);
r31474	r31475
317	309
318	310
319	311
320		inline void epic12_device::epic12_device_gfx_draw(offs_t *addr)
	312	inline void epic12_device::gfx_draw(offs_t *addr)
321	313	{
322	314	int x,y, dimx,dimy, flipx,flipy;//, src_p;
323	315	int trans,blend, s_mode, d_mode;
r31474	r31475
533	525	}
534	526
535	527
536		void epic12_device::epic12_device_gfx_create_shadow_copy(address_space &space)
	528	void epic12_device::gfx_create_shadow_copy(address_space &space)
537	529	{
538		offs_t addr = epic12_device_gfx_addr & 0x1fffffff;
539		epic12_device_clip.set(epic12_device_gfx_scroll_1_x_shadowcopy, epic12_device_clip.min_x + 320-1, epic12_device_gfx_scroll_1_y_shadowcopy, epic12_device_clip.min_y + 240-1);
	530	offs_t addr = m_gfx_addr & 0x1fffffff;
	531	m_clip.set(m_gfx_scroll_1_x_shadowcopy, m_gfx_scroll_1_x_shadowcopy + 320-1, m_gfx_scroll_1_y_shadowcopy, m_gfx_scroll_1_y_shadowcopy + 240-1);
540	532
541	533	while (1)
542	534	{
r31474	r31475
550	542
551	543	case 0xc000:
552	544	if (COPY_NEXT_WORD(space, &addr)) // cliptype
553		epic12_device_clip.set(epic12_device_gfx_scroll_1_x_shadowcopy, epic12_device_clip.min_x + 320-1, epic12_device_gfx_scroll_1_y_shadowcopy, epic12_device_clip.min_y + 240-1);
	545	m_clip.set(m_gfx_scroll_1_x_shadowcopy, m_gfx_scroll_1_x_shadowcopy + 320-1, m_gfx_scroll_1_y_shadowcopy, m_gfx_scroll_1_y_shadowcopy + 240-1);
554	546	else
555		epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1);
	547	m_clip.set(0, 0x2000-1, 0, 0x1000-1);
556	548	break;
557	549
558	550	case 0x2000:
559	551	addr -= 2;
560		epic12_device_gfx_upload_shadow_copy(space, &addr);
	552	gfx_upload_shadow_copy(space, &addr);
561	553	break;
562	554
563	555	case 0x1000:
564	556	addr -= 2;
565		epic12_device_gfx_draw_shadow_copy(space, &addr);
	557	gfx_draw_shadow_copy(space, &addr);
566	558	break;
567	559
568	560	default:
r31474	r31475
573	565	}
574	566
575	567
576		void epic12_device::epic12_device_gfx_exec(void)
	568	void epic12_device::gfx_exec(void)
577	569	{
578		offs_t addr = epic12_device_gfx_addr_shadowcopy & 0x1fffffff;
579		epic12_device_clip.set(epic12_device_gfx_scroll_1_x_shadowcopy, epic12_device_clip.min_x + 320-1, epic12_device_gfx_scroll_1_y_shadowcopy, epic12_device_clip.min_y + 240-1);
	570	offs_t addr = m_gfx_addr_shadowcopy & 0x1fffffff;
	571	m_clip.set(m_gfx_scroll_1_x_shadowcopy, m_gfx_scroll_1_x_shadowcopy + 320-1, m_gfx_scroll_1_y_shadowcopy, m_gfx_scroll_1_y_shadowcopy + 240-1);
580	572
581	573	//  logerror("GFX EXEC: %08X\n", addr);
582	574
r31474	r31475
592	584
593	585	case 0xc000:
594	586	if (READ_NEXT_WORD(&addr)) // cliptype
595		epic12_device_clip.set(epic12_device_gfx_scroll_1_x_shadowcopy, epic12_device_clip.min_x + 320-1, epic12_device_gfx_scroll_1_y_shadowcopy, epic12_device_clip.min_y + 240-1);
	587	m_clip.set(m_gfx_scroll_1_x_shadowcopy, m_gfx_scroll_1_x_shadowcopy + 320-1, m_gfx_scroll_1_y_shadowcopy, m_gfx_scroll_1_y_shadowcopy + 240-1);
596	588	else
597		epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1);
	589	m_clip.set(0, 0x2000-1, 0, 0x1000-1);
598	590	break;
599	591
600	592	case 0x2000:
601	593	addr -= 2;
602		epic12_device_gfx_upload(&addr);
	594	gfx_upload(&addr);
603	595	break;
604	596
605	597	case 0x1000:
606	598	addr -= 2;
607		epic12_device_gfx_draw(&addr);
	599	gfx_draw(&addr);
608	600	break;
609	601
610	602	default:
r31474	r31475
615	607	}
616	608
617	609
618		void epic12_device::epic12_device_gfx_exec_unsafe(void)
	610	void epic12_device::gfx_exec_unsafe(void)
619	611	{
620		offs_t addr = epic12_device_gfx_addr & 0x1fffffff;
621		epic12_device_clip.set(epic12_device_gfx_scroll_1_x, epic12_device_clip.min_x + 320-1, epic12_device_gfx_scroll_1_y, epic12_device_clip.min_y + 240-1);
	612	offs_t addr = m_gfx_addr & 0x1fffffff;
	613	m_clip.set(m_gfx_scroll_1_x, m_gfx_scroll_1_x + 320-1, m_gfx_scroll_1_y, m_gfx_scroll_1_y + 240-1);
622	614
623	615	//  logerror("GFX EXEC: %08X\n", addr);
624	616
r31474	r31475
634	626
635	627	case 0xc000:
636	628	if (READ_NEXT_WORD(&addr)) // cliptype
637		epic12_device_clip.set(epic12_device_gfx_scroll_1_x, epic12_device_clip.min_x + 320-1, epic12_device_gfx_scroll_1_y, epic12_device_clip.min_y + 240-1);
	629	m_clip.set(m_gfx_scroll_1_x, m_gfx_scroll_1_x + 320-1, m_gfx_scroll_1_y, m_gfx_scroll_1_y + 240-1);
638	630	else
639		epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1);
	631	m_clip.set(0, 0x2000-1, 0, 0x1000-1);
640	632	break;
641	633
642	634	case 0x2000:
643	635	addr -= 2;
644		epic12_device_gfx_upload(&addr);
	636	gfx_upload(&addr);
645	637	break;
646	638
647	639	case 0x1000:
648	640	addr -= 2;
649		epic12_device_gfx_draw(&addr);
	641	gfx_draw(&addr);
650	642	break;
651	643
652	644	default:
r31474	r31475
662	654	{
663	655	epic12_device *object = reinterpret_cast<epic12_device *>(param);
664	656
665		object->epic12_device_gfx_exec();
	657	object->gfx_exec();
666	658	return NULL;
667	659	}
668	660
r31474	r31475
673	665	epic12_device *object = reinterpret_cast<epic12_device *>(param);
674	666
675	667	epic12_device_blit_delay = 0;
676		object->epic12_device_gfx_exec_unsafe();
	668	object->gfx_exec_unsafe();
677	669	return NULL;
678	670	}
679	671
680	672
681		READ32_MEMBER( epic12_device::epic12_device_gfx_ready_r )
	673	READ32_MEMBER( epic12_device::gfx_ready_r )
682	674	{
683	675	return 0x00000010;
684	676	}
685	677
686		READ32_MEMBER( epic12_device::epic12_device_gfx_ready_r_unsafe )
	678	READ32_MEMBER( epic12_device::gfx_ready_r_unsafe )
687	679	{
688		if (blitter_busy)
	680	if (m_blitter_busy)
689	681	{
690	682	m_maincpu->spin_until_time(attotime::from_usec(10));
691	683	return 0x00000000;
r31474	r31475
694	686	return 0x00000010;
695	687	}
696	688
697		WRITE32_MEMBER( epic12_device::epic12_device_gfx_exec_w )
	689	WRITE32_MEMBER( epic12_device::gfx_exec_w )
698	690	{
699	691	if ( ACCESSING_BITS_0_7 )
700	692	{
r31474	r31475
702	694	{
703	695	//g_profiler.start(PROFILER_USER1);
704	696	// make sure we've not already got a request running
705		if (blitter_request)
	697	if (m_blitter_request)
706	698	{
707	699	int result;
708	700	do
709	701	{
710		result = osd_work_item_wait(blitter_request, 1000);
	702	result = osd_work_item_wait(m_blitter_request, 1000);
711	703	} while (result==0);
712		osd_work_item_release(blitter_request);
	704	osd_work_item_release(m_blitter_request);
713	705	}
714	706
715	707	epic12_device_blit_delay = 0;
716		epic12_device_gfx_create_shadow_copy(space); // create a copy of the blit list so we can safely thread it.
	708	gfx_create_shadow_copy(space); // create a copy of the blit list so we can safely thread it.
717	709
718	710	if (epic12_device_blit_delay)
719	711	{
720		blitter_busy = 1;
721		epic12_device_blitter_delay_timer->adjust(attotime::from_nsec(epic12_device_blit_delay*8)); // NOT accurate timing (currently ignored anyway)
	712	m_blitter_busy = 1;
	713	m_blitter_delay_timer->adjust(attotime::from_nsec(epic12_device_blit_delay*8)); // NOT accurate timing (currently ignored anyway)
722	714	}
723	715
724		epic12_device_gfx_addr_shadowcopy = epic12_device_gfx_addr;
725		epic12_device_gfx_scroll_0_x_shadowcopy =  epic12_device_gfx_scroll_0_x;
726		epic12_device_gfx_scroll_0_y_shadowcopy = epic12_device_gfx_scroll_0_y;
727		epic12_device_gfx_scroll_1_x_shadowcopy = epic12_device_gfx_scroll_1_x;
728		epic12_device_gfx_scroll_1_y_shadowcopy = epic12_device_gfx_scroll_1_y;
729		blitter_request = osd_work_item_queue(queue, blit_request_callback, (void*)this, 0);
	716	m_gfx_addr_shadowcopy = m_gfx_addr;
	717	m_gfx_scroll_0_x_shadowcopy =  m_gfx_scroll_0_x;
	718	m_gfx_scroll_0_y_shadowcopy = m_gfx_scroll_0_y;
	719	m_gfx_scroll_1_x_shadowcopy = m_gfx_scroll_1_x;
	720	m_gfx_scroll_1_y_shadowcopy = m_gfx_scroll_1_y;
	721	m_blitter_request = osd_work_item_queue(m_work_queue, blit_request_callback, (void*)this, 0);
730	722	//g_profiler.stop();
731	723	}
732	724	}
733	725	}
734	726
735	727
736		WRITE32_MEMBER( epic12_device::epic12_device_gfx_exec_w_unsafe )
	728	WRITE32_MEMBER( epic12_device::gfx_exec_w_unsafe )
737	729	{
738	730	if ( ACCESSING_BITS_0_7 )
739	731	{
r31474	r31475
741	733	{
742	734	//g_profiler.start(PROFILER_USER1);
743	735	// make sure we've not already got a request running
744		if (blitter_request)
	736	if (m_blitter_request)
745	737	{
746	738	int result;
747	739	do
748	740	{
749		result = osd_work_item_wait(blitter_request, 1000);
	741	result = osd_work_item_wait(m_blitter_request, 1000);
750	742	} while (result==0);
751		osd_work_item_release(blitter_request);
	743	osd_work_item_release(m_blitter_request);
752	744	}
753	745
754	746	if (epic12_device_blit_delay)
755	747	{
756		blitter_busy = 1;
	748	m_blitter_busy = 1;
757	749	int delay = epic12_device_blit_delay*(15 * m_delay_scale / 50);
758	750	//printf("delay %d\n", delay);
759		epic12_device_blitter_delay_timer->adjust(attotime::from_nsec(delay));
	751	m_blitter_delay_timer->adjust(attotime::from_nsec(delay));
760	752	}
761	753	else
762	754	{
763		blitter_busy = 0;
	755	m_blitter_busy = 0;
764	756	}
765	757
766		blitter_request = osd_work_item_queue(queue, blit_request_callback_unsafe, (void*)this, 0);
	758	m_blitter_request = osd_work_item_queue(m_work_queue, blit_request_callback_unsafe, (void*)this, 0);
767	759	//g_profiler.stop();
768	760	}
769	761	}
r31474	r31475
774	766	{
775	767	if (!m_is_unsafe)
776	768	{
777		if (blitter_request)
	769	if (m_blitter_request)
778	770	{
779	771	int result;
780	772	do
781	773	{
782		result = osd_work_item_wait(blitter_request, 1000);
	774	result = osd_work_item_wait(m_blitter_request, 1000);
783	775	} while (result==0);
784		osd_work_item_release(blitter_request);
	776	osd_work_item_release(m_blitter_request);
785	777	}
786	778	}
787	779
r31474	r31475
790	782
791	783	bitmap.fill(0, cliprect);
792	784
793		scroll_0_x = -epic12_device_gfx_scroll_0_x;
794		scroll_0_y = -epic12_device_gfx_scroll_0_y;
795		//  scroll_1_x = -epic12_device_gfx_scroll_1_x;
796		//  scroll_1_y = -epic12_device_gfx_scroll_1_y;
	785	scroll_0_x = -m_gfx_scroll_0_x;
	786	scroll_0_y = -m_gfx_scroll_0_y;
	787	//  scroll_1_x = -m_gfx_scroll_1_x;
	788	//  scroll_1_y = -m_gfx_scroll_1_y;
797	789
798	790	//printf("SCREEN UPDATE\n %d %d %d %d\n", scroll_0_x, scroll_0_y, scroll_1_x, scroll_1_y);
799	791
800		copyscrollbitmap(bitmap, *epic12_device_bitmaps, 1,&scroll_0_x, 1,&scroll_0_y, cliprect);
	792	copyscrollbitmap(bitmap, *m_bitmaps, 1,&scroll_0_x, 1,&scroll_0_y, cliprect);
801	793	}
802	794
803	795
r31474	r31475
805	797
806	798
807	799
808		READ32_MEMBER( epic12_device::epic12_device_blitter_r )
	800	READ32_MEMBER( epic12_device::blitter_r )
809	801	{
810	802	switch (offset*4)
811	803	{
812	804	case 0x10:
813		return epic12_device::epic12_device_gfx_ready_r(space,offset,mem_mask);
	805	return gfx_ready_r(space, offset, mem_mask);
814	806
815	807	case 0x24:
816	808	return 0xffffffff;
r31474	r31475
822	814	return space.machine().root_device().ioport(":DSW")->read();
823	815
824	816	default:
825		logerror("unknownepic12_device_blitter_r %08x %08x\n", offset*4, mem_mask);
	817	logerror("unknownblitter_r %08x %08x\n", offset*4, mem_mask);
826	818	break;
827	819
828	820	}
829	821	return 0;
830	822	}
831	823
832		READ32_MEMBER( epic12_device::epic12_device_blitter_r_unsafe )
	824	READ32_MEMBER( epic12_device::blitter_r_unsafe )
833	825	{
834	826	switch (offset*4)
835	827	{
836	828	case 0x10:
837		return epic12_device::epic12_device_gfx_ready_r_unsafe(space,offset,mem_mask);
	829	return gfx_ready_r_unsafe(space, offset, mem_mask);
838	830
839	831	case 0x24:
840	832	return 0xffffffff;
r31474	r31475
846	838	return space.machine().root_device().ioport(":DSW")->read();
847	839
848	840	default:
849		logerror("unknownepic12_device_blitter_r %08x %08x\n", offset*4, mem_mask);
	841	logerror("unknownblitter_r %08x %08x\n", offset*4, mem_mask);
850	842	break;
851	843
852	844	}
r31474	r31475
854	846	}
855	847
856	848
857		WRITE32_MEMBER( epic12_device::epic12_device_blitter_w )
	849	WRITE32_MEMBER( epic12_device::blitter_w )
858	850	{
859	851	switch (offset*4)
860	852	{
861	853	case 0x04:
862		epic12_device_gfx_exec_w(space,offset,data,mem_mask);
	854	gfx_exec_w(space,offset,data,mem_mask);
863	855	break;
864	856
865	857	case 0x08:
866		COMBINE_DATA(&epic12_device_gfx_addr);
	858	COMBINE_DATA(&m_gfx_addr);
867	859	break;
868	860
869	861	case 0x14:
870		COMBINE_DATA(&epic12_device_gfx_scroll_0_x);
	862	COMBINE_DATA(&m_gfx_scroll_0_x);
871	863	break;
872	864
873	865	case 0x18:
874		COMBINE_DATA(&epic12_device_gfx_scroll_0_y);
	866	COMBINE_DATA(&m_gfx_scroll_0_y);
875	867	break;
876	868
877	869	case 0x40:
878		COMBINE_DATA(&epic12_device_gfx_scroll_1_x);
	870	COMBINE_DATA(&m_gfx_scroll_1_x);
879	871	break;
880	872
881	873	case 0x44:
882		COMBINE_DATA(&epic12_device_gfx_scroll_1_y);
	874	COMBINE_DATA(&m_gfx_scroll_1_y);
883	875	break;
884	876
885	877	}
886	878	}
887	879
888		WRITE32_MEMBER( epic12_device::epic12_device_blitter_w_unsafe )
	880	WRITE32_MEMBER( epic12_device::blitter_w_unsafe )
889	881	{
890	882	switch (offset*4)
891	883	{
892	884	case 0x04:
893		epic12_device_gfx_exec_w_unsafe(space,offset,data,mem_mask);
	885	gfx_exec_w_unsafe(space,offset,data,mem_mask);
894	886	break;
895	887
896	888	case 0x08:
897		COMBINE_DATA(&epic12_device_gfx_addr);
	889	COMBINE_DATA(&m_gfx_addr);
898	890	break;
899	891
900	892	case 0x14:
901		COMBINE_DATA(&epic12_device_gfx_scroll_0_x);
	893	COMBINE_DATA(&m_gfx_scroll_0_x);
902	894	break;
903	895
904	896	case 0x18:
905		COMBINE_DATA(&epic12_device_gfx_scroll_0_y);
	897	COMBINE_DATA(&m_gfx_scroll_0_y);
906	898	break;
907	899
908	900	case 0x40:
909		COMBINE_DATA(&epic12_device_gfx_scroll_1_x);
	901	COMBINE_DATA(&m_gfx_scroll_1_x);
910	902	break;
911	903
912	904	case 0x44:
913		COMBINE_DATA(&epic12_device_gfx_scroll_1_y);
	905	COMBINE_DATA(&m_gfx_scroll_1_y);
914	906	break;
915	907
916	908	}
r31474	r31475
926	918	if (m_is_unsafe)
927	919	{
928	920	printf("using unsafe blit code!\n");
929		read = read32_delegate(FUNC(epic12_device::epic12_device_blitter_r_unsafe), this);
930		write = write32_delegate(FUNC(epic12_device::epic12_device_blitter_w_unsafe), this);
	921	read = read32_delegate(FUNC(epic12_device::blitter_r_unsafe), this);
	922	write = write32_delegate(FUNC(epic12_device::blitter_w_unsafe), this);
931	923	}
932	924	else
933	925	{
934		read = read32_delegate(FUNC(epic12_device::epic12_device_blitter_r), this);
935		write = write32_delegate(FUNC(epic12_device::epic12_device_blitter_w), this);
	926	read = read32_delegate(FUNC(epic12_device::blitter_r), this);
	927	write = write32_delegate(FUNC(epic12_device::blitter_w), this);
936	928	}
937	929
938	930	space.install_readwrite_handler(addr1, addr2, read , write, U64(0xffffffffffffffff));
939	931	}
940	932
941		READ64_MEMBER( epic12_device::epic12_device_fpga_r )
	933	READ64_MEMBER( epic12_device::fpga_r )
942	934	{
943	935	return 0xff;
944	936	}
945	937
946	938	// todo, store what's written here and checksum it, different microcode probably leads to slightly different blitter timings
947		WRITE64_MEMBER( epic12_device::epic12_device_fpga_w )
	939	WRITE64_MEMBER( epic12_device::fpga_w )
948	940	{
949	941	if (ACCESSING_BITS_24_31)
950	942	{

trunk/src/emu/video/epic12.h

r31474	r31475
51	51	public:
52	52	epic12_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
53	53
54		void set_rambase(UINT16* rambase) { epic12_device_ram16 = rambase; }
	54	void set_rambase(UINT16* rambase) { m_ram16 = rambase; }
	55	void set_delay_scale(int delay_scale) { m_delay_scale = delay_scale; }
	56	void set_is_unsafe(int is_unsafe) { m_is_unsafe = is_unsafe; }
	57	void set_cpu_device(cpu_device* maincpu) { m_maincpu = maincpu; }
55	58
56	59	inline UINT16 READ_NEXT_WORD(offs_t *addr);
57	60
r31474	r31475
62	65	dev.m_main_rammask = ramsize-1;
63	66	}
64	67
65
66	68	static void *blit_request_callback(void *param, int threadid);
67	69
68		DECLARE_READ64_MEMBER( epic12_device_fpga_r );
69		DECLARE_WRITE64_MEMBER( epic12_device_fpga_w );
	70	DECLARE_READ64_MEMBER( fpga_r );
	71	DECLARE_WRITE64_MEMBER( fpga_w );
70	72
71	73	void draw_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect);
72	74
73		UINT16* epic12_device_ram16;
74		UINT32 epic12_device_gfx_addr;
75		UINT32 epic12_device_gfx_scroll_0_x, epic12_device_gfx_scroll_0_y;
76		UINT32 epic12_device_gfx_scroll_1_x, epic12_device_gfx_scroll_1_y;
	75	UINT16* m_ram16;
	76	UINT32 m_gfx_addr;
	77	UINT32 m_gfx_scroll_0_x, m_gfx_scroll_0_y;
	78	UINT32 m_gfx_scroll_1_x, m_gfx_scroll_1_y;
77	79
	80	int m_gfx_size;
	81	bitmap_rgb32 *m_bitmaps;
	82	rectangle m_clip;
78	83
79		int epic12_device_gfx_size;
80		bitmap_rgb32 *epic12_device_bitmaps;
81		rectangle epic12_device_clip;
82
83
84		UINT16* use_ram;
	84	UINT16* m_use_ram;
85	85	int m_main_ramsize; // type D has double the main ram
86	86	int m_main_rammask;
87	87
88		// thread safe mode, with no delays & shadow ram copy
89		DECLARE_READ32_MEMBER(epic12_device_blitter_r);
90		DECLARE_WRITE32_MEMBER(epic12_device_blitter_w);
91		UINT32 epic12_device_gfx_addr_shadowcopy;
92		UINT32 epic12_device_gfx_scroll_0_x_shadowcopy, epic12_device_gfx_scroll_0_y_shadowcopy;
93		UINT32 epic12_device_gfx_scroll_1_x_shadowcopy, epic12_device_gfx_scroll_1_y_shadowcopy;
94		UINT16* epic12_device_ram16_copy;
95		inline void epic12_device_gfx_upload_shadow_copy(address_space &space, offs_t *addr);
96		inline void epic12_device_gfx_create_shadow_copy(address_space &space);
97		inline UINT16 COPY_NEXT_WORD(address_space &space, offs_t *addr);
98		inline void epic12_device_gfx_draw_shadow_copy(address_space &space, offs_t *addr);
99		inline void epic12_device_gfx_upload(offs_t *addr);
100		inline void epic12_device_gfx_draw(offs_t *addr);
101		void epic12_device_gfx_exec(void);
102		DECLARE_READ32_MEMBER( epic12_device_gfx_ready_r );
103		DECLARE_WRITE32_MEMBER( epic12_device_gfx_exec_w );
104
105
106		// for thread unsafe mode with blitter delays, no shadow copy of RAM
107		DECLARE_READ32_MEMBER(epic12_device_blitter_r_unsafe);
108		DECLARE_WRITE32_MEMBER(epic12_device_blitter_w_unsafe);
109		READ32_MEMBER( epic12_device_gfx_ready_r_unsafe );
110		WRITE32_MEMBER( epic12_device_gfx_exec_w_unsafe );
111		void epic12_device_gfx_exec_unsafe(void);
112		static void *blit_request_callback_unsafe(void *param, int threadid);
113
114	88	int m_is_unsafe;
115	89	int m_delay_scale;
116	90	cpu_device* m_maincpu;
117	91
118		void set_delay_scale(int delay_scale) { m_delay_scale = delay_scale; }
119		void set_is_unsafe(int is_unsafe) { m_is_unsafe = is_unsafe; }
120		void set_cpu_device(cpu_device* maincpu) { m_maincpu = maincpu; }
121
122	92	void install_handlers(int addr1, int addr2);
123	93
	94	// thread safe mode, with no delays & shadow ram copy
	95	DECLARE_READ32_MEMBER(blitter_r);
	96	DECLARE_WRITE32_MEMBER(blitter_w);
	97	UINT32 m_gfx_addr_shadowcopy;
	98	UINT32 m_gfx_scroll_0_x_shadowcopy, m_gfx_scroll_0_y_shadowcopy;
	99	UINT32 m_gfx_scroll_1_x_shadowcopy, m_gfx_scroll_1_y_shadowcopy;
	100	UINT16* m_ram16_copy;
	101	inline void gfx_upload_shadow_copy(address_space &space, offs_t *addr);
	102	inline void gfx_create_shadow_copy(address_space &space);
	103	inline UINT16 COPY_NEXT_WORD(address_space &space, offs_t *addr);
	104	inline void gfx_draw_shadow_copy(address_space &space, offs_t *addr);
	105	inline void gfx_upload(offs_t *addr);
	106	inline void gfx_draw(offs_t *addr);
	107	void gfx_exec(void);
	108	DECLARE_READ32_MEMBER( gfx_ready_r );
	109	DECLARE_WRITE32_MEMBER( gfx_exec_w );
	110
	111	// for thread unsafe mode with blitter delays, no shadow copy of RAM
	112	DECLARE_READ32_MEMBER(blitter_r_unsafe);
	113	DECLARE_WRITE32_MEMBER(blitter_w_unsafe);
	114	READ32_MEMBER( gfx_ready_r_unsafe );
	115	WRITE32_MEMBER( gfx_exec_w_unsafe );
	116	void gfx_exec_unsafe(void);
	117	static void *blit_request_callback_unsafe(void *param, int threadid);
	118
124	119	#define BLIT_FUNCTION static const void
125	120	#define BLIT_PARAMS bitmap_rgb32 *bitmap, const rectangle *clip, UINT32 *gfx, int src_x, int src_y, const int dst_x_start, const int dst_y_start, int dimx, int dimy, const int flipy, const UINT8 s_alpha, const UINT8 d_alpha, const clr_t *tint_clr
126	121
r31474	r31475
832	827	virtual void device_start();
833	828	virtual void device_reset();
834	829
835		osd_work_queue *    queue;                  /* work queue */
836		osd_work_item * blitter_request;
	830	osd_work_queue *m_work_queue;
	831	osd_work_item *m_blitter_request;
837	832
838	833	// blit timing
839		emu_timer *epic12_device_blitter_delay_timer;
840		int blitter_busy;
	834	emu_timer *m_blitter_delay_timer;
	835	int m_blitter_busy;
841	836
842		TIMER_CALLBACK_MEMBER( epic12_device_blitter_delay_callback );
	837	TIMER_CALLBACK_MEMBER( blitter_delay_callback );
843	838	};
844	839
845	840

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team