static bool kernel_data_init(void)
{
char str[256];
SYSTEM_INFO si;
GetSystemInfo(&si);
allocation_granule = si.dwAllocationGranularity;
kernel_area_size = (KERNEL_AREA_SIZE + allocation_granule - 1) & -allocation_granule;
char rcs[10];
LPVOID kernel_addr;
kernel_handle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, kernel_area_size, NULL);
if (kernel_handle == NULL) {
sprintf(rcs, "%d", GetLastError());
sprintf(str, GetString(STR_KD_SHMGET_ERR), rcs);
ErrorAlert(str);
return false;
}
kernel_addr = (LPVOID)Mac2HostAddr(KERNEL_DATA_BASE & -allocation_granule);
if (MapViewOfFileEx(kernel_handle, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, kernel_area_size, kernel_addr) != kernel_addr) {
sprintf(rcs, "%d", GetLastError());
sprintf(str, GetString(STR_KD_SHMAT_ERR), rcs);
ErrorAlert(str);
return false;
}
kernel_addr = (LPVOID)Mac2HostAddr(KERNEL_DATA2_BASE & -allocation_granule);
if (MapViewOfFileEx(kernel_handle, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, kernel_area_size, kernel_addr) != kernel_addr) {
sprintf(rcs, "%d", GetLastError());
sprintf(str, GetString(STR_KD2_SHMAT_ERR), rcs);
ErrorAlert(str);
return false;
}
return true;
}
static bool load_sockets()
{
bool result = false;
hWinsock32 = LoadLibrary( wslib );
if(!hWinsock32) {
ErrorAlert("Could not load Winsock libraries; router module is not available. Please install Windows sockets 2.");
} else {
_WSAStartup = (int (WSAAPI *)(WORD, LPWSADATA))GetProcAddress( hWinsock32, "WSAStartup" );
_WSACleanup = (int (WSAAPI *)(void))GetProcAddress( hWinsock32, "WSACleanup" );
_gethostname = (int (WSAAPI *)(char *, int))GetProcAddress( hWinsock32, "gethostname" );
_inet_ntoa = (char * (WSAAPI *)(struct in_addr))GetProcAddress( hWinsock32, "inet_ntoa" );
_gethostbyname = (struct hostent * (WSAAPI *)(const char *))GetProcAddress( hWinsock32, "gethostbyname" );
_send = (int (WSAAPI *)(SOCKET, const char *, int, int))GetProcAddress( hWinsock32, "send" );
_sendto = (int (WSAAPI *)(SOCKET, const char *, int, int, const struct sockaddr *, int))GetProcAddress( hWinsock32, "sendto" );
_recv = (int (WSAAPI *)(SOCKET, char *, int, int))GetProcAddress( hWinsock32, "recv" );
_recvfrom = (int (WSAAPI *)(SOCKET, char *, int, int, struct sockaddr *, int *))GetProcAddress( hWinsock32, "recvfrom" );
_listen = (int (WSAAPI *)(SOCKET, int))GetProcAddress( hWinsock32, "listen" );
_accept = (SOCKET (WSAAPI *)(SOCKET, struct sockaddr *, int *))GetProcAddress( hWinsock32, "accept" );
_socket = (SOCKET (WSAAPI *)(int, int, int))GetProcAddress( hWinsock32, "socket" );
_bind = (int (WSAAPI *)(SOCKET, const struct sockaddr *, int))GetProcAddress( hWinsock32, "bind" );
_WSAAsyncSelect = (int (WSAAPI *)(SOCKET, HWND, u_int, long))GetProcAddress( hWinsock32, "WSAAsyncSelect" );
_closesocket = (int (WSAAPI *)(SOCKET))GetProcAddress( hWinsock32, "closesocket" );
_getsockname = (int (WSAAPI *)(SOCKET, struct sockaddr *, int *))GetProcAddress( hWinsock32, "getsockname" );
_WSARecvFrom = (int (WSAAPI *)(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, struct sockaddr *, LPINT, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE))GetProcAddress( hWinsock32, "WSARecvFrom" );
_WSAGetLastError = (int (WSAAPI *)(void))GetProcAddress( hWinsock32, "WSAGetLastError" );
_WSAConnect = (int (WSAAPI *)(SOCKET, const struct sockaddr *, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS))GetProcAddress( hWinsock32, "WSAConnect" );
_setsockopt = (int (WSAAPI *)(SOCKET, int, int, const char *, int))GetProcAddress( hWinsock32, "setsockopt" );
_WSAEventSelect = (int (WSAAPI *)(SOCKET, WSAEVENT, long))GetProcAddress( hWinsock32, "WSAEventSelect" );
_WSACreateEvent = (WSAEVENT (WSAAPI *)(void))GetProcAddress( hWinsock32, "WSACreateEvent" );
_WSACloseEvent = (BOOL (WSAAPI *)(WSAEVENT))GetProcAddress( hWinsock32, "WSACloseEvent" );
_WSAResetEvent = (BOOL (WSAAPI *)(WSAEVENT))GetProcAddress( hWinsock32, "WSAResetEvent" );
_WSAEnumNetworkEvents = (BOOL (WSAAPI *)(SOCKET, WSAEVENT, LPWSANETWORKEVENTS))GetProcAddress( hWinsock32, "WSAEnumNetworkEvents" );
_shutdown = (int (WSAAPI *)(SOCKET, int))GetProcAddress( hWinsock32, "shutdown" );
_WSASend = (int (WSAAPI *)(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE))GetProcAddress( hWinsock32, "WSASend" );
_WSARecv = (int (WSAAPI *)(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE))GetProcAddress( hWinsock32, "WSARecv" );
_inet_addr = (unsigned long (WSAAPI *)(const char *))GetProcAddress( hWinsock32, "inet_addr" );
if( _WSAStartup && _WSACleanup && _gethostname && _inet_ntoa && _gethostbyname &&
_send && _sendto && _recv && _recvfrom && _listen && _accept && _socket && _bind &&
_WSAAsyncSelect && _closesocket && _getsockname && _WSARecvFrom && _WSAGetLastError &&
_WSAConnect && _setsockopt && _WSAEventSelect && _WSACreateEvent && _WSACloseEvent &&
_WSAResetEvent && _WSAEnumNetworkEvents && _shutdown && _WSASend && _WSARecv && _inet_addr
)
{
result = true;
} else {
ErrorAlert("Could not find required entry points; router module is not available. Please install Windows sockets 2.");
}
}
return result;
}
bool BeOS_monitor_desc::video_open() {
// Create semaphore
mac_os_lock = create_sem(0, "MacOS Frame Buffer Lock");
const video_mode &mode = get_current_mode();
// Open display
switch (display_type) {
case DISPLAY_WINDOW:
the_window = new MacWindow(BRect(0, 0, mode.x-1, mode.y-1), *this);
break;
case DISPLAY_SCREEN: {
status_t screen_error;
the_screen = new MacScreen(*this, GetString(STR_WINDOW_TITLE), scr_mode_bit & 0x1f, &screen_error);
if (screen_error != B_NO_ERROR) {
the_screen->PostMessage(B_QUIT_REQUESTED);
while (the_screen)
snooze(200000);
ErrorAlert(STR_OPEN_SCREEN_ERR);
return false;
} else {
the_screen->Show();
acquire_sem(mac_os_lock);
}
break;
}
}
return true;
}
/* VDTGetOpenAndCheckOperationsPortPtr(ppp, setTerminalPortOffLineIfConflict, displayDialogIfPortSelectedButNotOpenable)
This is called when we are about to attempt to use the operations port.
If no operations port is selected, it displays a dialog (if requested) returns NULL via ppp.
Otherwise, if the operations port is closed, it tries to open it. If this
results in an error it displays a dialog (if requested) and returns NULL via ppp.
If the port was open already or was successfully opened here, it returns
a non-NULL VDTPortPtr via ppp.
If there are no errors and if setTerminalPortOffLineIfConflict is true and if the
terminal port is the same as the operations port, it sets the terminal port to
"Off Line".
The function result is 0 if OK or an error code.
*/
int
VDTGetOpenAndCheckOperationsPortPtr(VDTPortPtr* ppp, int setTerminalPortOffLineIfConflict, int displayDialogIfPortSelectedButNotOpenable)
{
VDTPortPtr op;
int err;
*ppp = NULL;
op = VDTGetOperationsPortPtr();
if (op == NULL) {
if (displayDialogIfPortSelectedButNotOpenable)
ErrorAlert(VDT_ERR_NO_OPERATIONS_PORT_SELECTED);
return VDT_ERR_NO_OPERATIONS_PORT_SELECTED;
}
if (VDTPortIsOpen(op)) {
*ppp = op;
if (setTerminalPortOffLineIfConflict)
SetTerminalPortOffLineIfConflict();
return 0;
}
err = OpenVDTPort(op->name, ppp);
if (err == 0) {
if (setTerminalPortOffLineIfConflict)
SetTerminalPortOffLineIfConflict();
return 0;
}
*ppp = NULL; // Port can't be opened.
if (displayDialogIfPortSelectedButNotOpenable)
ErrorAlert(err);
return err;
}
bool dynsockets_init(void)
{
bool result = false;
if(load_sockets()) {
if( (_WSAStartup(MAKEWORD(2,0), &WSAData)) != 0 ||
LOBYTE( WSAData.wVersion ) != 2 ||
HIBYTE( WSAData.wVersion ) != 0 )
{
ErrorAlert("Could not start Windows sockets version 2.");
} else {
result = true;
}
}
return result;
}
static void extfs_log_open( char *path )
{
if(debug_extfs == DB_EXTFS_NONE) return;
DeleteFile( path );
extfs_log_file = CreateFile(
path,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
// FILE_FLAG_WRITE_THROUGH|FILE_FLAG_NO_BUFFERING,
FILE_FLAG_WRITE_THROUGH,
NULL
);
if( extfs_log_file == INVALID_HANDLE_VALUE ) {
ErrorAlert( "Could not create the EXTFS log file." );
}
}
static void extfs_log_write( char *s )
{
DWORD bytes_written;
// should have been checked already.
if(debug_extfs == DB_EXTFS_NONE) return;
if( extfs_log_file != INVALID_HANDLE_VALUE ) {
DWORD count = strlen(s);
if (0 == WriteFile(extfs_log_file, s, count, &bytes_written, NULL) ||
(int)bytes_written != count)
{
extfs_log_close();
ErrorAlert( "extfs log file write error (out of disk space?). Log closed." );
} else {
FlushFileBuffers( extfs_log_file );
}
}
}
// !!UNC
void init_posix_emu(void)
{
if(!validate_stat_struct) {
ErrorAlert( "Invalid struct my_stat -- edit posix_emu.h" );
QuitEmulator();
}
#if DEBUG_EXTFS
debug_extfs = PrefsFindInt16("debugextfs");
debug_extfs = DB_EXTFS_LOUD;
if(debug_extfs != DB_EXTFS_NONE) {
extfs_log_open( EXTFS_LOG_FILE_NAME );
}
#endif
// We cannot use ExtFS "RootPath" because of the virtual desktop.
if(PrefsFindBool("enableextfs")) {
PrefsReplaceString("extfs", "");
} else {
PrefsRemoveItem("extfs");
D(bug("extfs disabled by user\n"));
#if DEBUG_EXTFS
extfs_log_close();
#endif
return;
}
const char *extdrives = PrefsFindString("extdrives");
// Set up drive list.
size_t outinx = 0;
for( TCHAR letter = TEXT('A'); letter <= TEXT('Z'); letter++ ) {
if(extdrives && !strchr(extdrives,letter)) continue;
TCHAR rootdir[20];
_sntprintf( rootdir, lengthof(rootdir), TEXT("%c:\\"), letter );
use_streams[ letter - 'A' ] = false;
switch(GetDriveType(rootdir)) {
case DRIVE_FIXED:
case DRIVE_REMOTE:
case DRIVE_RAMDISK:
// TODO: NTFS AFP?
// fall
case DRIVE_REMOVABLE:
case DRIVE_CDROM:
if(outinx < lengthof(host_drive_list)) {
host_drive_list[outinx] = letter;
outinx += 2;
}
}
}
// Set up virtual desktop root.
// TODO: this should be customizable.
GetModuleFileName( NULL, virtual_root, lengthof(virtual_root) );
TCHAR *p = _tcsrchr( virtual_root, TEXT('\\') );
if(p) {
_tcscpy( ++p, desktop_name );
} else {
// should never happen
_sntprintf( virtual_root, lengthof(virtual_root), TEXT("C:\\%s"), desktop_name );
}
CreateDirectory( virtual_root, 0 );
// Set up an icon looking like "My Computer"
// Can be overwritten just like any other folder custom icon.
if(my_access(custom_icon_name,0) != 0) {
int fd = my_creat( custom_icon_name, 0 );
if(fd >= 0) {
my_close(fd);
fd = open_rfork( custom_icon_name, O_RDWR|O_CREAT );
if(fd >= 0) {
my_write( fd, my_comp_icon, sizeof(my_comp_icon) );
my_close(fd);
static uint8 host_finfo[SIZEOF_FInfo];
uint32 finfo = Host2MacAddr(host_finfo);
get_finfo(custom_icon_name, finfo, 0, false);
WriteMacInt16(finfo + fdFlags, kIsInvisible);
set_finfo(custom_icon_name, finfo, 0, false);
get_finfo(my_computer, finfo, 0, true);
WriteMacInt16(finfo + fdFlags, ReadMacInt16(finfo + fdFlags) | kHasCustomIcon);
set_finfo(my_computer, finfo, 0, true);
} else {
my_remove(custom_icon_name);
}
}
}
}
void SCSIInit(void)
{
int id, lun;
int memtype = PrefsFindInt32("scsimemtype");
switch (memtype) {
case 1:
buffer_memf = MEMF_24BITDMA | MEMF_PUBLIC;
break;
case 2:
buffer_memf = MEMF_ANY | MEMF_PUBLIC;
direct_transfers_supported = true;
break;
default:
buffer_memf = MEMF_CHIP | MEMF_PUBLIC;
break;
}
// Create port and buffers
the_port = CreateMsgPort();
buffer = (UBYTE *)AllocMem(buffer_size = 0x10000, buffer_memf);
sense_buffer = (UBYTE *)AllocMem(SENSE_LENGTH, MEMF_CHIP | MEMF_PUBLIC);
if (the_port == NULL || buffer == NULL || sense_buffer == NULL) {
ErrorAlert(STR_NO_MEM_ERR);
QuitEmulator();
}
// Create and open IORequests for all 8 units (and all 8 LUNs)
for (id=0; id<8; id++) {
for (lun=0; lun<8; lun++)
ios[id*8+lun] = NULL;
char prefs_name[16];
sprintf(prefs_name, "scsi%d", id);
const char *str = PrefsFindString(prefs_name);
if (str) {
char dev_name[256];
ULONG dev_unit = 0;
if (sscanf(str, "%[^/]/%ld", dev_name, &dev_unit) == 2) {
for (lun=0; lun<8; lun++) {
struct IOStdReq *io = (struct IOStdReq *)CreateIORequest(the_port, sizeof(struct IOStdReq));
if (io == NULL)
continue;
if (OpenDevice((UBYTE *) dev_name, dev_unit + lun * 10, (struct IORequest *)io, 0)) {
DeleteIORequest(io);
continue;
}
io->io_Data = &scsi;
io->io_Length = sizeof(scsi);
io->io_Command = HD_SCSICMD;
ios[id*8+lun] = io;
}
}
}
}
// Reset SCSI bus
SCSIReset();
// Init SCSICmd
memset(&scsi, 0, sizeof(scsi));
scsi.scsi_Command = cmd_buffer;
scsi.scsi_SenseData = sense_buffer;
scsi.scsi_SenseLength = SENSE_LENGTH;
}
int main(int argc, char **argv)
{
char str[256];
int16 i16;
HANDLE rom_fh;
const char *rom_path;
uint32 rom_size;
DWORD actual;
uint8 *rom_tmp;
// Initialize variables
RAMBase = 0;
// Print some info
printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
printf(" %s\n", GetString(STR_ABOUT_TEXT2));
// Read preferences
PrefsInit(NULL, argc, argv);
// Parse command line arguments
for (int i=1; i<argc; i++) {
if (strcmp(argv[i], "--help") == 0) {
usage(argv[0]);
} else if (argv[i][0] == '-') {
fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
usage(argv[0]);
}
}
// Check we are using a Windows NT kernel >= 4.0
OSVERSIONINFO osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&osvi)) {
ErrorAlert("Could not determine OS type");
QuitEmulator();
}
win_os = osvi.dwPlatformId;
win_os_major = osvi.dwMajorVersion;
if (win_os != VER_PLATFORM_WIN32_NT || win_os_major < 4) {
ErrorAlert(GetString(STR_NO_WIN32_NT_4));
QuitEmulator();
}
// Check that drivers are installed
if (!check_drivers())
QuitEmulator();
// Load win32 libraries
KernelInit();
// FIXME: default to DIB driver
if (getenv("SDL_VIDEODRIVER") == NULL)
putenv("SDL_VIDEODRIVER=windib");
// Initialize SDL system
int sdl_flags = 0;
#ifdef USE_SDL_VIDEO
sdl_flags |= SDL_INIT_VIDEO;
#endif
#ifdef USE_SDL_AUDIO
sdl_flags |= SDL_INIT_AUDIO;
#endif
assert(sdl_flags != 0);
if (SDL_Init(sdl_flags) == -1) {
char str[256];
sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
ErrorAlert(str);
goto quit;
}
atexit(SDL_Quit);
#ifdef ENABLE_MON
// Initialize mon
mon_init();
#endif
// Install SIGSEGV handler for CPU emulator
if (!sigsegv_install_handler(sigsegv_handler)) {
sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
// Initialize VM system
vm_init();
// Get system info
PVR = 0x00040000; // Default: 604
CPUClockSpeed = 100000000; // Default: 100MHz
BusClockSpeed = 100000000; // Default: 100MHz
TimebaseSpeed = 25000000; // Default: 25MHz
PVR = 0x000c0000; // Default: 7400 (with AltiVec)
D(bug("PVR: %08x (assumed)\n", PVR));
// Init system routines
SysInit();
// Show preferences editor
if (!PrefsFindBool("nogui"))
if (!PrefsEditor())
goto quit;
// Create areas for Kernel Data
if (!kernel_data_init())
goto quit;
kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE);
emulator_data = &kernel_data->ed;
KernelDataAddr = KERNEL_DATA_BASE;
D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE));
D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
// Create area for DR Cache
if (vm_mac_acquire(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
dr_emulator_area_mapped = true;
if (vm_mac_acquire(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
dr_cache_area_mapped = true;
DRCacheAddr = (uint32)Mac2HostAddr(DR_CACHE_BASE);
D(bug("DR Cache at %p (%08x)\n", DRCacheAddr, DR_CACHE_BASE));
// Create area for SheepShaver data
if (!SheepMem::Init()) {
sprintf(str, GetString(STR_SHEEP_MEM_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
// Create area for Mac ROM
if (vm_mac_acquire(ROM_BASE, ROM_AREA_SIZE) < 0) {
sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
ROMBase = ROM_BASE;
ROMBaseHost = Mac2HostAddr(ROMBase);
rom_area_mapped = true;
D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase));
// Create area for Mac RAM
RAMSize = PrefsFindInt32("ramsize");
if (RAMSize < 8*1024*1024) {
WarningAlert(GetString(STR_SMALL_RAM_WARN));
RAMSize = 8*1024*1024;
}
RAMBase = 0;
if (vm_mac_acquire(RAMBase, RAMSize) < 0) {
sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
RAMBaseHost = Mac2HostAddr(RAMBase);
ram_area_mapped = true;
D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
if (RAMBase > ROMBase) {
ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
goto quit;
}
// Load Mac ROM
rom_path = PrefsFindString("rom");
rom_fh = CreateFile(rom_path && *rom_path ? rom_path : ROM_FILE_NAME,
GENERIC_READ, 0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (rom_fh == INVALID_HANDLE_VALUE) {
rom_fh = CreateFile(ROM_FILE_NAME2,
GENERIC_READ, 0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (rom_fh == INVALID_HANDLE_VALUE) {
ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
goto quit;
}
}
printf(GetString(STR_READING_ROM_FILE));
rom_size = GetFileSize(rom_fh, NULL);
rom_tmp = new uint8[ROM_SIZE];
ReadFile(rom_fh, (void *)rom_tmp, ROM_SIZE, &actual, NULL);
CloseHandle(rom_fh);
// Decode Mac ROM
if (!DecodeROM(rom_tmp, actual)) {
if (rom_size != 4*1024*1024) {
ErrorAlert(GetString(STR_ROM_SIZE_ERR));
goto quit;
} else {
ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
goto quit;
}
}
delete[] rom_tmp;
// Initialize native timers
timer_init();
// Initialize everything
if (!InitAll(NULL))
goto quit;
D(bug("Initialization complete\n"));
// Write protect ROM
vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ);
// Start 60Hz thread
tick_thread_cancel = false;
tick_thread_active = ((tick_thread = create_thread(tick_func)) != NULL);
SetThreadPriority(tick_thread, THREAD_PRIORITY_ABOVE_NORMAL);
D(bug("Tick thread installed (%ld)\n", tick_thread));
// Start NVRAM watchdog thread
memcpy(last_xpram, XPRAM, XPRAM_SIZE);
nvram_thread_cancel = false;
nvram_thread_active = ((nvram_thread = create_thread(nvram_func, NULL)) != NULL);
SetThreadPriority(nvram_thread, THREAD_PRIORITY_BELOW_NORMAL);
D(bug("NVRAM thread installed (%ld)\n", nvram_thread));
// Get my thread ID and jump to ROM boot routine
emul_thread = GetCurrentThread();
D(bug("Jumping to ROM\n"));
#ifdef _MSC_VER
__try {
#endif
jump_to_rom(ROMBase + 0x310000);
#ifdef _MSC_VER
} __except (main_exception_filter(GetExceptionInformation())) {}
#endif
D(bug("Returned from ROM\n"));
quit:
Quit();
return 0;
}
bool TMovieCue::InitVideoCodec()
{
if (m_Reader->HasVideo() == false)
return false;
m_VideoCodec = NULL;
// Get video header to determine compression type
AVIVIDSHeader *vidsHeader = m_Reader->GetVIDSHeader();
// Determine compression and create codec
switch(vidsHeader->Compression)
{
// Uncompressed RGB
case RIFF_RGB:
case RIFF_rgb:
m_VideoCodec = new TRGBCodec(m_Reader);
break;
// Apple Video "Road Pizza"
case RIFF_rpza:
case RIFF_azpr:
m_VideoCodec = new TAppleVideoCodec(m_Reader);
break;
// Microsoft Video 01
case RIFF_wham:
case RIFF_WHAM:
case RIFF_cram:
case RIFF_CRAM:
case kRiff_msvc_Chunk:
case kRiff_MSVC_Chunk:
m_VideoCodec = new TMSVideoCodec(m_Reader);
break;
// Microsoft RLE
case RIFF_RLE8:
case RIFF_rle8:
m_VideoCodec = new TMSRLECodec(m_Reader);
break;
// Radius Cinepak "Compact Video"
case RIFF_cvid:
case RIFF_CVID:
m_VideoCodec = new TCinepakCodec(m_Reader);
break;
default:
ErrorAlert("Unhandled CODEC.");
#ifdef DEBUG
printf("Unhandled CODEC: ");
DumpRIFFID(vidsHeader->Compression);
#endif
return false;
break;
}
if (m_VideoCodec)
return true;
else
return false;
}
bool InitAll(const char *vmdir)
{
// Check ROM version
if (!CheckROM()) {
ErrorAlert(STR_UNSUPPORTED_ROM_TYPE_ERR);
return false;
}
#if EMULATED_68K
// Set CPU and FPU type (UAE emulation)
switch (ROMVersion) {
case ROM_VERSION_64K:
case ROM_VERSION_PLUS:
case ROM_VERSION_CLASSIC:
CPUType = 0;
FPUType = 0;
TwentyFourBitAddressing = true;
break;
case ROM_VERSION_II:
CPUType = PrefsFindInt32("cpu");
if (CPUType < 2) CPUType = 2;
if (CPUType > 4) CPUType = 4;
FPUType = PrefsFindBool("fpu") ? 1 : 0;
if (CPUType == 4) FPUType = 1; // 68040 always with FPU
TwentyFourBitAddressing = true;
break;
case ROM_VERSION_32:
CPUType = PrefsFindInt32("cpu");
if (CPUType < 2) CPUType = 2;
if (CPUType > 4) CPUType = 4;
FPUType = PrefsFindBool("fpu") ? 1 : 0;
if (CPUType == 4) FPUType = 1; // 68040 always with FPU
TwentyFourBitAddressing = false;
break;
}
CPUIs68060 = false;
#endif
// Load XPRAM
XPRAMInit(vmdir);
// Load XPRAM default values if signature not found
if (XPRAM[0x0c] != 0x4e || XPRAM[0x0d] != 0x75
|| XPRAM[0x0e] != 0x4d || XPRAM[0x0f] != 0x63) {
D(bug("Loading XPRAM default values\n"));
memset(XPRAM, 0, 0x100);
XPRAM[0x0c] = 0x4e; // "NuMc" signature
XPRAM[0x0d] = 0x75;
XPRAM[0x0e] = 0x4d;
XPRAM[0x0f] = 0x63;
XPRAM[0x01] = 0x80; // InternalWaitFlags = DynWait (don't wait for SCSI devices upon bootup)
XPRAM[0x10] = 0xa8; // Standard PRAM values
XPRAM[0x11] = 0x00;
XPRAM[0x12] = 0x00;
XPRAM[0x13] = 0x22;
XPRAM[0x14] = 0xcc;
XPRAM[0x15] = 0x0a;
XPRAM[0x16] = 0xcc;
XPRAM[0x17] = 0x0a;
XPRAM[0x1c] = 0x00;
XPRAM[0x1d] = 0x02;
XPRAM[0x1e] = 0x63;
XPRAM[0x1f] = 0x00;
XPRAM[0x08] = 0x13;
XPRAM[0x09] = 0x88;
XPRAM[0x0a] = 0x00;
XPRAM[0x0b] = 0xcc;
XPRAM[0x76] = 0x00; // OSDefault = MacOS
XPRAM[0x77] = 0x01;
}
// Set boot volume
int16 i16 = PrefsFindInt32("bootdrive");
XPRAM[0x78] = i16 >> 8;
XPRAM[0x79] = i16 & 0xff;
i16 = PrefsFindInt32("bootdriver");
XPRAM[0x7a] = i16 >> 8;
XPRAM[0x7b] = i16 & 0xff;
// Init drivers
SonyInit();
DiskInit();
CDROMInit();
SCSIInit();
#if SUPPORTS_EXTFS
// Init external file system
ExtFSInit();
#endif
// Init serial ports
SerialInit();
// Init network
EtherInit();
// Init Time Manager
TimerInit();
// Init clipboard
ClipInit();
// Init ADB
ADBInit();
// Init audio
AudioInit();
// Init video
if (!VideoInit(ROMVersion == ROM_VERSION_64K || ROMVersion == ROM_VERSION_PLUS || ROMVersion == ROM_VERSION_CLASSIC))
return false;
// Set default video mode in XPRAM
XPRAM[0x56] = 0x42; // 'B'
XPRAM[0x57] = 0x32; // '2'
const monitor_desc &main_monitor = *VideoMonitors[0];
XPRAM[0x58] = uint8(main_monitor.depth_to_apple_mode(main_monitor.get_current_mode().depth));
XPRAM[0x59] = 0;
#if EMULATED_68K
// Init 680x0 emulation (this also activates the memory system which is needed for PatchROM())
if (!Init680x0())
return false;
#endif
// Install ROM patches
if (!PatchROM()) {
ErrorAlert(STR_UNSUPPORTED_ROM_TYPE_ERR);
return false;
}
#if ENABLE_MON
// Initialize mon
mon_init();
mon_read_byte = mon_read_byte_b2;
mon_write_byte = mon_write_byte_b2;
#endif
return true;
}
void ErrorAlert(int string_id)
{
ErrorAlert(GetString(string_id));
}
void
XPFPrefs::Close ()
{
#ifndef __MACH__
// Sync with changes to balloon help
setShowHelpTags (HMGetBalloons ());
#endif
// Do the superclass Close, so that we save if we need to save etc.
Inherited::Close ();
bool synchronizationFailed = false;
try {
// Now, we check NVRAM and do whatever copying is necessary
XPFNVRAMSettings *nvram = XPFNVRAMSettings::GetSettings ();
nvram->readFromNVRAM ();
char *bootArgs = nvram->getStringValue ("boot-args");
char *bootDevice = nvram->getStringValue ("boot-device");
if (!strstr (bootDevice, "/AAPL,ROM")) {
MountedVolume *bootDisk = MountedVolume::WithOpenFirmwarePath (bootDevice);
MountedVolume *rootDisk = bootDisk;
char *rdString = strstr (bootArgs, "rd=*");
if (rdString) {
char rootPath[256];
strcpy (rootPath, rdString + strlen ("rd=*"));
char *pos = strchr (rootPath, ' ');
if (pos) *pos = 0;
rootDisk = MountedVolume::WithOpenFirmwarePath (rootPath);
if (!rootDisk) rootDisk = bootDisk;
}
if (rootDisk && (rootDisk != bootDisk)) {
XPFUpdate update (rootDisk, bootDisk);
if (update.getRequiresSynchronization ()) {
PerformCommand (TH_new XPFSynchronizeCommand (&update));
}
// If the root disk was not writeable, then force an update if necessary
// The XPFUpdate class checks and updates /Library/Extensions in the helper
// directory in this case.
if (!rootDisk->getIsWriteable () && update.getRequiresAction ()) {
PerformCommand (TH_new XPFUpdateCommand (&update));
}
}
}
}
catch (CException_AC &ex) {
synchronizationFailed = true;
ErrorAlert (ex.GetError (), ex.GetExceptionMessage ());
}
#ifdef __MACH__
restartStartupItem ();
#endif
if (synchronizationFailed) {
// If synchronization fails, then we put up a warning message and set up
// reboot in Mac OS 9.
// FIXME -- this will not work on some newer "New World" machines which cannot
// boot in Mac OS 9. I'm not sure how to identify them, though. And they are not
// the machines that people are likely to be using with XPostFacto :-)
fRebootInMacOS9 = true;
ErrorAlert (kSynchronizationFailed, 0);
try {
writePrefsToNVRAM (false);
}
catch (CException_AC &ex) {
ErrorAlert (ex.GetError (), ex.GetExceptionMessage ());
}
fRebootInMacOS9 = false; // so we don't save the pref that way
} else {
if (fRestartOnClose) tellFinderToRestart ();
}
if (!gApplication->GetDone ()) gApplication->DoMenuCommand (cQuit);
}
/*------------------------------------------------------------------------------
Display error alert to end user
Parameters:
status - error code
Description:
This is where we post an alert to report any problem encountered by the Printing Manager.
------------------------------------------------------------------------------*/
void PostPrintingErrors( OSStatus status )
{
ErrorAlert(ES_Caution, status == kPMNoDefaultPrinter ? errDefaultPrinter : errGenericPrinting, "Error = %d", status );
}
bool scsi_send_cmd(size_t data_length, bool reading, int sg_size, uint8 **sg_ptr, uint32 *sg_len, uint16 *stat, uint32 timeout)
{
static int pack_id = 0;
// Check if buffer is large enough, allocate new buffer if needed
if (!try_buffer(data_length)) {
char str[256];
sprintf(str, GetString(STR_SCSI_BUFFER_ERR), data_length);
ErrorAlert(str);
return false;
}
// Process S/G table when writing
if (!reading) {
D(bug(" writing to buffer\n"));
uint8 *buffer_ptr = buffer + sizeof(sg_header) + the_cmd_len;
for (int i=0; i<sg_size; i++) {
uint32 len = sg_len[i];
D(bug(" %d bytes from %08lx\n", len, sg_ptr[i]));
memcpy(buffer_ptr, sg_ptr[i], len);
buffer_ptr += len;
}
}
// Request Sense and autosense data valid?
sg_header *h = (sg_header *)buffer;
int res;
if (reading && the_cmd[0] == 0x03 && (h->target_status & DRIVER_SENSE)) {
// Yes, fake command
D(bug(" autosense\n"));
memcpy(buffer + sizeof(sg_header), h->sense_buffer, 16);
h->target_status &= ~DRIVER_SENSE;
res = 0;
*stat = 0;
} else {
// No, send regular command
if (timeout) {
int to = timeout * HZ / 60;
ioctl(fd, SG_SET_TIMEOUT, &to);
}
ioctl(fd, SG_NEXT_CMD_LEN, &the_cmd_len);
D(bug(" sending command, length %d\n", data_length));
int request_size, reply_size;
if (reading) {
h->pack_len = request_size = sizeof(sg_header) + the_cmd_len;
h->reply_len = reply_size = sizeof(sg_header) + data_length;
} else {
h->pack_len = request_size = sizeof(sg_header) + the_cmd_len + data_length;
h->reply_len = reply_size = sizeof(sg_header);
}
h->pack_id = pack_id++;
h->result = 0;
h->twelve_byte = (the_cmd_len == 12);
h->target_status = 0;
h->host_status = 0;
h->driver_status = 0;
h->other_flags = 0;
memcpy(buffer + sizeof(sg_header), the_cmd, the_cmd_len);
res = write(fd, buffer, request_size);
D(bug(" request sent, actual %d, result %d\n", res, h->result));
if (res >= 0) {
res = read(fd, buffer, reply_size);
D(bug(" reply read, actual %d, result %d, status %02x\n", res, h->result, h->target_status << 1));
}
*stat = h->target_status << 1;
}
// Process S/G table when reading
if (reading && h->result == 0) {
D(bug(" reading from buffer\n"));
uint8 *buffer_ptr = buffer + sizeof(sg_header);
for (int i=0; i<sg_size; i++) {
uint32 len = sg_len[i];
D(bug(" %d bytes to %08lx\n", len, sg_ptr[i]));
memcpy(sg_ptr[i], buffer_ptr, len);
buffer_ptr += len;
}
}
return res >= 0;
}
status_t
CodyCam::_SetUpNodes()
{
status_t status = B_OK;
/* find the media roster */
fMediaRoster = BMediaRoster::Roster(&status);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot find the media roster"), status,
fWindow);
return status;
}
/* find the time source */
status = fMediaRoster->GetTimeSource(&fTimeSourceNode);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot get a time source"), status, fWindow);
return status;
}
/* find a video producer node */
INFO("CodyCam acquiring VideoInput node\n");
status = fMediaRoster->GetVideoInput(&fProducerNode);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot find a video source. You need a webcam "
"to use CodyCam."), status, fWindow);
return status;
}
/* create the video consumer node */
fVideoConsumer = new VideoConsumer("CodyCam",
((VideoWindow*)fWindow)->VideoView(),
((VideoWindow*)fWindow)->StatusLine(), NULL, 0);
if (!fVideoConsumer) {
ErrorAlert(B_TRANSLATE("Cannot create a video window"), B_ERROR,
fWindow);
return B_ERROR;
}
/* register the node */
status = fMediaRoster->RegisterNode(fVideoConsumer);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot register the video window"), status,
fWindow);
return status;
}
fPort = fVideoConsumer->ControlPort();
/* find free producer output */
int32 cnt = 0;
status = fMediaRoster->GetFreeOutputsFor(fProducerNode, &fProducerOut, 1,
&cnt, B_MEDIA_RAW_VIDEO);
if (status != B_OK || cnt < 1) {
status = B_RESOURCE_UNAVAILABLE;
ErrorAlert(B_TRANSLATE("Cannot find an available video stream"),
status, fWindow);
return status;
}
/* find free consumer input */
cnt = 0;
status = fMediaRoster->GetFreeInputsFor(fVideoConsumer->Node(),
&fConsumerIn, 1, &cnt, B_MEDIA_RAW_VIDEO);
if (status != B_OK || cnt < 1) {
status = B_RESOURCE_UNAVAILABLE;
ErrorAlert(B_TRANSLATE("Can't find an available connection to the "
"video window"), status, fWindow);
return status;
}
/* Connect The Nodes!!! */
media_format format;
format.type = B_MEDIA_RAW_VIDEO;
media_raw_video_format vid_format = {0, 1, 0, 239, B_VIDEO_TOP_LEFT_RIGHT,
1, 1, {B_RGB32, VIDEO_SIZE_X, VIDEO_SIZE_Y, VIDEO_SIZE_X * 4, 0, 0}};
format.u.raw_video = vid_format;
/* connect producer to consumer */
status = fMediaRoster->Connect(fProducerOut.source,
fConsumerIn.destination, &format, &fProducerOut, &fConsumerIn);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot connect the video source to the video "
"window"), status);
return status;
}
/* set time sources */
status = fMediaRoster->SetTimeSourceFor(fProducerNode.node,
fTimeSourceNode.node);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot set the time source for the video "
"source"), status);
return status;
}
status = fMediaRoster->SetTimeSourceFor(fVideoConsumer->ID(),
fTimeSourceNode.node);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot set the time source for the video "
"window"), status);
return status;
}
/* figure out what recording delay to use */
bigtime_t latency = 0;
status = fMediaRoster->GetLatencyFor(fProducerNode, &latency);
status = fMediaRoster->SetProducerRunModeDelay(fProducerNode, latency);
/* start the nodes */
bigtime_t initLatency = 0;
status = fMediaRoster->GetInitialLatencyFor(fProducerNode, &initLatency);
if (status < B_OK) {
ErrorAlert(B_TRANSLATE("Error getting initial latency for the capture "
"node"), status);
return status;
}
initLatency += estimate_max_scheduling_latency();
BTimeSource* timeSource = fMediaRoster->MakeTimeSourceFor(fProducerNode);
bool running = timeSource->IsRunning();
/* workaround for people without sound cards */
/* because the system time source won't be running */
bigtime_t real = BTimeSource::RealTime();
if (!running) {
status = fMediaRoster->StartTimeSource(fTimeSourceNode, real);
if (status != B_OK) {
timeSource->Release();
ErrorAlert(B_TRANSLATE("Cannot start time source!"), status);
return status;
}
status = fMediaRoster->SeekTimeSource(fTimeSourceNode, 0, real);
if (status != B_OK) {
timeSource->Release();
ErrorAlert(B_TRANSLATE("Cannot seek time source!"), status);
return status;
}
}
bigtime_t perf = timeSource->PerformanceTimeFor(real + latency
+ initLatency);
timeSource->Release();
/* start the nodes */
status = fMediaRoster->StartNode(fProducerNode, perf);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot start the video source"), status);
return status;
}
status = fMediaRoster->StartNode(fVideoConsumer->Node(), perf);
if (status != B_OK) {
ErrorAlert(B_TRANSLATE("Cannot start the video window"), status);
return status;
}
return status;
}
bool TMovieCue::InitAudioCodec()
{
if (m_Reader->HasAudio() == false)
return false;
m_AudioCodec = NULL;
// Get video header to determine compression type
AVIAUDSHeader *audsHeader = m_Reader->GetAUDSHeader();
// Determine compression and create codec
switch(audsHeader->Format)
{
case WAVE_FORMAT_PCM:
m_AudioCodec = new TPCMCodec(m_Reader);
break;
/*
case WAVE_FORMAT_ADPCM:
{
switch(audsHeader.Size)
{
case 4:
m_AudioType = kAudioADPCM;
break;
default:
m_AudioType = kAudioInvalid;
break;
}
}
break;
case WAVE_FORMAT_DVI_ADPCM:
{
m_AudioType = kAudioDVI;
}
break;
case WAVE_FORMAT_MULAW:
{
m_AudioType = kAudioULaw;
}
break;
case WAVE_FORMAT_GSM610:
{
m_AudioType = kAudioMSGSM;
}
break;*/
default:
{
ErrorAlert("Unhandled Audio CODEC.");
#ifdef DEBUG
printf("Unhandled Audio CODEC: ");
#endif
return false;
}
break;
}
if (m_AudioCodec)
return true;
else
return false;
}
bool scsi_send_cmd(size_t data_length, bool reading, int sg_size, uint8 **sg_ptr, uint32 *sg_len, uint16 *stat, uint32 timeout)
{
// Bypass the buffer if there's only one S/G table entry
bool do_direct_transfer = (sg_size == 1 && ((uint32)sg_ptr[0] & 1) == 0 && direct_transfers_supported);
if (!do_direct_transfer) {
// Check if buffer is large enough, allocate new buffer if needed
if (!try_buffer(data_length)) {
char str[256];
sprintf(str, GetString(STR_SCSI_BUFFER_ERR), data_length);
ErrorAlert(str);
return false;
}
// Process S/G table when writing
if (!reading) {
D(bug(" writing to buffer\n"));
uint8 *buffer_ptr = buffer;
for (int i=0; i<sg_size; i++) {
uint32 len = sg_len[i];
D(bug(" %d bytes from %08lx\n", len, sg_ptr[i]));
memcpy(buffer_ptr, sg_ptr[i], len);
buffer_ptr += len;
}
}
}
// Request Sense and autosense data valid?
BYTE res = 0;
if (cmd_buffer[0] == 0x03 && scsi.scsi_SenseActual) {
// Yes, fake command
D(bug(" autosense\n"));
memcpy(buffer, sense_buffer, scsi.scsi_SenseActual);
scsi.scsi_Status = 0;
do_direct_transfer = false;
} else {
// No, send regular command
D(bug(" sending command, length %ld\n", data_length));
if (do_direct_transfer) {
scsi.scsi_Data = (UWORD *)sg_ptr[0];
scsi.scsi_Length = sg_len[0];
} else {
scsi.scsi_Data = (UWORD *)buffer;
scsi.scsi_Length = data_length;
}
scsi.scsi_Actual = 0;
scsi.scsi_Flags = (reading ? SCSIF_READ : SCSIF_WRITE) | SCSIF_AUTOSENSE;
scsi.scsi_SenseActual = 0;
scsi.scsi_Status = 0;
res = DoIO((struct IORequest *)io);
D(bug(" command sent, res %d, status %d\n", res, scsi.scsi_Status));
*stat = scsi.scsi_Status;
}
if (!do_direct_transfer) {
// Process S/G table when reading
if (reading && res == 0) {
D(bug(" reading from buffer\n"));
uint8 *buffer_ptr = buffer;
for (int i=0; i<sg_size; i++) {
uint32 len = sg_len[i];
D(bug(" %d bytes to %08lx\n", len, sg_ptr[i]));
memcpy(sg_ptr[i], buffer_ptr, len);
buffer_ptr += len;
}
}
}
return res == 0;
}
bool VideoInit(bool classic)
{
classic_mode = classic;
// Get screen mode from preferences
const char *mode_str;
if (classic_mode)
mode_str = "win/512/342";
else
mode_str = PrefsFindString("screen");
// Determine type and mode
int default_width = 512, default_height = 384;
display_type = DISPLAY_WINDOW;
if (mode_str) {
if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
display_type = DISPLAY_WINDOW;
else if (sscanf(mode_str, "scr/%d", &scr_mode_bit) == 1)
display_type = DISPLAY_SCREEN;
}
#if 0
if (default_width <= 0)
default_width = DisplayWidth(x_display, screen);
else if (default_width > DisplayWidth(x_display, screen))
default_width = DisplayWidth(x_display, screen);
if (default_height <= 0)
default_height = DisplayHeight(x_display, screen);
else if (default_height > DisplayHeight(x_display, screen))
default_height = DisplayHeight(x_display, screen);
#endif
// Mac screen depth follows BeOS depth
video_depth default_depth = VDEPTH_1BIT;
switch (BScreen().ColorSpace()) {
case B_CMAP8:
default_depth = VDEPTH_8BIT;
break;
case B_RGB15:
default_depth = VDEPTH_16BIT;
break;
case B_RGB32:
default_depth = VDEPTH_32BIT;
break;
default:
fprintf(stderr, "Unknown color space!");
}
// Construct list of supported modes
if (display_type == DISPLAY_WINDOW) {
if (classic)
add_mode(512, 342, 0x80, 64, VDEPTH_1BIT);
else {
add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, default_depth), default_depth);
#if 0
for (unsigned d=VDEPTH_1BIT; d<=VDEPTH_32BIT; d++) {
if (find_visual_for_depth(video_depth(d)))
add_window_modes(video_depth(d));
}
#endif
}
} else
add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, default_depth), default_depth);
if (VideoModes.empty()) {
ErrorAlert(STR_VIDEO_FAILED);
return false;
}
// Find requested default mode with specified dimensions
uint32 default_id;
std::vector<video_mode>::const_iterator i, end = VideoModes.end();
for (i = VideoModes.begin(); i != end; ++i) {
if (i->x == default_width && i->y == default_height && i->depth == default_depth) {
default_id = i->resolution_id;
break;
}
}
if (i == end) { // not found, use first available mode
default_depth = VideoModes[0].depth;
default_id = VideoModes[0].resolution_id;
}
#if DEBUG
D(bug("Available video modes:\n"));
for (i = VideoModes.begin(); i != end; ++i) {
int bits = 1 << i->depth;
if (bits == 16)
bits = 15;
else if (bits == 32)
bits = 24;
D(bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits));
}
#endif
// Create X11_monitor_desc for this (the only) display
BeOS_monitor_desc *monitor = new BeOS_monitor_desc(VideoModes, default_depth, default_id);
VideoMonitors.push_back(monitor);
// Open display
return monitor->video_open();
}
