UINT32 nubus_m2video_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
UINT8 pixels, *vram;
vram = m_vram + 0x20;
switch (m_mode)
{
case 0: // 1 bpp?
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/8; x++)
{
pixels = vram[(y * 128) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0x80)];
*scanline++ = m_palette[((pixels<<1)&0x80)];
*scanline++ = m_palette[((pixels<<2)&0x80)];
*scanline++ = m_palette[((pixels<<3)&0x80)];
*scanline++ = m_palette[((pixels<<4)&0x80)];
*scanline++ = m_palette[((pixels<<5)&0x80)];
*scanline++ = m_palette[((pixels<<6)&0x80)];
*scanline++ = m_palette[((pixels<<7)&0x80)];
}
}
break;
case 1: // 2 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/4; x++)
{
pixels = vram[(y * 256) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0xc0)];
*scanline++ = m_palette[((pixels<<2)&0xc0)];
*scanline++ = m_palette[((pixels<<4)&0xc0)];
*scanline++ = m_palette[((pixels<<6)&0xc0)];
}
}
break;
case 2: // 4 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/2; x++)
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0xf0)];
*scanline++ = m_palette[((pixels&0x0f)<<4)];
}
}
break;
case 3: // 8 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels];
}
}
break;
default:
fatalerror("m2video: unknown video mode %d\n", m_mode);
}
return 0;
}
void ui_menu_main::handle()
{
/* process the menu */
const ui_menu_event *menu_event = process(0);
if (menu_event != NULL && menu_event->iptkey == IPT_UI_SELECT) {
switch((long long)(menu_event->itemref)) {
case INPUT_GROUPS:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_input_groups(machine(), container)));
break;
case INPUT_SPECIFIC:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_input_specific(machine(), container)));
break;
case SETTINGS_DIP_SWITCHES:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_settings_dip_switches(machine(), container)));
break;
case SETTINGS_DRIVER_CONFIG:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_settings_driver_config(machine(), container)));
break;
case ANALOG:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_analog(machine(), container)));
break;
case BOOKKEEPING:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_bookkeeping(machine(), container)));
break;
case GAME_INFO:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_game_info(machine(), container)));
break;
case IMAGE_MENU_IMAGE_INFO:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_image_info(machine(), container)));
break;
case IMAGE_MENU_FILE_MANAGER:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_file_manager(machine(), container, NULL)));
break;
case TAPE_CONTROL:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_tape_control(machine(), container, NULL)));
break;
case PTY_INFO:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_pty_info(machine(), container)));
break;
case SLOT_DEVICES:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_slot_devices(machine(), container)));
break;
case NETWORK_DEVICES:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_network_devices(machine(), container)));
break;
case KEYBOARD_MODE:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_keyboard_mode(machine(), container)));
break;
case SLIDERS:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_sliders(machine(), container, false)));
break;
case VIDEO_TARGETS:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_video_targets(machine(), container)));
break;
case VIDEO_OPTIONS:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_video_options(machine(), container, machine().render().first_target())));
break;
case CROSSHAIR:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_crosshair(machine(), container)));
break;
case CHEAT:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_cheat(machine(), container)));
break;
case SELECT_GAME:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_select_game(machine(), container, 0)));
break;
case BIOS_SELECTION:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_bios_selection(machine(), container)));
break;
case BARCODE_READ:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_barcode_reader(machine(), container, NULL)));
break;
default:
fatalerror("ui_menu_main::handle - unknown reference\n");
}
}
}
static UINT32 am2Error5(void)
{
fatalerror("CPU - AM2 - 5 (PC=%06x)", PC);
return 0; /* never reached, fatalerror won't return */
}
void s100_dj2db_device::s100_mwrt_w(address_space &space, offs_t offset, UINT8 data)
{
// if (!(m_board_enbl & m_phantom)) return;
// LS96 inverts data
data ^= 0xff;
if (offset == 0xfbf8) // SERIAL OUT
{
// UART inverted data
}
else if (offset == 0xfbf9) // DRIVE SEL
{
/*
bit description
0 DRIVE 1
1 DRIVE 2
2 DRIVE 3
3 DRIVE 4
4 IN USE / SIDE SELECT
5 INT ENBL
6 _ACCESS ENBL
7 START
*/
// drive select
m_floppy = NULL;
if (BIT(data, 0)) m_floppy = m_floppy0->get_device();
if (BIT(data, 1)) m_floppy = m_floppy1->get_device();
if (BIT(data, 2)) m_floppy = m_floppy2->get_device();
if (BIT(data, 3)) m_floppy = m_floppy3->get_device();
m_fdc->set_floppy(m_floppy);
// side select
if (m_floppy)
{
m_floppy->ss_w(BIT(data, 4));
m_floppy->mon_w(0);
}
// interrupt enable
m_int_enbl = BIT(data, 5);
// access enable
m_access_enbl = BIT(data, 6);
// master reset
if (!BIT(data, 7)) m_fdc->soft_reset();
}
else if (offset == 0xfbfa) // FUNCTION SEL
{
/*
bit description
0 DOUBLE
1 8A SET
2 8A CLEAR
3 LEDOFF
4
5
6
7
*/
// density select
m_fdc->dden_w(BIT(data, 0));
}
else if (offset == 0xfbfb) // WAIT ENBL
{
fatalerror("Z80 WAIT not supported by MAME core\n");
}
else if ((offset >= 0xfbfc) && (offset < 0xfc00))
{
m_fdc->gen_w(offset & 0x03, data);
}
else if ((offset >= 0xfc00) && (offset < 0x10000))
{
m_ram[offset & 0x3ff] = data;
}
}
static void memory_error(const char *message)
{
fatalerror("%s", message);
}
int a800_cart_slot_device::identify_cart_type(UINT8 *header)
{
int type = A800_8K;
// check CART format
if (strncmp((const char *)header, "CART", 4))
fatalerror("Invalid header detected!\n");
switch ((header[4] << 24) + (header[5] << 16) + (header[6] << 8) + (header[7] << 0))
{
case 1:
type = A800_8K;
break;
case 2:
type = A800_16K;
break;
case 3:
type = A800_OSS034M;
break;
case 8:
type = A800_WILLIAMS;
break;
case 9:
type = A800_DIAMOND;
break;
case 10:
type = A800_EXPRESS;
break;
case 11:
type = A800_SPARTADOS;
break;
case 12:
type = A800_XEGS;
break;
case 15:
type = A800_OSSM091;
break;
case 18:
type = A800_BBSB;
break;
case 21:
type = A800_8K_RIGHT;
break;
case 39:
type = A800_PHOENIX;
break;
case 40:
type = A800_BLIZZARD;
break;
case 44:
type = A800_OSS8K;
break;
case 50:
type = A800_TURBO64;
break;
case 51:
type = A800_TURBO128;
break;
case 52:
type = A800_MICROCALC;
break;
// Atari 5200 CART files
case 4:
type = A5200_32K;
break;
case 16:
type = A5200_16K;
break;
case 19:
type = A5200_8K;
break;
case 20:
type = A5200_4K;
break;
case 6:
type = A5200_16K_2CHIPS;
break;
case 7:
type = A5200_BBSB;
break;
default:
osd_printf_info("Cart type \"%d\" is currently unsupported.\n", (header[4] << 24) + (header[5] << 16) + (header[6] << 8) + (header[7] << 0));
break;
}
return type;
}
bool device_image_interface::load_software(software_list_device &swlist, const char *swname, const rom_entry *start)
{
std::string locationtag, breakstr("%");
const rom_entry *region;
bool retVal = FALSE;
int warningcount = 0;
for (region = start; region != nullptr; region = rom_next_region(region))
{
// loop until we hit the end of this region
const rom_entry *romp = region + 1;
while (!ROMENTRY_ISREGIONEND(romp))
{
// handle files
if (ROMENTRY_ISFILE(romp))
{
osd_file::error filerr = osd_file::error::NOT_FOUND;
UINT32 crc = 0;
bool has_crc = util::hash_collection(ROM_GETHASHDATA(romp)).crc(crc);
const software_info *swinfo = swlist.find(swname);
if (swinfo == nullptr)
return false;
UINT32 supported = swinfo->supported();
if (supported == SOFTWARE_SUPPORTED_PARTIAL)
osd_printf_error("WARNING: support for software %s (in list %s) is only partial\n", swname, swlist.list_name());
if (supported == SOFTWARE_SUPPORTED_NO)
osd_printf_error("WARNING: support for software %s (in list %s) is only preliminary\n", swname, swlist.list_name());
// attempt reading up the chain through the parents and create a locationtag std::string in the format
// " swlist % clonename % parentname "
// below, we have the code to split the elements and to create paths to load from
while (swinfo != nullptr)
{
locationtag.append(swinfo->shortname()).append(breakstr);
swinfo = !swinfo->parentname().empty() ? swlist.find(swinfo->parentname().c_str()) : nullptr;
}
// strip the final '%'
locationtag.erase(locationtag.length() - 1, 1);
// check if locationtag actually contains two locations separated by '%'
// (i.e. check if we are dealing with a clone in softwarelist)
std::string tag2, tag3, tag4(locationtag), tag5;
int separator = tag4.find_first_of('%');
if (separator != -1)
{
// we are loading a clone through softlists, split the setname from the parentname
tag5.assign(tag4.substr(separator + 1, tag4.length() - separator + 1));
tag4.erase(separator, tag4.length() - separator);
}
// prepare locations where we have to load from: list/parentname & list/clonename
std::string tag1(swlist.list_name());
tag1.append(PATH_SEPARATOR);
tag2.assign(tag1.append(tag4));
tag1.assign(swlist.list_name());
tag1.append(PATH_SEPARATOR);
tag3.assign(tag1.append(tag5));
if (tag5.find_first_of('%') != -1)
fatalerror("We do not support clones of clones!\n");
// try to load from the available location(s):
// - if we are not using lists, we have regiontag only;
// - if we are using lists, we have: list/clonename, list/parentname, clonename, parentname
// try to load from list/setname
if ((m_mame_file == nullptr) && (tag2.c_str() != nullptr))
m_mame_file = common_process_file(device().machine().options(), tag2.c_str(), has_crc, crc, romp, filerr);
// try to load from list/parentname
if ((m_mame_file == nullptr) && (tag3.c_str() != nullptr))
m_mame_file = common_process_file(device().machine().options(), tag3.c_str(), has_crc, crc, romp, filerr);
// try to load from setname
if ((m_mame_file == nullptr) && (tag4.c_str() != nullptr))
m_mame_file = common_process_file(device().machine().options(), tag4.c_str(), has_crc, crc, romp, filerr);
// try to load from parentname
if ((m_mame_file == nullptr) && (tag5.c_str() != nullptr))
m_mame_file = common_process_file(device().machine().options(), tag5.c_str(), has_crc, crc, romp, filerr);
warningcount += verify_length_and_hash(m_mame_file.get(),ROM_GETNAME(romp),ROM_GETLENGTH(romp), util::hash_collection(ROM_GETHASHDATA(romp)));
if (filerr == osd_file::error::NONE)
filerr = util::core_file::open_proxy(*m_mame_file, m_file);
if (filerr == osd_file::error::NONE)
retVal = TRUE;
break; // load first item for start
}
romp++; /* something else; skip */
}
}
if (warningcount > 0)
{
osd_printf_error("WARNING: the software item might not run correctly.\n");
}
return retVal;
}
static UINT64 READ_EA_64(m68ki_cpu_core *m68k, int ea)
{
int mode = (ea >> 3) & 0x7;
int reg = (ea & 0x7);
UINT32 h1, h2;
switch (mode)
{
case 2: // (An)
{
UINT32 ea = REG_A(m68k)[reg];
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 3: // (An)+
{
UINT32 ea = REG_A(m68k)[reg];
REG_A(m68k)[reg] += 8;
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 4: // -(An)
{
UINT32 ea = REG_A(m68k)[reg]-8;
REG_A(m68k)[reg] -= 8;
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 5: // (d16, An)
{
UINT32 ea = EA_AY_DI_32(m68k);
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 6: // (An) + (Xn) + d8
{
UINT32 ea = EA_AY_IX_32(m68k);
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 7:
{
switch (reg)
{
case 1: // (xxx).L
{
UINT32 d1 = OPER_I_16(m68k);
UINT32 d2 = OPER_I_16(m68k);
UINT32 ea = (d1 << 16) | d2;
return (UINT64)(m68ki_read_32(m68k, ea)) << 32 | (UINT64)(m68ki_read_32(m68k, ea+4));
}
case 3: // (PC) + (Xn) + d8
{
UINT32 ea = EA_PCIX_32(m68k);
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 4: // #<data>
{
h1 = OPER_I_32(m68k);
h2 = OPER_I_32(m68k);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
case 2: // (d16, PC)
{
UINT32 ea = EA_PCDI_32(m68k);
h1 = m68ki_read_32(m68k, ea+0);
h2 = m68ki_read_32(m68k, ea+4);
return (UINT64)(h1) << 32 | (UINT64)(h2);
}
default: fatalerror("M68kFPU: READ_EA_64: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC(m68k));
}
break;
}
default: fatalerror("M68kFPU: READ_EA_64: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC(m68k));
}
return 0;
}
static floatx80 READ_EA_FPE(m68ki_cpu_core *m68k, int ea)
{
floatx80 fpr;
int mode = (ea >> 3) & 0x7;
int reg = (ea & 0x7);
switch (mode)
{
case 2: // (An)
{
UINT32 ea = REG_A(m68k)[reg];
fpr = load_extended_float80(m68k, ea);
break;
}
case 3: // (An)+
{
UINT32 ea = REG_A(m68k)[reg];
REG_A(m68k)[reg] += 12;
fpr = load_extended_float80(m68k, ea);
break;
}
case 4: // -(An)
{
UINT32 ea = REG_A(m68k)[reg]-12;
REG_A(m68k)[reg] -= 12;
fpr = load_extended_float80(m68k, ea);
break;
}
case 5: // (d16, An)
{
// FIXME: will fail for fmovem
UINT32 ea = EA_AY_DI_32(m68k);
fpr = load_extended_float80(m68k, ea);
break;
}
case 6: // (An) + (Xn) + d8
{
// FIXME: will fail for fmovem
UINT32 ea = EA_AY_IX_32(m68k);
fpr = load_extended_float80(m68k, ea);
break;
}
case 7: // extended modes
{
switch (reg)
{
case 2: // (d16, PC)
{
UINT32 ea = EA_PCDI_32(m68k);
fpr = load_extended_float80(m68k, ea);
}
break;
case 3: // (d16,PC,Dx.w)
{
UINT32 ea = EA_PCIX_32(m68k);
fpr = load_extended_float80(m68k, ea);
}
break;
default:
fatalerror("M68kFPU: READ_EA_FPE: unhandled mode %d, reg %d, at %08X\n", mode, reg, REG_PC(m68k));
break;
}
}
break;
default: fatalerror("M68kFPU: READ_EA_FPE: unhandled mode %d, reg %d, at %08X\n", mode, reg, REG_PC(m68k)); break;
}
return fpr;
}
INLINE int TEST_CONDITION(m68ki_cpu_core *m68k, int condition)
{
int n = (REG_FPSR(m68k) & FPCC_N) != 0;
int z = (REG_FPSR(m68k) & FPCC_Z) != 0;
int nan = (REG_FPSR(m68k) & FPCC_NAN) != 0;
int r = 0;
switch (condition)
{
case 0x10:
case 0x00: return 0; // False
case 0x11:
case 0x01: return (z); // Equal
case 0x12:
case 0x02: return (!(nan || z || n)); // Greater Than
case 0x13:
case 0x03: return (z || !(nan || n)); // Greater or Equal
case 0x14:
case 0x04: return (n && !(nan || z)); // Less Than
case 0x15:
case 0x05: return (z || (n && !nan)); // Less Than or Equal
case 0x16:
case 0x06: return !nan && !z;
case 0x17:
case 0x07: return !nan;
case 0x18:
case 0x08: return nan;
case 0x19:
case 0x09: return nan || z;
case 0x1a:
case 0x0a: return (nan || !(n || z)); // Not Less Than or Equal
case 0x1b:
case 0x0b: return (nan || z || !n); // Not Less Than
case 0x1c:
case 0x0c: return (nan || (n && !z)); // Not Greater or Equal Than
case 0x1d:
case 0x0d: return (nan || z || n); // Not Greater Than
case 0x1e:
case 0x0e: return (!z); // Not Equal
case 0x1f:
case 0x0f: return 1; // True
default: fatalerror("M68kFPU: test_condition: unhandled condition %02X\n", condition);
}
return r;
}
static UINT32 READ_EA_32(m68ki_cpu_core *m68k, int ea)
{
int mode = (ea >> 3) & 0x7;
int reg = (ea & 0x7);
switch (mode)
{
case 0: // Dn
{
return REG_D(m68k)[reg];
}
case 2: // (An)
{
UINT32 ea = REG_A(m68k)[reg];
return m68ki_read_32(m68k, ea);
}
case 3: // (An)+
{
UINT32 ea = EA_AY_PI_32(m68k);
return m68ki_read_32(m68k, ea);
}
case 4: // -(An)
{
UINT32 ea = EA_AY_PD_32(m68k);
return m68ki_read_32(m68k, ea);
}
case 5: // (d16, An)
{
UINT32 ea = EA_AY_DI_32(m68k);
return m68ki_read_32(m68k, ea);
}
case 6: // (An) + (Xn) + d8
{
UINT32 ea = EA_AY_IX_32(m68k);
return m68ki_read_32(m68k, ea);
}
case 7:
{
switch (reg)
{
case 0: // (xxx).W
{
UINT32 ea = (UINT32)OPER_I_16(m68k);
return m68ki_read_32(m68k, ea);
}
case 1: // (xxx).L
{
UINT32 d1 = OPER_I_16(m68k);
UINT32 d2 = OPER_I_16(m68k);
UINT32 ea = (d1 << 16) | d2;
return m68ki_read_32(m68k, ea);
}
case 2: // (d16, PC)
{
UINT32 ea = EA_PCDI_32(m68k);
return m68ki_read_32(m68k, ea);
}
case 3: // (PC) + (Xn) + d8
{
UINT32 ea = EA_PCIX_32(m68k);
return m68ki_read_32(m68k, ea);
}
case 4: // #<data>
{
return OPER_I_32(m68k);
}
default: fatalerror("M68kFPU: READ_EA_32: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC(m68k));
}
break;
}
default: fatalerror("M68kFPU: READ_EA_32: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC(m68k));
}
return 0;
}
static void fpgen_rm_reg(m68ki_cpu_core *m68k, UINT16 w2)
{
int ea = m68k->ir & 0x3f;
int rm = (w2 >> 14) & 0x1;
int src = (w2 >> 10) & 0x7;
int dst = (w2 >> 7) & 0x7;
int opmode = w2 & 0x7f;
floatx80 source;
// fmovecr #$f, fp0 f200 5c0f
if (rm)
{
switch (src)
{
case 0: // Long-Word Integer
{
INT32 d = READ_EA_32(m68k, ea);
source = int32_to_floatx80(d);
break;
}
case 1: // Single-precision Real
{
UINT32 d = READ_EA_32(m68k, ea);
source = float32_to_floatx80(d);
break;
}
case 2: // Extended-precision Real
{
source = READ_EA_FPE(m68k, ea);
break;
}
case 3: // Packed-decimal Real
{
source = READ_EA_PACK(m68k, ea);
break;
}
case 4: // Word Integer
{
INT16 d = READ_EA_16(m68k, ea);
source = int32_to_floatx80((INT32)d);
break;
}
case 5: // Double-precision Real
{
UINT64 d = READ_EA_64(m68k, ea);
source = float64_to_floatx80(d);
break;
}
case 6: // Byte Integer
{
INT8 d = READ_EA_8(m68k, ea);
source = int32_to_floatx80((INT32)d);
break;
}
case 7: // FMOVECR load from constant ROM
{
switch (w2 & 0x7f)
{
case 0x0: // Pi
source.high = 0x4000;
source.low = U64(0xc90fdaa22168c235);
break;
case 0xb: // log10(2)
source.high = 0x3ffd;
source.low = U64(0x9a209a84fbcff798);
break;
case 0xc: // e
source.high = 0x4000;
source.low = U64(0xadf85458a2bb4a9b);
break;
case 0xd: // log2(e)
source.high = 0x3fff;
source.low = U64(0xb8aa3b295c17f0bc);
break;
case 0xe: // log10(e)
source.high = 0x3ffd;
source.low = U64(0xde5bd8a937287195);
break;
case 0xf: // 0.0
source = int32_to_floatx80((INT32)0);
break;
case 0x30: // ln(2)
source.high = 0x3ffe;
source.low = U64(0xb17217f7d1cf79ac);
break;
case 0x31: // ln(10)
source.high = 0x4000;
source.low = U64(0x935d8dddaaa8ac17);
break;
case 0x32: // 1 (or 100? manuals are unclear, but 1 would make more sense)
source = int32_to_floatx80((INT32)1);
break;
case 0x33: // 10^1
source = int32_to_floatx80((INT32)10);
break;
case 0x34: // 10^2
source = int32_to_floatx80((INT32)10*10);
break;
case 0x35: // 10^4
source = int32_to_floatx80((INT32)1000*10);
break;
case 0x36: // 1.0e8
source = int32_to_floatx80((INT32)10000000*10);
break;
case 0x37: // 1.0e16 - can't get the right precision from INT32 so go "direct" with constants from h/w
source.high = 0x4034;
source.low = U64(0x8e1bc9bf04000000);
break;
case 0x38: // 1.0e32
source.high = 0x4069;
source.low = U64(0x9dc5ada82b70b59e);
break;
case 0x39: // 1.0e64
source.high = 0x40d3;
source.low = U64(0xc2781f49ffcfa6d5);
break;
case 0x3a: // 1.0e128
source.high = 0x41a8;
source.low = U64(0x93ba47c980e98ce0);
break;
case 0x3b: // 1.0e256
source.high = 0x4351;
source.low = U64(0xaa7eebfb9df9de8e);
break;
case 0x3c: // 1.0e512
source.high = 0x46a3;
source.low = U64(0xe319a0aea60e91c7);
break;
case 0x3d: // 1.0e1024
source.high = 0x4d48;
source.low = U64(0xc976758681750c17);
break;
case 0x3e: // 1.0e2048
source.high = 0x5a92;
source.low = U64(0x9e8b3b5dc53d5de5);
break;
case 0x3f: // 1.0e4096
source.high = 0x7525;
source.low = U64(0xc46052028a20979b);
break;
default:
fatalerror("fmove_rm_reg: unknown constant ROM offset %x at %08x\n", w2&0x7f, REG_PC(m68k)-4);
break;
}
// handle it right here, the usual opmode bits aren't valid in the FMOVECR case
REG_FP(m68k)[dst] = source;
m68k->remaining_cycles -= 4;
return;
}
default: fatalerror("fmove_rm_reg: invalid source specifier %x at %08X\n", src, REG_PC(m68k)-4);
}
}
else
{
source = REG_FP(m68k)[src];
}
switch (opmode)
{
case 0x00: // FMOVE
{
REG_FP(m68k)[dst] = source;
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 4;
break;
}
case 0x01: // FINT
{
INT32 temp;
temp = floatx80_to_int32(source);
REG_FP(m68k)[dst] = int32_to_floatx80(temp);
break;
}
case 0x03: // FINTRZ
{
INT32 temp;
temp = floatx80_to_int32_round_to_zero(source);
REG_FP(m68k)[dst] = int32_to_floatx80(temp);
break;
}
case 0x04: // FSQRT
{
REG_FP(m68k)[dst] = floatx80_sqrt(source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 109;
break;
}
case 0x06: // FLOGNP1
{
REG_FP(m68k)[dst] = floatx80_flognp1 (source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 594; // for MC68881
break;
}
case 0x0e: // FSIN
{
REG_FP(m68k)[dst] = source;
floatx80_fsin(REG_FP(m68k)[dst]);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 75;
break;
}
case 0x0f: // FTAN
{
REG_FP(m68k)[dst] = source;
floatx80_ftan(REG_FP(m68k)[dst]);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 75;
break;
}
case 0x14: // FLOGN
{
REG_FP(m68k)[dst] = floatx80_flogn (source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 548; // for MC68881
break;
}
case 0x15: // FLOG10
{
REG_FP(m68k)[dst] = floatx80_flog10 (source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 604; // for MC68881
break;
}
case 0x16: // FLOG2
{
REG_FP(m68k)[dst] = floatx80_flog2 (source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 604; // for MC68881
break;
}
case 0x18: // FABS
{
REG_FP(m68k)[dst] = source;
REG_FP(m68k)[dst].high &= 0x7fff;
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 3;
break;
}
case 0x1a: // FNEG
{
REG_FP(m68k)[dst] = source;
REG_FP(m68k)[dst].high ^= 0x8000;
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 3;
break;
}
case 0x1d: // FCOS
{
REG_FP(m68k)[dst] = source;
floatx80_fcos(REG_FP(m68k)[dst]);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 75;
break;
}
case 0x1e: // FGETEXP
{
INT16 temp2;
temp2 = source.high; // get the exponent
temp2 -= 0x3fff; // take off the bias
REG_FP(m68k)[dst] = double_to_fx80((double)temp2);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 6;
break;
}
case 0x20: // FDIV
{
REG_FP(m68k)[dst] = floatx80_div(REG_FP(m68k)[dst], source);
m68k->remaining_cycles -= 43;
break;
}
case 0x22: // FADD
{
REG_FP(m68k)[dst] = floatx80_add(REG_FP(m68k)[dst], source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 9;
break;
}
case 0x23: // FMUL
{
REG_FP(m68k)[dst] = floatx80_mul(REG_FP(m68k)[dst], source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 11;
break;
}
case 0x24: // FSGLDIV
{
float32 a = floatx80_to_float32( REG_FP(m68k)[dst] );
float32 b = floatx80_to_float32( source );
REG_FP(m68k)[dst] = float32_to_floatx80( float32_div(a, b) );
m68k->remaining_cycles -= 43; // // ? (value is from FDIV)
break;
}
case 0x25: // FREM
{
REG_FP(m68k)[dst] = floatx80_rem(REG_FP(m68k)[dst], source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 43; // guess
break;
}
case 0x27: // FSGLMUL
{
float32 a = floatx80_to_float32( REG_FP(m68k)[dst] );
float32 b = floatx80_to_float32( source );
REG_FP(m68k)[dst] = float32_to_floatx80( float32_mul(a, b) );
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 11; // ? (value is from FMUL)
break;
}
case 0x28: // FSUB
{
REG_FP(m68k)[dst] = floatx80_sub(REG_FP(m68k)[dst], source);
SET_CONDITION_CODES(m68k, REG_FP(m68k)[dst]);
m68k->remaining_cycles -= 9;
break;
}
case 0x38: // FCMP
{
floatx80 res;
res = floatx80_sub(REG_FP(m68k)[dst], source);
SET_CONDITION_CODES(m68k, res);
m68k->remaining_cycles -= 7;
break;
}
case 0x3a: // FTST
{
floatx80 res;
res = source;
SET_CONDITION_CODES(m68k, res);
m68k->remaining_cycles -= 7;
break;
}
default: fatalerror("fpgen_rm_reg: unimplemented opmode %02X at %08X\n", opmode, REG_PPC(m68k));
}
}
static void WRITE_EA_64(m68ki_cpu_core *m68k, int ea, UINT64 data)
{
int mode = (ea >> 3) & 0x7;
int reg = (ea & 0x7);
switch (mode)
{
case 2: // (An)
{
UINT32 ea = REG_A(m68k)[reg];
m68ki_write_32(m68k, ea, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
case 3: // (An)+
{
UINT32 ea = REG_A(m68k)[reg];
REG_A(m68k)[reg] += 8;
m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
case 4: // -(An)
{
UINT32 ea;
REG_A(m68k)[reg] -= 8;
ea = REG_A(m68k)[reg];
m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
case 5: // (d16, An)
{
UINT32 ea = EA_AY_DI_32(m68k);
m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
case 6: // (An) + (Xn) + d8
{
UINT32 ea = EA_AY_IX_32(m68k);
m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
case 7:
{
switch (reg)
{
case 1: // (xxx).L
{
UINT32 d1 = OPER_I_16(m68k);
UINT32 d2 = OPER_I_16(m68k);
UINT32 ea = (d1 << 16) | d2;
m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
case 2: // (d16, PC)
{
UINT32 ea = EA_PCDI_32(m68k);
m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
m68ki_write_32(m68k, ea+4, (UINT32)(data));
break;
}
default: fatalerror("M68kFPU: WRITE_EA_64: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC(m68k));
}
break;
}
default: fatalerror("M68kFPU: WRITE_EA_64: unhandled mode %d, reg %d, data %08X%08X at %08X\n", mode, reg, (UINT32)(data >> 32), (UINT32)(data), REG_PC(m68k));
}
}
/*********************************************************************//*!
* @brief The main program
*
* Opens the camera and reads pictures as fast as possible
* Makes a debayering of the image
* Writes the debayered image to a buffer which can be read by
* TCP clients on Port 8111. Several concurrent clients are allowed.
* The simplest streaming video client looks like this:
*
* nc 192.168.1.10 8111 | mplayer - -demuxer rawvideo -rawvideo w=376:h=240:format=bgr24:fps=100
*
* Writes every 10th picture to a .jpg file in the Web Server Directory
*//*********************************************************************/
int main(const int argc, const char * argv[])
{
struct OSC_PICTURE calcPic;
struct OSC_PICTURE rawPic;
unsigned char *tmpbuf;
int loops=0;
int numalarm=0;
char filename[100];
initSystem(&sys);
ip_start_server();
/* setup variables */
rawPic.width = OSC_CAM_MAX_IMAGE_WIDTH;
rawPic.height = OSC_CAM_MAX_IMAGE_HEIGHT;
rawPic.type = OSC_PICTURE_GREYSCALE;
/* calcPic width, height etc. are set in the debayering algos */
calcPic.data = malloc(3 * OSC_CAM_MAX_IMAGE_WIDTH * OSC_CAM_MAX_IMAGE_HEIGHT);
if (calcPic.data == 0)
fatalerror("Did not get memory\n");
tmpbuf = malloc(500000);
if (tmpbuf == 0)
fatalerror("Did not get memory\n");
#if defined(OSC_TARGET)
/* Take a picture, first time slower ;-) */
usleep(10000); OscGpioTriggerImage(); usleep(10000);
OscLog(DEBUG,"Triggered CAM ");
#endif
while(true) {
OscCamReadPicture(OSC_CAM_MULTI_BUFFER, (void *) &rawPic.data, 0, 0);
/* Take a picture */
usleep(2000);
OscCamSetupCapture(OSC_CAM_MULTI_BUFFER);
#if defined(OSC_TARGET)
OscGpioTriggerImage();
#else
usleep(10000);
#endif
if (is_alarm(&rawPic)) {
OscGpioSetTestLed(TRUE);
printf("alarm\n");
sprintf(filename, "/home/httpd/alarm_pic%02i.jpg", numalarm%16);
writeJPG(&calcPic, tmpbuf, filename);
numalarm++;
} else {
OscGpioSetTestLed(FALSE);
}
fastdebayerBGR(rawPic, &calcPic, NULL);
ip_send_all((char *)calcPic.data, calcPic.width*calcPic.height*
OSC_PICTURE_TYPE_COLOR_DEPTH(calcPic.type)/8);
loops+=1;
if (loops%20 == 0) {
writeJPG(&calcPic, tmpbuf, "/home/httpd/liveimage.jpg");
}
ip_do_work();
}
ip_stop_server();
cleanupSystem(&sys);
return 0;
} /* main */
UINT32 nubus_cb264se30_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
UINT8 pixels, *vram;
vram = &m_vram[8*1024];
switch (m_mode)
{
case 0: // 1 bpp?
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/8; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0x80)];
*scanline++ = m_palette[((pixels<<1)&0x80)];
*scanline++ = m_palette[((pixels<<2)&0x80)];
*scanline++ = m_palette[((pixels<<3)&0x80)];
*scanline++ = m_palette[((pixels<<4)&0x80)];
*scanline++ = m_palette[((pixels<<5)&0x80)];
*scanline++ = m_palette[((pixels<<6)&0x80)];
*scanline++ = m_palette[((pixels<<7)&0x80)];
}
}
break;
case 1: // 2 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/4; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0xc0)];
*scanline++ = m_palette[((pixels<<2)&0xc0)];
*scanline++ = m_palette[((pixels<<4)&0xc0)];
*scanline++ = m_palette[((pixels<<6)&0xc0)];
}
}
break;
case 2: // 4 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/2; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0xf0)];
*scanline++ = m_palette[((pixels&0x0f)<<4)];
}
}
break;
case 3: // 8 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels];
}
}
break;
case 4: // 24 bpp
{
UINT32 *vram32 = (UINT32 *)&m_vram[0];
UINT32 *base;
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
base = &vram32[y * 1024];
for (x = 0; x < 640; x++)
{
*scanline++ = *base++;
}
}
}
break;
default:
fatalerror("cb264se30: unknown video mode %d\n", m_mode);
}
return 0;
}
static void WRITE_EA_32(m68ki_cpu_core *m68k, int ea, UINT32 data)
{
int mode = (ea >> 3) & 0x7;
int reg = (ea & 0x7);
switch (mode)
{
case 0: // Dn
{
REG_D(m68k)[reg] = data;
break;
}
case 1: // An
{
REG_A(m68k)[reg] = data;
break;
}
case 2: // (An)
{
UINT32 ea = REG_A(m68k)[reg];
m68ki_write_32(m68k, ea, data);
break;
}
case 3: // (An)+
{
UINT32 ea = EA_AY_PI_32(m68k);
m68ki_write_32(m68k, ea, data);
break;
}
case 4: // -(An)
{
UINT32 ea = EA_AY_PD_32(m68k);
m68ki_write_32(m68k, ea, data);
break;
}
case 5: // (d16, An)
{
UINT32 ea = EA_AY_DI_32(m68k);
m68ki_write_32(m68k, ea, data);
break;
}
case 6: // (An) + (Xn) + d8
{
UINT32 ea = EA_AY_IX_32(m68k);
m68ki_write_32(m68k, ea, data);
break;
}
case 7:
{
switch (reg)
{
case 1: // (xxx).L
{
UINT32 d1 = OPER_I_16(m68k);
UINT32 d2 = OPER_I_16(m68k);
UINT32 ea = (d1 << 16) | d2;
m68ki_write_32(m68k, ea, data);
break;
}
case 2: // (d16, PC)
{
UINT32 ea = EA_PCDI_32(m68k);
m68ki_write_32(m68k, ea, data);
break;
}
default: fatalerror("M68kFPU: WRITE_EA_32: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC(m68k));
}
break;
}
default: fatalerror("M68kFPU: WRITE_EA_32: unhandled mode %d, reg %d, data %08X at %08X\n", mode, reg, data, REG_PC(m68k));
}
}
file_error video_manager::open_next(emu_file &file, const char *extension)
{
UINT32 origflags = file.openflags();
// handle defaults
const char *snapname = machine().options().snap_name();
if (snapname == NULL || snapname[0] == 0)
snapname = "%g/%i";
astring snapstr(snapname);
// strip any extension in the provided name
int index = snapstr.rchr(0, '.');
if (index != -1)
snapstr.substr(0, index);
// handle %d in the template (for image devices)
astring snapdev("%d_");
int pos = snapstr.find(0, snapdev);
if (pos != -1)
{
// if more %d are found, revert to default and ignore them all
if (snapstr.find(pos + 3, snapdev) != -1)
snapstr.cpy("%g/%i");
// else if there is a single %d, try to create the correct snapname
else
{
int name_found = 0;
// find length of the device name
int end1 = snapstr.find(pos + 3, "/");
int end2 = snapstr.find(pos + 3, "%");
int end = -1;
if ((end1 != -1) && (end2 != -1))
end = MIN(end1, end2);
else if (end1 != -1)
end = end1;
else if (end2 != -1)
end = end2;
else
end = snapstr.len();
if (end - pos < 3)
fatalerror("Something very wrong is going on!!!");
// copy the device name to an astring
astring snapdevname;
snapdevname.cpysubstr(snapstr, pos + 3, end - pos - 3);
//printf("check template: %s\n", snapdevname.cstr());
// verify that there is such a device for this system
device_image_interface *image = NULL;
for (bool gotone = machine().devicelist().first(image); gotone; gotone = image->next(image))
{
// get the device name
astring tempdevname(image->brief_instance_name());
//printf("check device: %s\n", tempdevname.cstr());
if (snapdevname.cmp(tempdevname) == 0)
{
// verify that such a device has an image mounted
if (image->basename() != NULL)
{
astring filename(image->basename());
// strip extension
filename.substr(0, filename.rchr(0, '.'));
// setup snapname and remove the %d_
snapstr.replace(0, snapdevname, filename);
snapstr.del(pos, 3);
//printf("check image: %s\n", filename.cstr());
name_found = 1;
}
}
}
// or fallback to default
if (name_found == 0)
snapstr.cpy("%g/%i");
}
}
// add our own extension
snapstr.cat(".").cat(extension);
// substitute path and gamename up front
snapstr.replace(0, "/", PATH_SEPARATOR);
snapstr.replace(0, "%g", machine().basename());
// determine if the template has an index; if not, we always use the same name
astring fname;
if (snapstr.find(0, "%i") == -1)
fname.cpy(snapstr);
// otherwise, we scan for the next available filename
else
{
// try until we succeed
astring seqtext;
file.set_openflags(OPEN_FLAG_READ);
for (int seq = 0; ; seq++)
{
// build up the filename
fname.cpy(snapstr).replace(0, "%i", seqtext.format("%04d", seq).cstr());
// try to open the file; stop when we fail
file_error filerr = file.open(fname);
if (filerr != FILERR_NONE)
break;
}
}
// create the final file
file.set_openflags(origflags);
return file.open(fname);
}
void laserdisc_device::init_video()
{
// register for VBLANK callbacks
m_screen->register_vblank_callback(vblank_state_delegate(FUNC(laserdisc_device::vblank_state_changed), this));
// allocate palette for applying brightness/contrast/gamma
m_videopalette = palette_t::alloc(256);
if (m_videopalette == nullptr)
throw emu_fatalerror("Out of memory allocating video palette");
for (int index = 0; index < 256; index++)
m_videopalette->entry_set_color(index, rgb_t(index, index, index));
// allocate video frames
for (auto & frame : m_frame)
{
// first allocate a YUY16 bitmap at 2x the height
frame.m_bitmap.allocate(m_width, m_height * 2);
frame.m_bitmap.set_palette(m_videopalette);
fillbitmap_yuy16(frame.m_bitmap, 40, 109, 240);
// make a copy of the bitmap that clips out the VBI and horizontal blanking areas
frame.m_visbitmap.wrap(&frame.m_bitmap.pix16(44, frame.m_bitmap.width() * 8 / 720),
frame.m_bitmap.width() - 2 * frame.m_bitmap.width() * 8 / 720,
frame.m_bitmap.height() - 44,
frame.m_bitmap.rowpixels());
frame.m_visbitmap.set_palette(m_videopalette);
}
// allocate an empty frame of the same size
m_emptyframe.allocate(m_width, m_height * 2);
m_emptyframe.set_palette(m_videopalette);
fillbitmap_yuy16(m_emptyframe, 0, 128, 128);
// allocate texture for rendering
m_videoenable = true;
m_videotex = machine().render().texture_alloc();
if (m_videotex == nullptr)
fatalerror("Out of memory allocating video texture\n");
// allocate overlay
m_overenable = overlay_configured();
if (m_overenable)
{
// bind our handlers
m_overupdate_ind16.bind_relative_to(*owner());
m_overupdate_rgb32.bind_relative_to(*owner());
// configure bitmap formats
bitmap_format format = !m_overupdate_ind16.isnull() ? BITMAP_FORMAT_IND16 : BITMAP_FORMAT_RGB32;
texture_format texformat = !m_overupdate_ind16.isnull() ? TEXFORMAT_PALETTEA16 : TEXFORMAT_ARGB32;
// allocate overlay bitmaps
for (auto & elem : m_overbitmap)
{
elem.set_format(format, texformat);
if (format==BITMAP_FORMAT_IND16)
elem.set_palette(m_overlay_palette->palette());
elem.resize(m_overwidth, m_overheight);
}
// allocate overlay texture
m_overtex = machine().render().texture_alloc();
if (m_overtex == nullptr)
fatalerror("Out of memory allocating overlay texture\n");
}
}
static SCREEN_UPDATE_RGB32( specpdq )
{
UINT32 *scanline;
int x, y;
nubus_specpdq_device *card = downcast<nubus_specpdq_device *>(screen.owner());
UINT8 pixels, *vram;
// first time? kick off the VBL timer
if (!card->m_screen)
{
card->m_screen = &screen;
card->m_timer->adjust(card->m_screen->time_until_pos(843, 0), 0);
}
vram = card->m_vram + 0x9000;
switch (card->m_mode)
{
case 0: // 1 bpp
for (y = 0; y < 844; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 1152/8; x++)
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels&0x80)];
*scanline++ = card->m_palette[((pixels<<1)&0x80)];
*scanline++ = card->m_palette[((pixels<<2)&0x80)];
*scanline++ = card->m_palette[((pixels<<3)&0x80)];
*scanline++ = card->m_palette[((pixels<<4)&0x80)];
*scanline++ = card->m_palette[((pixels<<5)&0x80)];
*scanline++ = card->m_palette[((pixels<<6)&0x80)];
*scanline++ = card->m_palette[((pixels<<7)&0x80)];
}
}
break;
case 1: // 2 bpp
for (y = 0; y < 844; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 1152/4; x++)
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels&0xc0)];
*scanline++ = card->m_palette[((pixels<<2)&0xc0)];
*scanline++ = card->m_palette[((pixels<<4)&0xc0)];
*scanline++ = card->m_palette[((pixels<<6)&0xc0)];
}
}
break;
case 2: // 4 bpp
for (y = 0; y < 844; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 1152/2; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels&0xf0)];
*scanline++ = card->m_palette[((pixels<<4)&0xf0)];
}
}
break;
case 3: // 8 bpp
for (y = 0; y < 844; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 1152; x++)
{
pixels = vram[(y * 1152) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels];
}
}
break;
default:
fatalerror("specpdq: unknown video mode %d", card->m_mode);
break;
}
return 0;
}
static void machine_config_detokenize(machine_config *config, const machine_config_token *tokens, const device_config *owner, int depth)
{
UINT32 entrytype = MCONFIG_TOKEN_INVALID;
astring *tempstring = astring_alloc();
device_config *device = NULL;
/* loop over tokens until we hit the end */
while (entrytype != MCONFIG_TOKEN_END)
{
device_custom_config_func custom;
int size, offset, bits;
UINT32 data32, clock;
device_type devtype;
const char *tag;
UINT64 data64;
/* unpack the token from the first entry */
TOKEN_GET_UINT32_UNPACK1(tokens, entrytype, 8);
switch (entrytype)
{
/* end */
case MCONFIG_TOKEN_END:
break;
/* including */
case MCONFIG_TOKEN_INCLUDE:
machine_config_detokenize(config, TOKEN_GET_PTR(tokens, tokenptr), owner, depth + 1);
break;
/* device management */
case MCONFIG_TOKEN_DEVICE_ADD:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, clock, 32);
devtype = TOKEN_GET_PTR(tokens, devtype);
tag = TOKEN_GET_STRING(tokens);
device = device_list_add(&config->devicelist, owner, devtype, device_build_tag(tempstring, owner, tag), clock);
break;
case MCONFIG_TOKEN_DEVICE_REMOVE:
tag = TOKEN_GET_STRING(tokens);
remove_device(&config->devicelist, device_build_tag(tempstring, owner, tag));
device = NULL;
break;
case MCONFIG_TOKEN_DEVICE_MODIFY:
tag = TOKEN_GET_STRING(tokens);
device = (device_config *)device_list_find_by_tag(config->devicelist, device_build_tag(tempstring, owner, tag));
if (device == NULL)
fatalerror("Unable to find device: tag=%s\n", astring_c(tempstring));
break;
case MCONFIG_TOKEN_DEVICE_CLOCK:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, device->clock, 32);
break;
case MCONFIG_TOKEN_DEVICE_MAP:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, data32, 8);
device->address_map[data32] = TOKEN_GET_PTR(tokens, addrmap);
break;
case MCONFIG_TOKEN_DEVICE_CONFIG:
assert(device != NULL);
device->static_config = TOKEN_GET_PTR(tokens, voidptr);
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_1:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_2:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_3:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_4:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_5:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_6:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_7:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_8:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_9:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_FREE:
assert(device != NULL);
custom = (device_custom_config_func)devtype_get_info_fct(device->type, DEVINFO_FCT_CUSTOM_CONFIG);
assert(custom != NULL);
tokens = (*custom)(device, entrytype, tokens);
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA32:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 4, offset, 12);
data32 = TOKEN_GET_UINT32(tokens);
switch (size)
{
case 1: *(UINT8 *) ((UINT8 *)device->inline_config + offset) = data32; break;
case 2: *(UINT16 *)((UINT8 *)device->inline_config + offset) = data32; break;
case 4: *(UINT32 *)((UINT8 *)device->inline_config + offset) = data32; break;
}
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA64:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 4, offset, 12);
TOKEN_EXTRACT_UINT64(tokens, data64);
switch (size)
{
case 1: *(UINT8 *) ((UINT8 *)device->inline_config + offset) = data64; break;
case 2: *(UINT16 *)((UINT8 *)device->inline_config + offset) = data64; break;
case 4: *(UINT32 *)((UINT8 *)device->inline_config + offset) = data64; break;
case 8: *(UINT64 *)((UINT8 *)device->inline_config + offset) = data64; break;
}
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, size, 4, bits, 6, offset, 12);
data32 = TOKEN_GET_UINT32(tokens);
switch (size)
{
case 4: *(float *)((UINT8 *)device->inline_config + offset) = (float)(INT32)data32 / (float)(1 << bits); break;
case 8: *(double *)((UINT8 *)device->inline_config + offset) = (double)(INT32)data32 / (double)(1 << bits); break;
}
break;
/* core parameters */
case MCONFIG_TOKEN_DRIVER_DATA:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->driver_data_size, 24);
break;
case MCONFIG_TOKEN_QUANTUM_TIME:
TOKEN_EXTRACT_UINT64(tokens, data64);
config->minimum_quantum = UINT64_ATTOTIME_TO_ATTOTIME(data64);
break;
case MCONFIG_TOKEN_QUANTUM_PERFECT_CPU:
config->perfect_cpu_quantum = TOKEN_GET_STRING(tokens);
break;
case MCONFIG_TOKEN_WATCHDOG_VBLANK:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->watchdog_vblank_count, 24);
break;
case MCONFIG_TOKEN_WATCHDOG_TIME:
TOKEN_EXTRACT_UINT64(tokens, data64);
config->watchdog_time = UINT64_ATTOTIME_TO_ATTOTIME(data64);
break;
/* core functions */
case MCONFIG_TOKEN_MACHINE_START:
config->machine_start = TOKEN_GET_PTR(tokens, machine_start);
break;
case MCONFIG_TOKEN_MACHINE_RESET:
config->machine_reset = TOKEN_GET_PTR(tokens, machine_reset);
break;
case MCONFIG_TOKEN_NVRAM_HANDLER:
config->nvram_handler = TOKEN_GET_PTR(tokens, nvram_handler);
break;
case MCONFIG_TOKEN_MEMCARD_HANDLER:
config->memcard_handler = TOKEN_GET_PTR(tokens, memcard_handler);
break;
/* core video parameters */
case MCONFIG_TOKEN_VIDEO_ATTRIBUTES:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->video_attributes, 24);
break;
case MCONFIG_TOKEN_GFXDECODE:
config->gfxdecodeinfo = TOKEN_GET_PTR(tokens, gfxdecode);
break;
case MCONFIG_TOKEN_PALETTE_LENGTH:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->total_colors, 24);
break;
case MCONFIG_TOKEN_DEFAULT_LAYOUT:
config->default_layout = TOKEN_GET_STRING(tokens);
break;
/* core video functions */
case MCONFIG_TOKEN_PALETTE_INIT:
config->init_palette = TOKEN_GET_PTR(tokens, palette_init);
break;
case MCONFIG_TOKEN_VIDEO_START:
config->video_start = TOKEN_GET_PTR(tokens, video_start);
break;
case MCONFIG_TOKEN_VIDEO_RESET:
config->video_reset = TOKEN_GET_PTR(tokens, video_reset);
break;
case MCONFIG_TOKEN_VIDEO_EOF:
config->video_eof = TOKEN_GET_PTR(tokens, video_eof);
break;
case MCONFIG_TOKEN_VIDEO_UPDATE:
config->video_update = TOKEN_GET_PTR(tokens, video_update);
break;
/* core sound functions */
case MCONFIG_TOKEN_SOUND_START:
config->sound_start = TOKEN_GET_PTR(tokens, sound_start);
break;
case MCONFIG_TOKEN_SOUND_RESET:
config->sound_reset = TOKEN_GET_PTR(tokens, sound_reset);
break;
default:
fatalerror("Invalid token %d in machine config\n", entrytype);
break;
}
}
/* if we are the outermost level, process any device-specific machine configurations */
if (depth == 0)
for (device = config->devicelist; device != NULL; device = device->next)
{
tokens = (const machine_config_token *)device_get_info_ptr(device, DEVINFO_PTR_MACHINE_CONFIG);
if (tokens != NULL)
machine_config_detokenize(config, tokens, device, depth + 1);
}
astring_free(tempstring);
}
bool device_image_interface::load_internal(const char *path, bool is_create, int create_format, util::option_resolution *create_args, bool just_load)
{
UINT32 open_plan[4];
int i;
bool softload = FALSE;
m_from_swlist = FALSE;
// if the path contains no period, we are using softlists, so we won't create an image
std::string pathstr(path);
bool filename_has_period = (pathstr.find_last_of('.') != -1) ? TRUE : FALSE;
// first unload the image
unload();
// clear any possible error messages
clear_error();
// we are now loading
m_is_loading = TRUE;
// record the filename
m_err = set_image_filename(path);
if (m_err)
goto done;
if (core_opens_image_file())
{
// Check if there's a software list defined for this device and use that if we're not creating an image
if (!filename_has_period && !just_load)
{
softload = load_software_part(path, m_software_part_ptr);
if (softload)
{
m_software_info_ptr = &m_software_part_ptr->info();
m_software_list_name.assign(m_software_info_ptr->list().list_name());
m_full_software_name.assign(m_software_part_ptr->info().shortname());
// if we had launched from softlist with a specified part, e.g. "shortname:part"
// we would have recorded the wrong name, so record it again based on software_info
if (m_software_info_ptr && !m_full_software_name.empty())
m_err = set_image_filename(m_full_software_name.c_str());
// check if image should be read-only
const char *read_only = get_feature("read_only");
if (read_only && !strcmp(read_only, "true")) {
make_readonly();
}
m_from_swlist = TRUE;
}
}
if (is_create || filename_has_period)
{
// determine open plan
determine_open_plan(is_create, open_plan);
// attempt to open the file in various ways
for (i = 0; !m_file && open_plan[i]; i++)
{
// open the file
m_err = load_image_by_path(open_plan[i], path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
// Copy some image information when we have been loaded through a software list
if ( m_software_info_ptr )
{
// sanitize
if (m_software_info_ptr->longname().empty() || m_software_info_ptr->publisher().empty() || m_software_info_ptr->year().empty())
fatalerror("Each entry in an XML list must have all of the following fields: description, publisher, year!\n");
// store
m_longname = m_software_info_ptr->longname();
m_manufacturer = m_software_info_ptr->publisher();
m_year = m_software_info_ptr->year();
//m_playable = m_software_info_ptr->supported();
}
// did we fail to find the file?
if (!is_loaded() && !softload)
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
}
// call device load or create
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
m_err = (image_error_t)finish_load();
if (m_err)
goto done;
}
// success!
done:
if (just_load) {
if(m_err) clear();
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
if (m_err!=0) {
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
else
osd_printf_error("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if (device().machine().time() > attotime::zero && is_reset_on_load())
device().machine().schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
osd_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
void device_nubus_card_interface::install_declaration_rom(device_t *dev, const char *romregion, bool mirror_all_mb, bool reverse_rom)
{
bool inverted = false;
UINT8 *newrom = NULL;
astring tempstring;
UINT8 *rom = device().machine().root_device().memregion(dev->subtag(tempstring, romregion))->base();
UINT32 romlen = device().machine().root_device().memregion(dev->subtag(tempstring, romregion))->bytes();
// printf("ROM length is %x, last bytes are %02x %02x\n", romlen, rom[romlen-2], rom[romlen-1]);
if (reverse_rom)
{
UINT8 temp;
UINT32 endptr = romlen-1;
for (UINT32 idx = 0; idx < romlen / 2; idx++)
{
temp = rom[idx];
rom[idx] = rom[endptr];
rom[endptr] = temp;
endptr--;
}
}
UINT8 byteLanes = rom[romlen-1];
// check if all bits are inverted
if (rom[romlen-2] == 0xff)
{
byteLanes ^= 0xff;
inverted = true;
}
#if 0
FILE *f;
f = fopen("romout.bin", "wb");
fwrite(rom, romlen, 1, f);
fclose(f);
#endif
switch (byteLanes)
{
case 0x0f: // easy case: all 4 lanes (still must scramble for 32-bit BE bus though)
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen);
for (int i = 0; i < romlen; i++)
{
newrom[BYTE4_XOR_BE(i)] = rom[i];
}
break;
case 0xe1: // lane 0 only
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*4);
for (int i = 0; i < romlen; i++)
{
newrom[BYTE4_XOR_BE(i*4)] = rom[i];
}
romlen *= 4;
break;
case 0xd2: // lane 1 only
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*4);
for (int i = 0; i < romlen; i++)
{
newrom[BYTE4_XOR_BE((i*4)+1)] = rom[i];
}
romlen *= 4;
break;
case 0xb4: // lane 2 only
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*4);
for (int i = 0; i < romlen; i++)
{
newrom[BYTE4_XOR_BE((i*4)+2)] = rom[i];
}
romlen *= 4;
break;
case 0x78: // lane 3 only
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*4);
for (int i = 0; i < romlen; i++)
{
newrom[BYTE4_XOR_BE((i*4)+3)] = rom[i];
}
romlen *= 4;
break;
case 0xc3: // lanes 0, 1
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*2);
for (int i = 0; i < romlen/2; i++)
{
newrom[BYTE4_XOR_BE((i*4)+0)] = rom[(i*2)];
newrom[BYTE4_XOR_BE((i*4)+1)] = rom[(i*2)+1];
}
romlen *= 2;
break;
case 0xa5: // lanes 0, 2
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*2);
for (int i = 0; i < romlen/2; i++)
{
newrom[BYTE4_XOR_BE((i*4)+0)] = rom[(i*2)];
newrom[BYTE4_XOR_BE((i*4)+2)] = rom[(i*2)+1];
}
romlen *= 2;
break;
case 0x3c: // lanes 2,3
newrom = auto_alloc_array_clear(device().machine(), UINT8, romlen*2);
for (int i = 0; i < romlen/2; i++)
{
newrom[BYTE4_XOR_BE((i*4)+2)] = rom[(i*2)];
newrom[BYTE4_XOR_BE((i*4)+3)] = rom[(i*2)+1];
}
romlen *= 2;
break;
default:
fatalerror("NuBus: unhandled byteLanes value %02x\n", byteLanes);
break;
}
// the slot manager can supposedly handle inverted ROMs by itself, but let's do it for it anyway
if (inverted)
{
for (int i = 0; i < romlen; i++)
{
newrom[i] ^= 0xff;
}
}
// now install the ROM
UINT32 addr = get_slotspace() + 0x01000000;
char bankname[128];
strcpy(bankname, "rom_");
strcat(bankname, m_nubus_slottag);
addr -= romlen;
// printf("Installing ROM at %x, length %x\n", addr, romlen);
if (mirror_all_mb) // mirror the declaration ROM across all 16 megs of the slot space
{
m_nubus->install_bank(addr, addr+romlen-1, 0, 0x00f00000, bankname, newrom);
}
else
{
m_nubus->install_bank(addr, addr+romlen-1, 0, 0, bankname, newrom);
}
}
int main()
{
/* Variables */
int fd;
int stdout_fileno;
char *username;
char *home;
char *conf_file_name;
/* Initialize variables */
afterlist = ul_create(8);
beforelist = ul_create(8);
stdout_fileno = fileno(stdout);
/* Get our username */
struct passwd *p = getpwuid(getuid());
if(p == NULL)
fatalperror("getpwuid");
/* warning - username will now point to a static area, subsequent getpwuid calls may overwite it */
username = p->pw_name;
/* Get our home directory */
home = getenv("HOME");
if(home == NULL)
fatalerror("$HOME is not set.\n");
conf_file_name = malloc(strlen(home) + 1 + strlen(conf_file_basename) + 1);
strcpy(conf_file_name, home);
strcat(conf_file_name, "/");
strcat(conf_file_name, conf_file_basename);
/* Set up atexit */
atexit(free_mem_on_exit);
/* Read conf file */
config = load_config(conf_file_name);
/* If we are supposed to print a user list upon startup, do it now, before fork()ing */
if(config->initialshow)
{
struct userlist *ls = ul_create(8);
ul_populate(ls);
ul_sort(ls);
if(ls->array[0] == NULL)
{
printf("No users logged in.\n");
}
else
{
printf("Users logged in: ");
for(int i = 0; ls->array[i] != NULL; i++)
{
if(i > 0 && !strcmp(ls->array[i], ls->array[i-1]))
continue;
printf("%s, ", ls->array[i]);
}
printf("\b\b \n");
}
ul_free(ls);
}
/* If we aren't supposed to listen to INs *or* OUTs, no point in continuing */
if(!config->listen_ins && !config->listen_outs)
exit(EXIT_SUCCESS);
/* If we are forking, fork() and then exit the parent */
if(config->forking)
{
pid_t pid = fork();
if(pid > 0)
exit(0);
else if(pid == -1)
fatalperror("fork");
/* This setpgid() call changes the process-group ID so 'w' reports the shell (not us!) as the current command */
setpgid(getpid(),getpid());
/* Close stdin, and hang up the TTY, since we really can't access them from the "background" */
close(STDIN_FILENO);
vhangup();
}
/* Set up child-reaping for login-command */
signal(SIGCHLD, SIG_IGN);
/* Start and setup inotify */
fd = inotify_init();
if(fd < 0)
fatalperror("inotify_init");
if(inotify_add_watch(fd, _PATH_UTMP, IN_MODIFY) < 0)
fatalperror("inotify_add_watch");
while(1)
{
ul_populate(beforelist);
/* If we are fork()ing, we want to monitor stdout, which requires us to use select() with a timeout */
if(config->forking)
{
watch_and_wait(fd, stdout_fileno);
}
struct inotify_event evt;
if(read(fd, &evt, sizeof(struct inotify_event)) < 0)
fatalperror("read");
ul_populate(afterlist);
int firstlen = ul_count(beforelist);
int secondlen = ul_count(afterlist);
if(firstlen == secondlen)
{
continue;
}
else if(firstlen > secondlen)
{
char *r = ul_subtract(beforelist, afterlist);
if(r == NULL)
continue;
if(!strcmp(r, username))
continue;
if(config->listen_outs)
on_logout(r);
}
else
{
char *r = ul_subtract(afterlist, beforelist);
if(r == NULL)
continue;
if(!strcmp(r, username))
continue;
if(config->listen_ins)
on_login(r);
}
if(config->oneshot)
{
exit(0);
}
}
exit(SUCCESS);
}
UINT32 nubus_cb264_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline, *base;
int x, y;
UINT8 pixels;
if (!m_cb264_vbl_disable)
{
raise_slot_irq();
}
switch (m_cb264_mode)
{
case 0: // 1 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/8; x++)
{
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels&0x80];
*scanline++ = m_palette[(pixels<<1)&0x80];
*scanline++ = m_palette[(pixels<<2)&0x80];
*scanline++ = m_palette[(pixels<<3)&0x80];
*scanline++ = m_palette[(pixels<<4)&0x80];
*scanline++ = m_palette[(pixels<<5)&0x80];
*scanline++ = m_palette[(pixels<<6)&0x80];
*scanline++ = m_palette[(pixels<<7)&0x80];
}
}
break;
case 1: // 2 bpp (3f/7f/bf/ff)
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/4; x++)
{
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels&0xc0];
*scanline++ = m_palette[(pixels<<2)&0xc0];
*scanline++ = m_palette[(pixels<<4)&0xc0];
*scanline++ = m_palette[(pixels<<6)&0xc0];
}
}
break;
case 2: // 4 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/2; x++)
{
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels&0xf0];
*scanline++ = m_palette[(pixels<<4)&0xf0];
}
}
break;
case 3: // 8 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640; x++)
{
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels];
}
}
break;
case 4: // 24 bpp
case 7: // ???
{
UINT32 *vram32 = (UINT32 *)&m_vram[0];
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
base = &vram32[y * 1024];
for (x = 0; x < 640; x++)
{
*scanline++ = *base++;
}
}
}
break;
default:
fatalerror("cb264: unknown video mode %d\n", m_cb264_mode);
}
return 0;
}
UINT32 nubus_procolor816_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
UINT8 pixels, *vram;
vram = m_vram + 4;
switch (m_mode)
{
case 0: // 1 bpp?
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/8; x++)
{
pixels = vram[(y * 640/8) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0x80)];
*scanline++ = m_palette[((pixels<<1)&0x80)];
*scanline++ = m_palette[((pixels<<2)&0x80)];
*scanline++ = m_palette[((pixels<<3)&0x80)];
*scanline++ = m_palette[((pixels<<4)&0x80)];
*scanline++ = m_palette[((pixels<<5)&0x80)];
*scanline++ = m_palette[((pixels<<6)&0x80)];
*scanline++ = m_palette[((pixels<<7)&0x80)];
}
}
break;
case 1: // 2 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/4; x++)
{
pixels = vram[(y * 640/4) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0xc0)];
*scanline++ = m_palette[((pixels<<2)&0xc0)];
*scanline++ = m_palette[((pixels<<4)&0xc0)];
*scanline++ = m_palette[((pixels<<6)&0xc0)];
}
}
break;
case 2: // 4 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/2; x++)
{
pixels = vram[(y * 640/2) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[(pixels&0xf0)];
*scanline++ = m_palette[((pixels&0x0f)<<4)];
}
}
break;
case 3: // 8 bpp
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640; x++)
{
pixels = vram[(y * 640) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels];
}
}
break;
case 4: // 15 bpp
{
UINT16 *vram16 = (UINT16 *)m_vram;
UINT16 pixels;
for (y = 0; y < 480; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < 640; x++)
{
pixels = vram16[(y * 640) + (x^1)];
*scanline++ = MAKE_RGB(((pixels>>10) & 0x1f)<<3, ((pixels>>5) & 0x1f)<<3, (pixels & 0x1f)<<3);
}
}
}
break;
default:
fatalerror("procolor816: unknown video mode %d\n", m_mode);
break;
}
return 0;
}
void tms32010_device::opcodes_7F() { fatalerror("Should never get here!\n"); }
void device_nubus_card_interface::install_declaration_rom(device_t *dev, const char *romregion, bool mirror_all_mb, bool reverse_rom)
{
bool inverted = false;
uint8_t *rom = device().machine().root_device().memregion(dev->subtag(romregion).c_str())->base();
uint32_t romlen = device().machine().root_device().memregion(dev->subtag(romregion).c_str())->bytes();
// printf("ROM length is %x, last bytes are %02x %02x\n", romlen, rom[romlen-2], rom[romlen-1]);
if (reverse_rom)
{
uint8_t temp;
uint32_t endptr = romlen-1;
for (uint32_t idx = 0; idx < romlen / 2; idx++)
{
temp = rom[idx];
rom[idx] = rom[endptr];
rom[endptr] = temp;
endptr--;
}
}
uint8_t byteLanes = rom[romlen-1];
// check if all bits are inverted
if (rom[romlen-2] == 0xff)
{
byteLanes ^= 0xff;
inverted = true;
}
#if 0
FILE *f;
f = fopen("romout.bin", "wb");
fwrite(rom, romlen, 1, f);
fclose(f);
#endif
switch (byteLanes)
{
case 0x0f: // easy case: all 4 lanes (still must scramble for 32-bit BE bus though)
m_declaration_rom.resize(romlen);
for (int i = 0; i < romlen; i++)
{
m_declaration_rom[BYTE4_XOR_BE(i)] = rom[i];
}
break;
case 0xe1: // lane 0 only
m_declaration_rom.resize(romlen*4);
memset(&m_declaration_rom[0], 0, romlen*4);
for (int i = 0; i < romlen; i++)
{
m_declaration_rom[BYTE4_XOR_BE(i*4)] = rom[i];
}
romlen *= 4;
break;
case 0xd2: // lane 1 only
m_declaration_rom.resize(romlen*4);
memset(&m_declaration_rom[0], 0, romlen*4);
for (int i = 0; i < romlen; i++)
{
m_declaration_rom[BYTE4_XOR_BE((i*4)+1)] = rom[i];
}
romlen *= 4;
break;
case 0xb4: // lane 2 only
m_declaration_rom.resize(romlen*4);
memset(&m_declaration_rom[0], 0, romlen*4);
for (int i = 0; i < romlen; i++)
{
m_declaration_rom[BYTE4_XOR_BE((i*4)+2)] = rom[i];
}
romlen *= 4;
break;
case 0x78: // lane 3 only
m_declaration_rom.resize(romlen*4);
memset(&m_declaration_rom[0], 0, romlen*4);
for (int i = 0; i < romlen; i++)
{
m_declaration_rom[BYTE4_XOR_BE((i*4)+3)] = rom[i];
}
romlen *= 4;
break;
case 0xc3: // lanes 0, 1
m_declaration_rom.resize(romlen*2);
memset(&m_declaration_rom[0], 0, romlen*2);
for (int i = 0; i < romlen/2; i++)
{
m_declaration_rom[BYTE4_XOR_BE((i*4)+0)] = rom[(i*2)];
m_declaration_rom[BYTE4_XOR_BE((i*4)+1)] = rom[(i*2)+1];
}
romlen *= 2;
break;
case 0xa5: // lanes 0, 2
m_declaration_rom.resize(romlen*2);
memset(&m_declaration_rom[0], 0, romlen*2);
for (int i = 0; i < romlen/2; i++)
{
m_declaration_rom[BYTE4_XOR_BE((i*4)+0)] = rom[(i*2)];
m_declaration_rom[BYTE4_XOR_BE((i*4)+2)] = rom[(i*2)+1];
}
romlen *= 2;
break;
case 0x3c: // lanes 2,3
m_declaration_rom.resize(romlen*2);
memset(&m_declaration_rom[0], 0, romlen*2);
for (int i = 0; i < romlen/2; i++)
{
m_declaration_rom[BYTE4_XOR_BE((i*4)+2)] = rom[(i*2)];
m_declaration_rom[BYTE4_XOR_BE((i*4)+3)] = rom[(i*2)+1];
}
romlen *= 2;
break;
default:
fatalerror("NuBus: unhandled byteLanes value %02x\n", byteLanes);
}
// the slot manager can supposedly handle inverted ROMs by itself, but let's do it for it anyway
if (inverted)
{
for (int i = 0; i < romlen; i++)
{
m_declaration_rom[i] ^= 0xff;
}
}
// now install the ROM
uint32_t addr = get_slotspace() + 0x01000000;
char bankname[128];
strcpy(bankname, "rom_");
strcat(bankname, m_nubus_slottag);
addr -= romlen;
// printf("Installing ROM at %x, length %x\n", addr, romlen);
if (mirror_all_mb) // mirror the declaration ROM across all 16 megs of the slot space
{
uint32_t off = 0;
while(off < 0x1000000) {
nubus().install_bank(addr + off, addr+off+romlen-1, bankname, &m_declaration_rom[0]);
off += romlen;
}
}
else
{
nubus().install_bank(addr, addr+romlen-1, bankname, &m_declaration_rom[0]);
}
}
int i8257_device::i8257_do_operation(int channel)
{
int done;
UINT8 data;
UINT8 mode = m_rwmode[channel];
if (m_count[channel] == 0x0000)
{
m_status |= (0x01 << channel);
m_out_tc_func(ASSERT_LINE);
}
switch(mode) {
case 1:
if (!m_in_memr_func.isnull())
{
data = m_in_memr_func(m_address[channel]);
}
else
{
data = 0;
logerror("8257: No memory read function defined.\n");
}
if (!m_out_iow_func[channel].isnull())
{
m_out_iow_func[channel](m_address[channel], data);
}
else
{
logerror("8257: No channel write function for channel %d defined.\n",channel);
}
m_address[channel]++;
m_count[channel]--;
done = (m_count[channel] == 0xFFFF);
break;
case 2:
if (!m_in_ior_func[channel].isnull())
{
data = m_in_ior_func[channel](m_address[channel]);
}
else
{
data = 0;
logerror("8257: No channel read function for channel %d defined.\n",channel);
}
if (!m_out_memw_func.isnull())
{
m_out_memw_func(m_address[channel], data);
}
else
{
logerror("8257: No memory write function defined.\n");
}
m_address[channel]++;
m_count[channel]--;
done = (m_count[channel] == 0xFFFF);
break;
case 0: /* verify */
m_address[channel]++;
m_count[channel]--;
done = (m_count[channel] == 0xFFFF);
break;
default:
fatalerror("i8257_do_operation: invalid mode!\n");
break;
}
if (done)
{
if ((channel==2) && DMA_MODE_AUTOLOAD(m_mode))
{
/* in case of autoload at the end channel 3 info is */
/* copied to channel 2 info */
m_registers[4] = m_registers[6];
m_registers[5] = m_registers[7];
}
m_out_tc_func(CLEAR_LINE);
}
return done;
}
static UINT32 bam2Error3(void)
{
fatalerror("CPU - BAM2 - 3 (PC=%06x)", PC);
return 0; /* never reached, fatalerror won't return */
}
static void cirrus_update_24bpp(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
fatalerror("NYI");
}
