void system1_state::video_start_common(int pagecount)
{
int pagenum;
/* allocate memory for the collision arrays */
m_mix_collide = auto_alloc_array_clear(machine(), UINT8, 64);
m_sprite_collide = auto_alloc_array_clear(machine(), UINT8, 1024);
/* allocate memory for videoram */
m_tilemap_pages = pagecount;
m_videoram = auto_alloc_array_clear(machine(), UINT8, 0x800 * pagecount);
/* create the tilemap pages */
for (pagenum = 0; pagenum < pagecount; pagenum++)
{
m_tilemap_page[pagenum] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(system1_state::tile_get_info),this), TILEMAP_SCAN_ROWS, 8,8, 32,32);
m_tilemap_page[pagenum]->set_transparent_pen(0);
m_tilemap_page[pagenum]->set_user_data(m_videoram + 0x800 * pagenum);
}
/* allocate a temporary bitmap for sprite rendering */
m_sprite_bitmap = auto_bitmap_ind16_alloc(machine(), 512, 256);
/* register for save stats */
save_item(NAME(m_video_mode));
save_item(NAME(m_mix_collide_summary));
save_item(NAME(m_sprite_collide_summary));
save_pointer(NAME(m_videoram), 0x800 * pagecount);
save_pointer(NAME(m_mix_collide), 64);
save_pointer(NAME(m_sprite_collide), 1024);
}
void k037122_device::device_start()
{
static const gfx_layout k037122_char_layout =
{
8, 8,
K037122_NUM_TILES,
8,
{ 0,1,2,3,4,5,6,7 },
{ 1*16, 0*16, 3*16, 2*16, 5*16, 4*16, 7*16, 6*16 },
{ 0*128, 1*128, 2*128, 3*128, 4*128, 5*128, 6*128, 7*128 },
8*128
};
m_char_ram = auto_alloc_array_clear(machine(), UINT32, 0x200000 / 4);
m_tile_ram = auto_alloc_array_clear(machine(), UINT32, 0x20000 / 4);
m_reg = auto_alloc_array_clear(machine(), UINT32, 0x400 / 4);
m_layer[0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(k037122_device::tile_info_layer0),this), TILEMAP_SCAN_ROWS, 8, 8, 256, 64);
m_layer[1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(k037122_device::tile_info_layer1),this), TILEMAP_SCAN_ROWS, 8, 8, 128, 64);
m_layer[0]->set_transparent_pen(0);
m_layer[1]->set_transparent_pen(0);
machine().gfx[m_gfx_index] = auto_alloc_clear(machine(), gfx_element(machine(), k037122_char_layout, (UINT8*)m_char_ram, machine().total_colors() / 16, 0));
save_pointer(NAME(m_reg), 0x400 / 4);
save_pointer(NAME(m_char_ram), 0x200000 / 4);
save_pointer(NAME(m_tile_ram), 0x20000 / 4);
}
VIDEO_START_MEMBER(twincobr_state,toaplan0)
{
m_spritegen->alloc_sprite_bitmap(*m_screen);
/* the video RAM is accessed via ports, it's not memory mapped */
m_txvideoram_size = 0x0800;
m_bgvideoram_size = 0x2000; /* banked two times 0x1000 */
m_fgvideoram_size = 0x1000;
twincobr_create_tilemaps();
m_txvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_txvideoram_size);
m_fgvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_fgvideoram_size);
m_bgvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_bgvideoram_size);
m_display_on = 0;
save_pointer(NAME(m_txvideoram16), m_txvideoram_size);
save_pointer(NAME(m_fgvideoram16), m_fgvideoram_size);
save_pointer(NAME(m_bgvideoram16), m_bgvideoram_size);
save_item(NAME(m_txoffs));
save_item(NAME(m_fgoffs));
save_item(NAME(m_bgoffs));
save_item(NAME(m_txscrollx));
save_item(NAME(m_fgscrollx));
save_item(NAME(m_bgscrollx));
save_item(NAME(m_txscrolly));
save_item(NAME(m_fgscrolly));
save_item(NAME(m_bgscrolly));
save_item(NAME(m_display_on));
save_item(NAME(m_fg_rom_bank));
save_item(NAME(m_bg_ram_bank));
}
void ninjakd2_state::video_init_common(UINT32 vram_alloc_size)
{
// create video ram
if (vram_alloc_size)
{
m_robokid_bg0_videoram = auto_alloc_array_clear(machine(), UINT8, vram_alloc_size);
m_robokid_bg1_videoram = auto_alloc_array_clear(machine(), UINT8, vram_alloc_size);
m_robokid_bg2_videoram = auto_alloc_array_clear(machine(), UINT8, vram_alloc_size);
save_pointer(NAME(m_robokid_bg0_videoram), vram_alloc_size);
save_pointer(NAME(m_robokid_bg1_videoram), vram_alloc_size);
save_pointer(NAME(m_robokid_bg2_videoram), vram_alloc_size);
}
m_fg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(ninjakd2_state::get_fg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
m_fg_tilemap->set_transparent_pen(0xf);
m_screen->register_screen_bitmap(m_sprites_bitmap);
m_sprites_updated = 0;
m_robokid_sprites = 0;
m_vram_bank_mask = 0;
// register for save states
save_item(NAME(m_sprites_updated));
save_item(NAME(m_next_sprite_overdraw_enabled));
save_item(NAME(m_robokid_bg0_bank));
save_item(NAME(m_robokid_bg1_bank));
save_item(NAME(m_robokid_bg2_bank));
}
static void video_start_common(running_machine &machine, int pagecount)
{
system1_state *state = machine.driver_data<system1_state>();
int pagenum;
/* allocate memory for the collision arrays */
state->m_mix_collide = auto_alloc_array_clear(machine, UINT8, 64);
state->m_sprite_collide = auto_alloc_array_clear(machine, UINT8, 1024);
/* allocate memory for videoram */
state->m_tilemap_pages = pagecount;
state->m_videoram = auto_alloc_array_clear(machine, UINT8, 0x800 * pagecount);
/* create the tilemap pages */
for (pagenum = 0; pagenum < pagecount; pagenum++)
{
state->m_tilemap_page[pagenum] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(system1_state::tile_get_info),state), TILEMAP_SCAN_ROWS, 8,8, 32,32);
state->m_tilemap_page[pagenum]->set_transparent_pen(0);
state->m_tilemap_page[pagenum]->set_user_data(state->m_videoram + 0x800 * pagenum);
}
/* allocate a temporary bitmap for sprite rendering */
state->m_sprite_bitmap = auto_bitmap_ind16_alloc(machine, 512, 256);
/* register for save stats */
state_save_register_global(machine, state->m_video_mode);
state_save_register_global(machine, state->m_mix_collide_summary);
state_save_register_global(machine, state->m_sprite_collide_summary);
state->save_pointer(NAME(state->m_videoram), 0x800 * pagecount);
state_save_register_global_pointer(machine, state->m_mix_collide, 64);
state_save_register_global_pointer(machine, state->m_sprite_collide, 1024);
}
VIDEO_START_MEMBER(leland_state,ataxx)
{
/* first do the standard stuff */
m_video_ram = auto_alloc_array_clear(machine(), UINT8, VRAM_SIZE);
/* allocate memory */
m_ataxx_qram = auto_alloc_array_clear(machine(), UINT8, QRAM_SIZE);
}
void k053936_device::device_start()
{
m_ctrl = auto_alloc_array_clear(machine(), UINT16, 0x20);
m_linectrl = auto_alloc_array_clear(machine(), UINT16, 0x4000);
save_pointer(NAME(m_ctrl), 0x20);
save_pointer(NAME(m_linectrl), 0x4000);
}
static void toaplan1_spritevram_alloc(running_machine *machine)
{
spriteram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITERAM_SIZE/2);
buffered_spriteram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITERAM_SIZE/2);
toaplan1_spritesizeram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
toaplan1_buffered_spritesizeram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
spriteram_size = TOAPLAN1_SPRITERAM_SIZE;
}
static void nmk16_video_init(running_machine *machine)
{
spriteram_old = auto_alloc_array_clear(machine, UINT16, 0x1000/2);
spriteram_old2 = auto_alloc_array_clear(machine, UINT16, 0x1000/2);
videoshift = 0; /* 256x224 screen, no shift */
background_bitmap = NULL;
nmk16_simple_scroll = 1;
}
void nmk16_state::nmk16_video_init()
{
m_spriteram_old = auto_alloc_array_clear(machine(), UINT16, 0x1000/2);
m_spriteram_old2 = auto_alloc_array_clear(machine(), UINT16, 0x1000/2);
m_videoshift = 0; /* 256x224 screen, no shift */
m_background_bitmap = NULL;
m_simple_scroll = 1;
}
void pc090oj_device::device_start()
{
m_ram = auto_alloc_array_clear(machine(), UINT16, PC090OJ_RAM_SIZE / 2);
m_ram_buffered = auto_alloc_array_clear(machine(), UINT16, PC090OJ_RAM_SIZE / 2);
save_pointer(NAME(m_ram), PC090OJ_RAM_SIZE / 2);
save_pointer(NAME(m_ram_buffered), PC090OJ_RAM_SIZE / 2);
save_item(NAME(m_ctrl));
save_item(NAME(m_sprite_ctrl)); // should this be set in intf?!?
}
static void nmk16_video_init(running_machine &machine)
{
nmk16_state *state = machine.driver_data<nmk16_state>();
state->m_spriteram_old = auto_alloc_array_clear(machine, UINT16, 0x1000/2);
state->m_spriteram_old2 = auto_alloc_array_clear(machine, UINT16, 0x1000/2);
state->m_videoshift = 0; /* 256x224 screen, no shift */
state->m_background_bitmap = NULL;
state->m_simple_scroll = 1;
}
void deco16ic_device::device_start()
{
m_bank_cb_func[0] = m_bank_cb0;
m_bank_cb_func[1] = m_bank_cb1;
int fullheight = 0;
int fullwidth = 0;
if (m_full_width12&2)
fullheight = 1;
if (m_full_width12&1)
fullwidth = 1;
m_pf1_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(deco16ic_device::get_pf1_tile_info),this), tilemap_mapper_delegate(FUNC(deco16ic_device::deco16_scan_rows),this), 16, 16, fullwidth ? 64 : 32, fullheight ?64 : 32);
// m_pf1_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(deco16ic_device::get_pf1_tile_info_b),this), TILEMAP_SCAN_ROWS, 8, 8, m_full_width12 ? 64 : 32, 32);
m_pf1_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(deco16ic_device::get_pf1_tile_info_b),this), TILEMAP_SCAN_ROWS, 8, 8, 64 , 32); // nitroball
if (m_split)
m_pf2_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(deco16ic_device::get_pf2_tile_info),this), tilemap_mapper_delegate(FUNC(deco16ic_device::deco16_scan_rows),this), 16, 16, fullwidth ? 64 : 32, fullheight ? 64 : 32);
else
m_pf2_tilemap_16x16 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(deco16ic_device::get_pf2_tile_info),this), tilemap_mapper_delegate(FUNC(deco16ic_device::deco16_scan_rows),this), 16, 16, fullwidth ? 64 : 32, fullheight ? 64 : 32);
m_pf2_tilemap_8x8 = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(deco16ic_device::get_pf2_tile_info_b),this), TILEMAP_SCAN_ROWS, 8, 8, fullwidth ? 64 : 32, fullheight ? 64 : 32);
m_pf1_tilemap_8x8->set_transparent_pen(0);
m_pf2_tilemap_8x8->set_transparent_pen(0);
m_pf1_tilemap_16x16->set_transparent_pen(0);
m_pf2_tilemap_16x16->set_transparent_pen(0);
if (m_split) /* Caveman Ninja only */
m_pf2_tilemap_16x16->set_transmask(0, 0x00ff, 0xff01);
m_pf1_8bpp_mode = 0;
m_pf1_data = auto_alloc_array_clear(machine(), UINT16, 0x2000 / 2);
m_pf2_data = auto_alloc_array_clear(machine(), UINT16, 0x2000 / 2);
m_pf12_control = auto_alloc_array_clear(machine(), UINT16, 0x10 / 2);
save_item(NAME(m_use_custom_pf1));
save_item(NAME(m_use_custom_pf2));
save_item(NAME(m_pf1_bank));
save_item(NAME(m_pf2_bank));
save_item(NAME(m_pf12_8x8_gfx_bank));
save_item(NAME(m_pf12_16x16_gfx_bank));
save_item(NAME(m_pf12_last_small));
save_item(NAME(m_pf12_last_big));
save_item(NAME(m_pf1_8bpp_mode));
save_pointer(NAME(m_pf1_data), 0x2000 / 2);
save_pointer(NAME(m_pf2_data), 0x2000 / 2);
save_pointer(NAME(m_pf12_control), 0x10 / 2);
}
void toaplan1_state::toaplan1_spritevram_alloc()
{
m_spriteram.allocate(TOAPLAN1_SPRITERAM_SIZE/2);
m_buffered_spriteram = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_SPRITERAM_SIZE/2);
m_spritesizeram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
m_buffered_spritesizeram16 = auto_alloc_array_clear(machine(), UINT16, TOAPLAN1_SPRITESIZERAM_SIZE/2);
save_pointer(NAME(m_buffered_spriteram), TOAPLAN1_SPRITERAM_SIZE/2);
save_pointer(NAME(m_spritesizeram16), TOAPLAN1_SPRITESIZERAM_SIZE/2);
save_pointer(NAME(m_buffered_spritesizeram16), TOAPLAN1_SPRITESIZERAM_SIZE/2);
}
void cidelsa_state::video_start()
{
// allocate memory
m_pcbram = auto_alloc_array_clear(machine(), UINT8, CIDELSA_CHARRAM_SIZE);
m_charram = auto_alloc_array_clear(machine(), UINT8, CIDELSA_CHARRAM_SIZE);
// register for state saving
save_item(NAME(m_cdp1869_pcb));
save_pointer(NAME(m_pcbram), CIDELSA_CHARRAM_SIZE);
save_pointer(NAME(m_charram), CIDELSA_CHARRAM_SIZE);
}
ROM_END
static DRIVER_INIT(ssingles)
{
ssingles_state *state = machine->driver_data<ssingles_state>();
state->videoram=auto_alloc_array_clear(machine, UINT8, VMEM_SIZE);
state->colorram=auto_alloc_array_clear(machine, UINT8, VMEM_SIZE);
state_save_register_global_pointer(machine, state->videoram, VMEM_SIZE);
state_save_register_global_pointer(machine, state->colorram, VMEM_SIZE);
}
static void videoram_alloc(running_machine* machine, int const size)
{
if (size)
{
/* create video ram */
robokid_bg0_videoram = auto_alloc_array_clear(machine, UINT8, size);
robokid_bg1_videoram = auto_alloc_array_clear(machine, UINT8, size);
robokid_bg2_videoram = auto_alloc_array_clear(machine, UINT8, size);
}
sp_bitmap = machine->primary_screen->alloc_compatible_bitmap();
}
static void videoram_alloc(running_machine& machine, int const size)
{
ninjakd2_state *state = machine.driver_data<ninjakd2_state>();
if (size)
{
/* create video ram */
state->m_robokid_bg0_videoram = auto_alloc_array_clear(machine, UINT8, size);
state->m_robokid_bg1_videoram = auto_alloc_array_clear(machine, UINT8, size);
state->m_robokid_bg2_videoram = auto_alloc_array_clear(machine, UINT8, size);
}
machine.primary_screen->register_screen_bitmap(state->m_sp_bitmap);
}
void deco_bac06_device::device_start()
{
pf_data = auto_alloc_array_clear(this->machine(), UINT16, 0x4000 / 2); // 0x2000 is the maximum needed, some games / chip setups map less and mirror - stadium hero banks this to 0x4000?!
pf_rowscroll = auto_alloc_array_clear(this->machine(), UINT16, 0x2000 / 2);
pf_colscroll = auto_alloc_array_clear(this->machine(), UINT16, 0x2000 / 2);
create_tilemaps(m_gfxregion8x8, m_gfxregion16x16);
m_gfxcolmask = 0x0f;
m_bppmult = 0x10;
m_bppmask = 0x0f;
m_rambank = 0;
}
void tms34061_device::device_start()
{
/* resolve callbak */
m_interrupt_cb.resolve();
/* reset the data */
m_vrammask = m_vramsize - 1;
/* allocate memory for VRAM */
m_vram = auto_alloc_array_clear(machine(), UINT8, m_vramsize + 256 * 2);
/* allocate memory for latch RAM */
m_latchram = auto_alloc_array_clear(machine(), UINT8, m_vramsize + 256 * 2);
/* add some buffer space for VRAM and latch RAM */
m_vram += 256;
m_latchram += 256;
/* point the shift register to the base of VRAM for now */
m_shiftreg = m_vram;
/* initialize registers to their default values from the manual */
m_regs[TMS34061_HORENDSYNC] = 0x0010;
m_regs[TMS34061_HORENDBLNK] = 0x0020;
m_regs[TMS34061_HORSTARTBLNK] = 0x01f0;
m_regs[TMS34061_HORTOTAL] = 0x0200;
m_regs[TMS34061_VERENDSYNC] = 0x0004;
m_regs[TMS34061_VERENDBLNK] = 0x0010;
m_regs[TMS34061_VERSTARTBLNK] = 0x00f0;
m_regs[TMS34061_VERTOTAL] = 0x0100;
m_regs[TMS34061_DISPUPDATE] = 0x0000;
m_regs[TMS34061_DISPSTART] = 0x0000;
m_regs[TMS34061_VERINT] = 0x0000;
m_regs[TMS34061_CONTROL1] = 0x7000;
m_regs[TMS34061_CONTROL2] = 0x0600;
m_regs[TMS34061_STATUS] = 0x0000;
m_regs[TMS34061_XYOFFSET] = 0x0010;
m_regs[TMS34061_XYADDRESS] = 0x0000;
m_regs[TMS34061_DISPADDRESS] = 0x0000;
m_regs[TMS34061_VERCOUNTER] = 0x0000;
/* start vertical interrupt timer */
m_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tms34061_device::interrupt), this));
save_item(NAME(m_regs));
save_item(NAME(m_xmask));
save_item(NAME(m_yshift));
save_pointer(NAME(m_vram), m_vramsize);
save_pointer(NAME(m_latchram), m_vramsize);
save_item(NAME(m_latchdata));
}
void simpsons_state::machine_start()
{
m_generic_paletteram_8.allocate(0x1000);
m_xtraram = auto_alloc_array_clear(machine(), UINT8, 0x1000);
m_spriteram = auto_alloc_array_clear(machine(), UINT16, 0x1000 / 2);
save_item(NAME(m_firq_enabled));
save_item(NAME(m_video_bank));
save_item(NAME(m_sprite_colorbase));
save_item(NAME(m_layer_colorbase));
save_item(NAME(m_layerpri));
save_pointer(NAME(m_xtraram), 0x1000);
save_pointer(NAME(m_spriteram), 0x1000 / 2);
machine().save().register_postload(save_prepost_delegate(FUNC(simpsons_state::simpsons_postload), this));
}
static void toaplan1_vram_alloc(running_machine *machine)
{
pf1_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
pf2_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
pf3_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
pf4_tilevram16 = auto_alloc_array_clear(machine, UINT16, TOAPLAN1_TILEVRAM_SIZE/2);
#ifdef MAME_DEBUG
display_pf1 = 1;
display_pf2 = 1;
display_pf3 = 1;
display_pf4 = 1;
displog = 0;
#endif
}
void k05324x_device::device_start()
{
UINT32 total;
static const gfx_layout spritelayout =
{
16,16,
0,
4,
{ 24, 16, 8, 0 },
{ 0, 1, 2, 3, 4, 5, 6, 7,
8*32+0, 8*32+1, 8*32+2, 8*32+3, 8*32+4, 8*32+5, 8*32+6, 8*32+7 },
{ 0*32, 1*32, 2*32, 3*32, 4*32, 5*32, 6*32, 7*32,
16*32, 17*32, 18*32, 19*32, 20*32, 21*32, 22*32, 23*32 },
128*8
};
/* decode the graphics */
switch (m_plane_order)
{
case NORMAL_PLANE_ORDER:
total = machine().root_device().memregion(m_gfx_memory_region)->bytes() / 128;
konami_decode_gfx(machine(), m_gfx_num, machine().root_device().memregion(m_gfx_memory_region)->base(), total, &spritelayout, 4);
break;
default:
fatalerror("Unsupported plane_order\n");
}
if (VERBOSE && !(machine().config().m_video_attributes & VIDEO_HAS_SHADOWS))
popmessage("driver should use VIDEO_HAS_SHADOWS");
/* deinterleave the graphics, if needed */
konami_deinterleave_gfx(machine(), m_gfx_memory_region, m_deinterleave);
m_ramsize = 0x800;
m_z_rejection = -1;
m_gfx = machine().gfx[m_gfx_num];
m_ram = auto_alloc_array_clear(machine(), UINT16, m_ramsize / 2);
m_buffer = auto_alloc_array_clear(machine(), UINT16, m_ramsize / 2);
save_pointer(NAME(m_ram), m_ramsize / 2);
save_pointer(NAME(m_buffer), m_ramsize / 2);
save_item(NAME(m_rombank));
save_item(NAME(m_z_rejection));
save_item(NAME(m_regs));
}
void nes_exrom_device::device_start()
{
common_start();
save_item(NAME(m_irq_count));
save_item(NAME(m_irq_status));
save_item(NAME(m_irq_enable));
save_item(NAME(m_mult1));
save_item(NAME(m_mult2));
save_item(NAME(m_mmc5_scanline));
save_item(NAME(m_vrom_page_a));
save_item(NAME(m_vrom_page_b));
save_item(NAME(m_floodtile));
save_item(NAME(m_floodattr));
save_item(NAME(m_prg_mode));
save_item(NAME(m_chr_mode));
save_item(NAME(m_wram_base));
save_item(NAME(m_wram_protect_1));
save_item(NAME(m_wram_protect_2));
save_item(NAME(m_mmc5_last_chr_a)); // basically unused in current code
save_item(NAME(m_high_chr));
save_item(NAME(m_split_scr));
save_item(NAME(m_split_ctrl));
save_item(NAME(m_split_yst));
save_item(NAME(m_split_bank));
save_item(NAME(m_prg_regs));
save_item(NAME(m_vrom_bank));
m_exram = auto_alloc_array_clear(machine(), UINT8, 0x400);
save_pointer(NAME(m_exram), 0x400);
m_mapper_sram_size = 0x400;
m_mapper_sram = m_exram;
}
static MACHINE_START( su2000 )
{
su2000_state *state = machine.driver_data<su2000_state>();
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
state->m_pit8254 = machine.device("pit8254");
state->m_pic8259_1 = machine.device("pic8259_1");
state->m_pic8259_2 = machine.device("pic8259_2");
state->m_dma8237_1 = machine.device("dma8237_1");
state->m_dma8237_2 = machine.device("dma8237_2");
/* Configure RAM */
state->m_pc_ram = auto_alloc_array_clear(machine, UINT32, PC_RAM_SIZE);
/* Conventional memory */
state->membank("mem_bank")->set_base(state->m_pc_ram);
/* HMA */
offs_t ram_limit = 0x100000 + PC_RAM_SIZE - 0x0a0000;
space->install_read_bank(0x100000, ram_limit - 1, "hma_bank");
space->install_write_bank(0x100000, ram_limit - 1, "hma_bank");
state->membank("hma_bank")->set_base(state->m_pc_ram + 0xa0000);
device_set_irq_callback(machine.device("maincpu"), pc_irq_callback);
init_pc_common(machine, PCCOMMON_KEYBOARD_AT, su2000_set_keyb_int);
kbdc8042_init(machine, &at8042);
pc_vga_init(machine, vga_setting, NULL);
pc_vga_io_init(machine, machine.device("maincpu")->memory().space(AS_PROGRAM), 0xa0000, machine.device("maincpu")->memory().space(AS_IO), 0x0000);
}
AM_RANGE(0x000, 0x7ff) AM_RAM
ADDRESS_MAP_END
/* Video Start */
void cidelsa_state::video_start()
{
// allocate memory
m_pcbram = auto_alloc_array_clear(machine(), UINT8, CIDELSA_CHARRAM_SIZE);
m_charram = auto_alloc_array_clear(machine(), UINT8, CIDELSA_CHARRAM_SIZE);
// register for state saving
save_item(NAME(m_cdp1869_pcb));
save_pointer(NAME(m_pcbram), CIDELSA_CHARRAM_SIZE);
save_pointer(NAME(m_charram), CIDELSA_CHARRAM_SIZE);
}
static VIDEO_START( common )
{
midyunit_state *state = machine.driver_data<midyunit_state>();
/* allocate memory */
state->m_cmos_ram = auto_alloc_array(machine, UINT16, (0x2000 * 4)/2);
state->m_local_videoram = auto_alloc_array_clear(machine, UINT16, 0x80000/2);
state->m_pen_map = auto_alloc_array(machine, pen_t, 65536);
machine.device<nvram_device>("nvram")->set_base(state->m_cmos_ram, 0x2000 * 4);
/* reset all the globals */
state->m_cmos_page = 0;
state->m_autoerase_enable = 0;
state->m_yawdim_dma = 0;
/* reset DMA state */
memset(state->m_dma_register, 0, sizeof(state->m_dma_register));
memset(&state->m_dma_state, 0, sizeof(state->m_dma_state));
/* register for state saving */
state_save_register_global(machine, state->m_autoerase_enable);
state_save_register_global_pointer(machine, state->m_local_videoram, 0x80000/2);
state_save_register_global_pointer(machine, state->m_cmos_ram, (0x2000 * 4)/2);
state_save_register_global(machine, state->m_videobank_select);
state_save_register_global_array(machine, state->m_dma_register);
}
void c65_state::c65_common_driver_init( )
{
m_memory = auto_alloc_array_clear(machine(), UINT8, 0x10000);
membank("bank11")->set_base(m_memory + 0x00000);
membank("bank12")->set_base(m_memory + 0x08000);
membank("bank13")->set_base(m_memory + 0x0a000);
membank("bank14")->set_base(m_memory + 0x0c000);
membank("bank15")->set_base(m_memory + 0x0e000);
cbm_common_init();
m_keyline = 0xff;
m_pal = 0;
m_charset_select = 0;
m_6511_port = 0xff;
m_vicirq = 0;
m_old_data = -1;
/* C65 had no datasette port */
m_tape_on = 0;
m_game = 1;
m_exrom = 1;
/*memset(m_memory + 0x40000, 0, 0x800000 - 0x40000); */
}
sound_stream *stream_create(device_t *device, int inputs, int outputs, int sample_rate, void *param, stream_update_func callback)
{
running_machine *machine = device->machine;
streams_private *strdata = machine->streams_data;
int inputnum, outputnum;
sound_stream *stream;
char statetag[30];
/* allocate memory */
stream = auto_alloc_clear(device->machine, sound_stream);
VPRINTF(("stream_create(%d, %d, %d) => %p\n", inputs, outputs, sample_rate, stream));
/* fill in the data */
stream->device = device;
stream->index = strdata->stream_index++;
stream->sample_rate = sample_rate;
stream->inputs = inputs;
stream->outputs = outputs;
stream->callback = callback;
stream->param = param;
/* create a unique tag for saving */
sprintf(statetag, "%d", stream->index);
state_save_register_item(machine, "stream", statetag, 0, stream->sample_rate);
/* allocate space for the inputs */
if (inputs > 0)
{
stream->input = auto_alloc_array_clear(device->machine, stream_input, inputs);
stream->input_array = auto_alloc_array_clear(device->machine, stream_sample_t *, inputs);
}
void *ui_menu::m_pool_alloc(size_t size)
{
ui_menu_pool *ppool;
assert(size < UI_MENU_POOL_SIZE);
// find a pool with enough room
for (ppool = pool; ppool != nullptr; ppool = ppool->next)
if (ppool->end - ppool->top >= size)
{
void *result = ppool->top;
ppool->top += size;
return result;
}
// allocate a new pool
ppool = (ui_menu_pool *)auto_alloc_array_clear(machine(), UINT8, sizeof(*ppool) + UI_MENU_POOL_SIZE);
// wire it up
ppool->next = pool;
pool = ppool;
ppool->top = (UINT8 *)(ppool + 1);
ppool->end = ppool->top + UI_MENU_POOL_SIZE;
return m_pool_alloc(size);
}
