Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-15 10:28:16 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix prev commit again + removed unneeded class member names prefixes

Browse Source
This commit is contained in:
Michaël Banaan Ananas 2014-07-30 20:35:53 +00:00
parent 78e76eea17
commit 71caae4932
4 changed files with 163 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

242
src/emu/video/epic12.c
View File

@ -13,61 +13,54 @@ epic12_device::epic12_device(const machine_config &mconfig, const char *tag, dev
{ {
m_is_unsafe = 0; m_is_unsafe = 0;
m_delay_scale = 0; m_delay_scale = 0;
m_maincpu = 0; m_blitter_request = 0;
queue = 0; m_blitter_delay_timer = 0;
blitter_request = 0; m_blitter_busy = 0;
epic12_device_blitter_delay_timer = 0; m_gfx_addr = 0;
blitter_busy = 0; m_gfx_scroll_0_x = 0;
use_ram = 0; m_gfx_scroll_0_y = 0;
epic12_device_ram16 = 0; m_gfx_scroll_1_x = 0;
epic12_device_gfx_addr = 0; m_gfx_scroll_1_y = 0;
epic12_device_gfx_scroll_0_x = 0; m_gfx_addr_shadowcopy = 0;
epic12_device_gfx_scroll_0_y = 0; m_gfx_scroll_0_x_shadowcopy = 0;
epic12_device_gfx_scroll_1_x = 0; m_gfx_scroll_0_y_shadowcopy = 0;
epic12_device_gfx_scroll_1_y = 0; m_gfx_scroll_1_x_shadowcopy = 0;
epic12_device_gfx_size = 0; m_gfx_scroll_1_y_shadowcopy = 0;
epic12_device_gfx_addr_shadowcopy = 0;
epic12_device_gfx_scroll_0_x_shadowcopy = 0;
epic12_device_gfx_scroll_0_y_shadowcopy = 0;
epic12_device_gfx_scroll_1_x_shadowcopy = 0;
epic12_device_gfx_scroll_1_y_shadowcopy = 0;
epic12_device_ram16_copy = 0;
epic12_device_blit_delay = 0; epic12_device_blit_delay = 0;
} }
TIMER_CALLBACK_MEMBER( epic12_device::epic12_device_blitter_delay_callback ) TIMER_CALLBACK_MEMBER( epic12_device::blitter_delay_callback )
{ {
blitter_busy = 0; m_blitter_busy = 0;
} }
void epic12_device::device_start() void epic12_device::device_start()
{ {
epic12_device_gfx_size = 0x2000 * 0x1000; m_gfx_size = 0x2000 * 0x1000;
epic12_device_bitmaps = auto_bitmap_rgb32_alloc(machine(), 0x2000, 0x1000); m_bitmaps = auto_bitmap_rgb32_alloc(machine(), 0x2000, 0x1000);
epic12_device_clip = epic12_device_bitmaps->cliprect(); m_clip = m_bitmaps->cliprect();
epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1); m_clip.set(0, 0x2000-1, 0, 0x1000-1);
epic12_device_ram16_copy = auto_alloc_array(machine(), UINT16, m_main_ramsize/2); m_ram16_copy = auto_alloc_array(machine(), UINT16, m_main_ramsize/2);
epic12_device_blitter_delay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(epic12_device::epic12_device_blitter_delay_callback),this)); m_blitter_delay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(epic12_device::blitter_delay_callback),this));
epic12_device_blitter_delay_timer->adjust(attotime::never); m_blitter_delay_timer->adjust(attotime::never);
} }
void epic12_device::device_reset() void epic12_device::device_reset()
{ {
if (m_is_unsafe) if (m_is_unsafe)
{ {
use_ram = epic12_device_ram16; m_use_ram = m_ram16;
queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ|WORK_QUEUE_FLAG_MULTI); m_work_queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ|WORK_QUEUE_FLAG_MULTI);
} }
else else
{ {
use_ram = epic12_device_ram16_copy; // slow mode m_use_ram = m_ram16_copy; // slow mode
queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ); m_work_queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ);
} }
// cache table to avoid divides in blit code, also pre-clamped // cache table to avoid divides in blit code, also pre-clamped
int x,y; int x,y;
for (y=0;y<0x40;y++) for (y=0;y<0x40;y++)
@ -92,8 +85,7 @@ void epic12_device::device_reset()
} }
} }
blitter_busy = 0; m_blitter_busy = 0;
} }
// todo, get these into the device class without ruining performance // todo, get these into the device class without ruining performance
@ -105,7 +97,7 @@ UINT64 epic12_device_blit_delay;
inline UINT16 epic12_device::READ_NEXT_WORD(offs_t *addr) inline UINT16 epic12_device::READ_NEXT_WORD(offs_t *addr)
{ {
// UINT16 data = space.read_word(*addr); // going through the memory system is 'more correct' but noticably slower // UINT16 data = space.read_word(*addr); // going through the memory system is 'more correct' but noticably slower
UINT16 data = use_ram[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)]; UINT16 data = m_use_ram[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)];
*addr += 2; *addr += 2;
@ -116,8 +108,8 @@ inline UINT16 epic12_device::READ_NEXT_WORD(offs_t *addr)
inline UINT16 epic12_device::COPY_NEXT_WORD(address_space &space, offs_t *addr) inline UINT16 epic12_device::COPY_NEXT_WORD(address_space &space, offs_t *addr)
{ {
// UINT16 data = space.read_word(*addr); // going through the memory system is 'more correct' but noticably slower // UINT16 data = space.read_word(*addr); // going through the memory system is 'more correct' but noticably slower
UINT16 data = epic12_device_ram16[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)]; UINT16 data = m_ram16[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)];
epic12_device_ram16_copy[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)] = data; m_ram16_copy[((*addr & m_main_rammask) >> 1) ^ NATIVE_ENDIAN_VALUE_LE_BE(3, 0)] = data;
*addr += 2; *addr += 2;
@ -126,7 +118,7 @@ inline UINT16 epic12_device::COPY_NEXT_WORD(address_space &space, offs_t *addr)
} }
inline void epic12_device::epic12_device_gfx_upload_shadow_copy(address_space &space, offs_t *addr) inline void epic12_device::gfx_upload_shadow_copy(address_space &space, offs_t *addr)
{ {
UINT32 x,y, dimx,dimy; UINT32 x,y, dimx,dimy;
COPY_NEXT_WORD(space, addr); COPY_NEXT_WORD(space, addr);
@ -148,7 +140,7 @@ inline void epic12_device::epic12_device_gfx_upload_shadow_copy(address_space &s
} }
} }
inline void epic12_device::epic12_device_gfx_upload(offs_t *addr) inline void epic12_device::gfx_upload(offs_t *addr)
{ {
UINT32 x,y, dst_p,dst_x_start,dst_y_start, dimx,dimy; UINT32 x,y, dst_p,dst_x_start,dst_y_start, dimx,dimy;
UINT32 *dst; UINT32 *dst;
@ -175,7 +167,7 @@ inline void epic12_device::epic12_device_gfx_upload(offs_t *addr)
for (y = 0; y < dimy; y++) for (y = 0; y < dimy; y++)
{ {
dst = &epic12_device_bitmaps->pix(dst_y_start + y, 0); dst = &m_bitmaps->pix(dst_y_start + y, 0);
dst += dst_x_start; dst += dst_x_start;
for (x = 0; x < dimx; x++) for (x = 0; x < dimx; x++)
@ -191,7 +183,7 @@ inline void epic12_device::epic12_device_gfx_upload(offs_t *addr)
} }
} }
#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 #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
@ -295,7 +287,7 @@ epic12_device_blitfunction epic12_device_f1_ti0_tr0_blit_funcs[] =
inline void epic12_device::epic12_device_gfx_draw_shadow_copy(address_space &space, offs_t *addr) inline void epic12_device::gfx_draw_shadow_copy(address_space &space, offs_t *addr)
{ {
COPY_NEXT_WORD(space, addr); COPY_NEXT_WORD(space, addr);
COPY_NEXT_WORD(space, addr); COPY_NEXT_WORD(space, addr);
@ -317,7 +309,7 @@ inline void epic12_device::epic12_device_gfx_draw_shadow_copy(address_space &spa
inline void epic12_device::epic12_device_gfx_draw(offs_t *addr) inline void epic12_device::gfx_draw(offs_t *addr)
{ {
int x,y, dimx,dimy, flipx,flipy;//, src_p; int x,y, dimx,dimy, flipx,flipy;//, src_p;
int trans,blend, s_mode, d_mode; int trans,blend, s_mode, d_mode;
@ -533,10 +525,10 @@ inline void epic12_device::epic12_device_gfx_draw(offs_t *addr)
} }
void epic12_device::epic12_device_gfx_create_shadow_copy(address_space &space) void epic12_device::gfx_create_shadow_copy(address_space &space)
{ {
offs_t addr = epic12_device_gfx_addr & 0x1fffffff; offs_t addr = m_gfx_addr & 0x1fffffff;
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); 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);
while (1) while (1)
{ {
@ -550,19 +542,19 @@ void epic12_device::epic12_device_gfx_create_shadow_copy(address_space &space)
case 0xc000: case 0xc000:
if (COPY_NEXT_WORD(space, &addr)) // cliptype if (COPY_NEXT_WORD(space, &addr)) // cliptype
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); 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);
else else
epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1); m_clip.set(0, 0x2000-1, 0, 0x1000-1);
break; break;
case 0x2000: case 0x2000:
addr -= 2; addr -= 2;
epic12_device_gfx_upload_shadow_copy(space, &addr); gfx_upload_shadow_copy(space, &addr);
break; break;
case 0x1000: case 0x1000:
addr -= 2; addr -= 2;
epic12_device_gfx_draw_shadow_copy(space, &addr); gfx_draw_shadow_copy(space, &addr);
break; break;
default: default:
@ -573,10 +565,10 @@ void epic12_device::epic12_device_gfx_create_shadow_copy(address_space &space)
} }
void epic12_device::epic12_device_gfx_exec(void) void epic12_device::gfx_exec(void)
{ {
offs_t addr = epic12_device_gfx_addr_shadowcopy & 0x1fffffff; offs_t addr = m_gfx_addr_shadowcopy & 0x1fffffff;
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); 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);
// logerror("GFX EXEC: %08X\n", addr); // logerror("GFX EXEC: %08X\n", addr);
@ -592,19 +584,19 @@ void epic12_device::epic12_device_gfx_exec(void)
case 0xc000: case 0xc000:
if (READ_NEXT_WORD(&addr)) // cliptype if (READ_NEXT_WORD(&addr)) // cliptype
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); 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);
else else
epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1); m_clip.set(0, 0x2000-1, 0, 0x1000-1);
break; break;
case 0x2000: case 0x2000:
addr -= 2; addr -= 2;
epic12_device_gfx_upload(&addr); gfx_upload(&addr);
break; break;
case 0x1000: case 0x1000:
addr -= 2; addr -= 2;
epic12_device_gfx_draw(&addr); gfx_draw(&addr);
break; break;
default: default:
@ -615,10 +607,10 @@ void epic12_device::epic12_device_gfx_exec(void)
} }
void epic12_device::epic12_device_gfx_exec_unsafe(void) void epic12_device::gfx_exec_unsafe(void)
{ {
offs_t addr = epic12_device_gfx_addr & 0x1fffffff; offs_t addr = m_gfx_addr & 0x1fffffff;
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); 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);
// logerror("GFX EXEC: %08X\n", addr); // logerror("GFX EXEC: %08X\n", addr);
@ -634,19 +626,19 @@ void epic12_device::epic12_device_gfx_exec_unsafe(void)
case 0xc000: case 0xc000:
if (READ_NEXT_WORD(&addr)) // cliptype if (READ_NEXT_WORD(&addr)) // cliptype
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); 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);
else else
epic12_device_clip.set(0, 0x2000-1, 0, 0x1000-1); m_clip.set(0, 0x2000-1, 0, 0x1000-1);
break; break;
case 0x2000: case 0x2000:
addr -= 2; addr -= 2;
epic12_device_gfx_upload(&addr); gfx_upload(&addr);
break; break;
case 0x1000: case 0x1000:
addr -= 2; addr -= 2;
epic12_device_gfx_draw(&addr); gfx_draw(&addr);
break; break;
default: default:
@ -662,7 +654,7 @@ void *epic12_device::blit_request_callback(void *param, int threadid)
{ {
epic12_device *object = reinterpret_cast<epic12_device *>(param); epic12_device *object = reinterpret_cast<epic12_device *>(param);
object->epic12_device_gfx_exec(); object->gfx_exec();
return NULL; return NULL;
} }
@ -673,19 +665,19 @@ void *epic12_device::blit_request_callback_unsafe(void *param, int threadid)
epic12_device *object = reinterpret_cast<epic12_device *>(param); epic12_device *object = reinterpret_cast<epic12_device *>(param);
epic12_device_blit_delay = 0; epic12_device_blit_delay = 0;
object->epic12_device_gfx_exec_unsafe(); object->gfx_exec_unsafe();
return NULL; return NULL;
} }
READ32_MEMBER( epic12_device::epic12_device_gfx_ready_r ) READ32_MEMBER( epic12_device::gfx_ready_r )
{ {
return 0x00000010; return 0x00000010;
} }
READ32_MEMBER( epic12_device::epic12_device_gfx_ready_r_unsafe ) READ32_MEMBER( epic12_device::gfx_ready_r_unsafe )
{ {
if (blitter_busy) if (m_blitter_busy)
{ {
m_maincpu->spin_until_time(attotime::from_usec(10)); m_maincpu->spin_until_time(attotime::from_usec(10));
return 0x00000000; return 0x00000000;
@ -694,7 +686,7 @@ READ32_MEMBER( epic12_device::epic12_device_gfx_ready_r_unsafe )
return 0x00000010; return 0x00000010;
} }
WRITE32_MEMBER( epic12_device::epic12_device_gfx_exec_w ) WRITE32_MEMBER( epic12_device::gfx_exec_w )
{ {
if ( ACCESSING_BITS_0_7 ) if ( ACCESSING_BITS_0_7 )
{ {
@ -702,38 +694,38 @@ WRITE32_MEMBER( epic12_device::epic12_device_gfx_exec_w )
{ {
//g_profiler.start(PROFILER_USER1); //g_profiler.start(PROFILER_USER1);
// make sure we've not already got a request running // make sure we've not already got a request running
if (blitter_request) if (m_blitter_request)
{ {
int result; int result;
do do
{ {
result = osd_work_item_wait(blitter_request, 1000); result = osd_work_item_wait(m_blitter_request, 1000);
} while (result==0); } while (result==0);
osd_work_item_release(blitter_request); osd_work_item_release(m_blitter_request);
} }
epic12_device_blit_delay = 0; epic12_device_blit_delay = 0;
epic12_device_gfx_create_shadow_copy(space); // create a copy of the blit list so we can safely thread it. gfx_create_shadow_copy(space); // create a copy of the blit list so we can safely thread it.
if (epic12_device_blit_delay) if (epic12_device_blit_delay)
{ {
blitter_busy = 1; m_blitter_busy = 1;
epic12_device_blitter_delay_timer->adjust(attotime::from_nsec(epic12_device_blit_delay*8)); // NOT accurate timing (currently ignored anyway) m_blitter_delay_timer->adjust(attotime::from_nsec(epic12_device_blit_delay*8)); // NOT accurate timing (currently ignored anyway)
} }
epic12_device_gfx_addr_shadowcopy = epic12_device_gfx_addr; m_gfx_addr_shadowcopy = m_gfx_addr;
epic12_device_gfx_scroll_0_x_shadowcopy = epic12_device_gfx_scroll_0_x; m_gfx_scroll_0_x_shadowcopy = m_gfx_scroll_0_x;
epic12_device_gfx_scroll_0_y_shadowcopy = epic12_device_gfx_scroll_0_y; m_gfx_scroll_0_y_shadowcopy = m_gfx_scroll_0_y;
epic12_device_gfx_scroll_1_x_shadowcopy = epic12_device_gfx_scroll_1_x; m_gfx_scroll_1_x_shadowcopy = m_gfx_scroll_1_x;
epic12_device_gfx_scroll_1_y_shadowcopy = epic12_device_gfx_scroll_1_y; m_gfx_scroll_1_y_shadowcopy = m_gfx_scroll_1_y;
blitter_request = osd_work_item_queue(queue, blit_request_callback, (void*)this, 0); m_blitter_request = osd_work_item_queue(m_work_queue, blit_request_callback, (void*)this, 0);
//g_profiler.stop(); //g_profiler.stop();
} }
} }
} }
WRITE32_MEMBER( epic12_device::epic12_device_gfx_exec_w_unsafe ) WRITE32_MEMBER( epic12_device::gfx_exec_w_unsafe )
{ {
if ( ACCESSING_BITS_0_7 ) if ( ACCESSING_BITS_0_7 )
{ {
@ -741,29 +733,29 @@ WRITE32_MEMBER( epic12_device::epic12_device_gfx_exec_w_unsafe )
{ {
//g_profiler.start(PROFILER_USER1); //g_profiler.start(PROFILER_USER1);
// make sure we've not already got a request running // make sure we've not already got a request running
if (blitter_request) if (m_blitter_request)
{ {
int result; int result;
do do
{ {
result = osd_work_item_wait(blitter_request, 1000); result = osd_work_item_wait(m_blitter_request, 1000);
} while (result==0); } while (result==0);
osd_work_item_release(blitter_request); osd_work_item_release(m_blitter_request);
} }
if (epic12_device_blit_delay) if (epic12_device_blit_delay)
{ {
blitter_busy = 1; m_blitter_busy = 1;
int delay = epic12_device_blit_delay*(15 * m_delay_scale / 50); int delay = epic12_device_blit_delay*(15 * m_delay_scale / 50);
//printf("delay %d\n", delay); //printf("delay %d\n", delay);
epic12_device_blitter_delay_timer->adjust(attotime::from_nsec(delay)); m_blitter_delay_timer->adjust(attotime::from_nsec(delay));
} }
else else
{ {
blitter_busy = 0; m_blitter_busy = 0;
} }
blitter_request = osd_work_item_queue(queue, blit_request_callback_unsafe, (void*)this, 0); m_blitter_request = osd_work_item_queue(m_work_queue, blit_request_callback_unsafe, (void*)this, 0);
//g_profiler.stop(); //g_profiler.stop();
} }
} }
@ -774,14 +766,14 @@ void epic12_device::draw_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect
{ {
if (!m_is_unsafe) if (!m_is_unsafe)
{ {
if (blitter_request) if (m_blitter_request)
{ {
int result; int result;
do do
{ {
result = osd_work_item_wait(blitter_request, 1000); result = osd_work_item_wait(m_blitter_request, 1000);
} while (result==0); } while (result==0);
osd_work_item_release(blitter_request); osd_work_item_release(m_blitter_request);
} }
} }
@ -790,14 +782,14 @@ void epic12_device::draw_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect
bitmap.fill(0, cliprect); bitmap.fill(0, cliprect);
scroll_0_x = -epic12_device_gfx_scroll_0_x; scroll_0_x = -m_gfx_scroll_0_x;
scroll_0_y = -epic12_device_gfx_scroll_0_y; scroll_0_y = -m_gfx_scroll_0_y;
// scroll_1_x = -epic12_device_gfx_scroll_1_x; // scroll_1_x = -m_gfx_scroll_1_x;
// scroll_1_y = -epic12_device_gfx_scroll_1_y; // scroll_1_y = -m_gfx_scroll_1_y;
//printf("SCREEN UPDATE\n %d %d %d %d\n", scroll_0_x, scroll_0_y, scroll_1_x, scroll_1_y); //printf("SCREEN UPDATE\n %d %d %d %d\n", scroll_0_x, scroll_0_y, scroll_1_x, scroll_1_y);
copyscrollbitmap(bitmap, *epic12_device_bitmaps, 1,&scroll_0_x, 1,&scroll_0_y, cliprect); copyscrollbitmap(bitmap, *m_bitmaps, 1,&scroll_0_x, 1,&scroll_0_y, cliprect);
} }
@ -805,12 +797,12 @@ void epic12_device::draw_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect
READ32_MEMBER( epic12_device::epic12_device_blitter_r ) READ32_MEMBER( epic12_device::blitter_r )
{ {
switch (offset*4) switch (offset*4)
{ {
case 0x10: case 0x10:
return epic12_device::epic12_device_gfx_ready_r(space,offset,mem_mask); return gfx_ready_r(space, offset, mem_mask);
case 0x24: case 0x24:
return 0xffffffff; return 0xffffffff;
@ -822,19 +814,19 @@ READ32_MEMBER( epic12_device::epic12_device_blitter_r )
return space.machine().root_device().ioport(":DSW")->read(); return space.machine().root_device().ioport(":DSW")->read();
default: default:
logerror("unknownepic12_device_blitter_r %08x %08x\n", offset*4, mem_mask); logerror("unknownblitter_r %08x %08x\n", offset*4, mem_mask);
break; break;
} }
return 0; return 0;
} }
READ32_MEMBER( epic12_device::epic12_device_blitter_r_unsafe ) READ32_MEMBER( epic12_device::blitter_r_unsafe )
{ {
switch (offset*4) switch (offset*4)
{ {
case 0x10: case 0x10:
return epic12_device::epic12_device_gfx_ready_r_unsafe(space,offset,mem_mask); return gfx_ready_r_unsafe(space, offset, mem_mask);
case 0x24: case 0x24:
return 0xffffffff; return 0xffffffff;
@ -846,7 +838,7 @@ READ32_MEMBER( epic12_device::epic12_device_blitter_r_unsafe )
return space.machine().root_device().ioport(":DSW")->read(); return space.machine().root_device().ioport(":DSW")->read();
default: default:
logerror("unknownepic12_device_blitter_r %08x %08x\n", offset*4, mem_mask); logerror("unknownblitter_r %08x %08x\n", offset*4, mem_mask);
break; break;
} }
@ -854,63 +846,63 @@ READ32_MEMBER( epic12_device::epic12_device_blitter_r_unsafe )
} }
WRITE32_MEMBER( epic12_device::epic12_device_blitter_w ) WRITE32_MEMBER( epic12_device::blitter_w )
{ {
switch (offset*4) switch (offset*4)
{ {
case 0x04: case 0x04:
epic12_device_gfx_exec_w(space,offset,data,mem_mask); gfx_exec_w(space,offset,data,mem_mask);
break; break;
case 0x08: case 0x08:
COMBINE_DATA(&epic12_device_gfx_addr); COMBINE_DATA(&m_gfx_addr);
break; break;
case 0x14: case 0x14:
COMBINE_DATA(&epic12_device_gfx_scroll_0_x); COMBINE_DATA(&m_gfx_scroll_0_x);
break; break;
case 0x18: case 0x18:
COMBINE_DATA(&epic12_device_gfx_scroll_0_y); COMBINE_DATA(&m_gfx_scroll_0_y);
break; break;
case 0x40: case 0x40:
COMBINE_DATA(&epic12_device_gfx_scroll_1_x); COMBINE_DATA(&m_gfx_scroll_1_x);
break; break;
case 0x44: case 0x44:
COMBINE_DATA(&epic12_device_gfx_scroll_1_y); COMBINE_DATA(&m_gfx_scroll_1_y);
break; break;
} }
} }
WRITE32_MEMBER( epic12_device::epic12_device_blitter_w_unsafe ) WRITE32_MEMBER( epic12_device::blitter_w_unsafe )
{ {
switch (offset*4) switch (offset*4)
{ {
case 0x04: case 0x04:
epic12_device_gfx_exec_w_unsafe(space,offset,data,mem_mask); gfx_exec_w_unsafe(space,offset,data,mem_mask);
break; break;
case 0x08: case 0x08:
COMBINE_DATA(&epic12_device_gfx_addr); COMBINE_DATA(&m_gfx_addr);
break; break;
case 0x14: case 0x14:
COMBINE_DATA(&epic12_device_gfx_scroll_0_x); COMBINE_DATA(&m_gfx_scroll_0_x);
break; break;
case 0x18: case 0x18:
COMBINE_DATA(&epic12_device_gfx_scroll_0_y); COMBINE_DATA(&m_gfx_scroll_0_y);
break; break;
case 0x40: case 0x40:
COMBINE_DATA(&epic12_device_gfx_scroll_1_x); COMBINE_DATA(&m_gfx_scroll_1_x);
break; break;
case 0x44: case 0x44:
COMBINE_DATA(&epic12_device_gfx_scroll_1_y); COMBINE_DATA(&m_gfx_scroll_1_y);
break; break;
} }
@ -926,25 +918,25 @@ void epic12_device::install_handlers(int addr1, int addr2)
if (m_is_unsafe) if (m_is_unsafe)
{ {
printf("using unsafe blit code!\n"); printf("using unsafe blit code!\n");
read = read32_delegate(FUNC(epic12_device::epic12_device_blitter_r_unsafe), this); read = read32_delegate(FUNC(epic12_device::blitter_r_unsafe), this);
write = write32_delegate(FUNC(epic12_device::epic12_device_blitter_w_unsafe), this); write = write32_delegate(FUNC(epic12_device::blitter_w_unsafe), this);
} }
else else
{ {
read = read32_delegate(FUNC(epic12_device::epic12_device_blitter_r), this); read = read32_delegate(FUNC(epic12_device::blitter_r), this);
write = write32_delegate(FUNC(epic12_device::epic12_device_blitter_w), this); write = write32_delegate(FUNC(epic12_device::blitter_w), this);
} }
space.install_readwrite_handler(addr1, addr2, read , write, U64(0xffffffffffffffff)); space.install_readwrite_handler(addr1, addr2, read , write, U64(0xffffffffffffffff));
} }
READ64_MEMBER( epic12_device::epic12_device_fpga_r ) READ64_MEMBER( epic12_device::fpga_r )
{ {
return 0xff; return 0xff;
} }
// todo, store what's written here and checksum it, different microcode probably leads to slightly different blitter timings // todo, store what's written here and checksum it, different microcode probably leads to slightly different blitter timings
WRITE64_MEMBER( epic12_device::epic12_device_fpga_w ) WRITE64_MEMBER( epic12_device::fpga_w )
{ {
if (ACCESSING_BITS_24_31) if (ACCESSING_BITS_24_31)
{ {

93
src/emu/video/epic12.h
View File

@ -51,7 +51,10 @@ class epic12_device : public device_t,
public: public:
epic12_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); epic12_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
void set_rambase(UINT16* rambase) { epic12_device_ram16 = rambase; } void set_rambase(UINT16* rambase) { m_ram16 = rambase; }
void set_delay_scale(int delay_scale) { m_delay_scale = delay_scale; }
void set_is_unsafe(int is_unsafe) { m_is_unsafe = is_unsafe; }
void set_cpu_device(cpu_device* maincpu) { m_maincpu = maincpu; }
inline UINT16 READ_NEXT_WORD(offs_t *addr); inline UINT16 READ_NEXT_WORD(offs_t *addr);
@ -62,65 +65,57 @@ public:
dev.m_main_rammask = ramsize-1; dev.m_main_rammask = ramsize-1;
} }
static void *blit_request_callback(void *param, int threadid); static void *blit_request_callback(void *param, int threadid);
DECLARE_READ64_MEMBER( epic12_device_fpga_r ); DECLARE_READ64_MEMBER( fpga_r );
DECLARE_WRITE64_MEMBER( epic12_device_fpga_w ); DECLARE_WRITE64_MEMBER( fpga_w );
void draw_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect); void draw_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect);
UINT16* epic12_device_ram16; UINT16* m_ram16;
UINT32 epic12_device_gfx_addr; UINT32 m_gfx_addr;
UINT32 epic12_device_gfx_scroll_0_x, epic12_device_gfx_scroll_0_y; UINT32 m_gfx_scroll_0_x, m_gfx_scroll_0_y;
UINT32 epic12_device_gfx_scroll_1_x, epic12_device_gfx_scroll_1_y; UINT32 m_gfx_scroll_1_x, m_gfx_scroll_1_y;
int m_gfx_size;
bitmap_rgb32 *m_bitmaps;
rectangle m_clip;
int epic12_device_gfx_size; UINT16* m_use_ram;
bitmap_rgb32 *epic12_device_bitmaps;
rectangle epic12_device_clip;
UINT16* use_ram;
int m_main_ramsize; // type D has double the main ram int m_main_ramsize; // type D has double the main ram
int m_main_rammask; int m_main_rammask;
// thread safe mode, with no delays & shadow ram copy
DECLARE_READ32_MEMBER(epic12_device_blitter_r);
DECLARE_WRITE32_MEMBER(epic12_device_blitter_w);
UINT32 epic12_device_gfx_addr_shadowcopy;
UINT32 epic12_device_gfx_scroll_0_x_shadowcopy, epic12_device_gfx_scroll_0_y_shadowcopy;
UINT32 epic12_device_gfx_scroll_1_x_shadowcopy, epic12_device_gfx_scroll_1_y_shadowcopy;
UINT16* epic12_device_ram16_copy;
inline void epic12_device_gfx_upload_shadow_copy(address_space &space, offs_t *addr);
inline void epic12_device_gfx_create_shadow_copy(address_space &space);
inline UINT16 COPY_NEXT_WORD(address_space &space, offs_t *addr);
inline void epic12_device_gfx_draw_shadow_copy(address_space &space, offs_t *addr);
inline void epic12_device_gfx_upload(offs_t *addr);
inline void epic12_device_gfx_draw(offs_t *addr);
void epic12_device_gfx_exec(void);
DECLARE_READ32_MEMBER( epic12_device_gfx_ready_r );
DECLARE_WRITE32_MEMBER( epic12_device_gfx_exec_w );
// for thread unsafe mode with blitter delays, no shadow copy of RAM
DECLARE_READ32_MEMBER(epic12_device_blitter_r_unsafe);
DECLARE_WRITE32_MEMBER(epic12_device_blitter_w_unsafe);
READ32_MEMBER( epic12_device_gfx_ready_r_unsafe );
WRITE32_MEMBER( epic12_device_gfx_exec_w_unsafe );
void epic12_device_gfx_exec_unsafe(void);
static void *blit_request_callback_unsafe(void *param, int threadid);
int m_is_unsafe; int m_is_unsafe;
int m_delay_scale; int m_delay_scale;
cpu_device* m_maincpu; cpu_device* m_maincpu;
void set_delay_scale(int delay_scale) { m_delay_scale = delay_scale; }
void set_is_unsafe(int is_unsafe) { m_is_unsafe = is_unsafe; }
void set_cpu_device(cpu_device* maincpu) { m_maincpu = maincpu; }
void install_handlers(int addr1, int addr2); void install_handlers(int addr1, int addr2);
// thread safe mode, with no delays & shadow ram copy
DECLARE_READ32_MEMBER(blitter_r);
DECLARE_WRITE32_MEMBER(blitter_w);
UINT32 m_gfx_addr_shadowcopy;
UINT32 m_gfx_scroll_0_x_shadowcopy, m_gfx_scroll_0_y_shadowcopy;
UINT32 m_gfx_scroll_1_x_shadowcopy, m_gfx_scroll_1_y_shadowcopy;
UINT16* m_ram16_copy;
inline void gfx_upload_shadow_copy(address_space &space, offs_t *addr);
inline void gfx_create_shadow_copy(address_space &space);
inline UINT16 COPY_NEXT_WORD(address_space &space, offs_t *addr);
inline void gfx_draw_shadow_copy(address_space &space, offs_t *addr);
inline void gfx_upload(offs_t *addr);
inline void gfx_draw(offs_t *addr);
void gfx_exec(void);
DECLARE_READ32_MEMBER( gfx_ready_r );
DECLARE_WRITE32_MEMBER( gfx_exec_w );
// for thread unsafe mode with blitter delays, no shadow copy of RAM
DECLARE_READ32_MEMBER(blitter_r_unsafe);
DECLARE_WRITE32_MEMBER(blitter_w_unsafe);
READ32_MEMBER( gfx_ready_r_unsafe );
WRITE32_MEMBER( gfx_exec_w_unsafe );
void gfx_exec_unsafe(void);
static void *blit_request_callback_unsafe(void *param, int threadid);
#define BLIT_FUNCTION static const void #define BLIT_FUNCTION static const void
#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 #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
@ -832,14 +827,14 @@ protected:
virtual void device_start(); virtual void device_start();
virtual void device_reset(); virtual void device_reset();
osd_work_queue * queue; /* work queue */ osd_work_queue *m_work_queue;
osd_work_item * blitter_request; osd_work_item *m_blitter_request;
// blit timing // blit timing
emu_timer *epic12_device_blitter_delay_timer; emu_timer *m_blitter_delay_timer;
int blitter_busy; int m_blitter_busy;
TIMER_CALLBACK_MEMBER( epic12_device_blitter_delay_callback ); TIMER_CALLBACK_MEMBER( blitter_delay_callback );
}; };

3
src/emu/video/epic12in.inc
View File

@ -1,5 +1,4 @@
/* blitter function */
const void epic12_device::FUNCNAME(BLIT_PARAMS) const void epic12_device::FUNCNAME(BLIT_PARAMS)
{ {

2
src/mame/drivers/cv1k.c
View File

@ -349,7 +349,7 @@ static ADDRESS_MAP_START( cv1k_port, AS_IO, 64, cv1k_state )
AM_RANGE(SH3_PORT_E, SH3_PORT_E+7) AM_READ( cv1k_flash_port_e_r ) AM_RANGE(SH3_PORT_E, SH3_PORT_E+7) AM_READ( cv1k_flash_port_e_r )
AM_RANGE(SH3_PORT_F, SH3_PORT_F+7) AM_READ_PORT("PORT_F") AM_RANGE(SH3_PORT_F, SH3_PORT_F+7) AM_READ_PORT("PORT_F")
AM_RANGE(SH3_PORT_L, SH3_PORT_L+7) AM_READ_PORT("PORT_L") AM_RANGE(SH3_PORT_L, SH3_PORT_L+7) AM_READ_PORT("PORT_L")
AM_RANGE(SH3_PORT_J, SH3_PORT_J+7) AM_DEVREADWRITE( "blitter", epic12_device, epic12_device_fpga_r, epic12_device_fpga_w ) AM_RANGE(SH3_PORT_J, SH3_PORT_J+7) AM_DEVREADWRITE( "blitter", epic12_device, fpga_r, fpga_w )
ADDRESS_MAP_END ADDRESS_MAP_END