[ win32 emulation i/f ]
*/
+#if defined(_USE_QT)
+#include <string>
+#endif
#include "emu.h"
#include "vm/vm.h"
+#include "fifo.h"
#include "fileio.h"
#ifndef FD_BASE_NUMBER
// ----------------------------------------------------------------------------
#if defined(_USE_QT)
// Please permit at least them m(.. )m
-extern void get_long_full_path_name(_TCHAR* src, _TCHAR* dst);
+//extern void get_long_full_path_name(_TCHAR* src, _TCHAR* dst);
#include <string>
#endif
// initialize d88 file info
memset(d88_file, 0, sizeof(d88_file));
#endif
+#ifdef USE_BUBBLE1
+ // initialize d88 file info
+ memset(b77_file, 0, sizeof(b77_file));
+#endif
// load sound config
static const int freq_table[8] = {
2000, 4000, 8000, 11025, 22050, 44100,
printer_device_type = config.printer_device_type;
#endif
- // initialize
+ // initialize osd
osd = new OSD();
#if defined(OSD_QT)
osd->main_window_handle = hwnd;
osd->instance_handle = hinst;
#endif
osd->initialize(sound_rate, sound_samples);
+ // initialize vm
+ osd->vm = vm = new VM(this);
+ // Below is temporally workaround. I will fix ASAP (or give up): 20160311 K.Ohta
+ // Problems seem to be resolved. See fm7.cpp. 20160319 K.Ohta
+ // Still not resolved with FM-7/77 :-( 20160407 K.Ohta
+#if defined(_FM7) || defined(_FMNEW7) || defined(_FM8) || \
+ defined(_FM77_VARIANTS)
+ delete vm;
osd->vm = vm = new VM(this);
+#endif
+#ifdef USE_AUTO_KEY
+ initialize_auto_key();
+#endif
#ifdef USE_DEBUGGER
initialize_debugger();
#endif
initialize_media();
vm->initialize_sound(sound_rate, sound_samples);
+#ifdef USE_SOUND_VOLUME
+ for(int i = 0; i < USE_SOUND_VOLUME; i++) {
+ vm->set_sound_device_volume(i, config.sound_volume_l[i], config.sound_volume_r[i]);
+ }
+#endif
vm->reset();
-
now_suspended = false;
}
EMU::~EMU()
{
+#ifdef USE_AUTO_KEY
+ release_auto_key();
+#endif
#ifdef USE_DEBUGGER
release_debugger();
#endif
// drive machine
// ----------------------------------------------------------------------------
-int EMU::frame_interval()
+int EMU::get_frame_interval()
{
#ifdef SUPPORT_VARIABLE_TIMING
static int prev_interval = 0;
static double prev_fps = -1;
- double fps = vm->frame_rate();
+ double fps = vm->get_frame_rate();
if(prev_fps != fps) {
prev_interval = (int)(1024. * 1000. / fps + 0.5);
prev_fps = fps;
#endif
}
-bool EMU::now_skip()
+bool EMU::is_frame_skippable()
{
- return vm->now_skip();
+ return vm->is_frame_skippable();
}
int EMU::run()
now_suspended = false;
}
osd->update_input();
+#ifdef USE_AUTO_KEY
+ update_auto_key();
+#endif
+#ifdef USE_JOYSTICK
+ update_joystick();
+#endif
+
#ifdef USE_SOCKET
- //osd->update_socket();
+#if !defined(_USE_QT) // Temporally
+ osd->update_socket();
+#endif
#endif
update_media();
delete vm;
osd->vm = vm = new VM(this);
vm->initialize_sound(sound_rate, sound_samples);
+#ifdef USE_SOUND_VOLUME
+ for(int i = 0; i < USE_SOUND_VOLUME; i++) {
+ vm->set_sound_device_volume(i, config.sound_volume_l[i], config.sound_volume_r[i]);
+ }
+#endif
vm->reset();
osd->unlock_vm();
// restore inserted medias
osd->unlock_vm();
}
-#if !defined(_USE_QT) // Temporally
// restart recording
- osd->restart_rec_sound();
- osd->restart_rec_video();
+#if !defined(_USE_QT) // Temporally
+ osd->restart_record_sound();
+ osd->restart_record_video();
#endif
}
osd->unlock_vm();
// restart recording
#if !defined(_USE_QT) // Temporally
- restart_rec_sound();
- restart_rec_video();
+ restart_record_sound();
+ restart_record_video();
#endif
}
#endif
}
+bool EMU::is_vm_locked()
+{
+ return osd->is_vm_locked();
+}
+
// ----------------------------------------------------------------------------
// input
// ----------------------------------------------------------------------------
#ifdef OSD_QT
-void EMU::key_modifiers(uint32 mod)
+void EMU::key_modifiers(uint32_t mod)
{
osd->key_modifiers(mod);
}
+ # ifdef USE_MOUSE
void EMU::set_mouse_pointer(int x, int y)
{
osd->set_mouse_pointer(x, y);
{
return osd->get_mouse_button();
}
-
+ #endif
#endif
void EMU::key_down(int code, bool repeat)
#ifdef ONE_BOARD_MICRO_COMPUTER
void EMU::press_button(int num)
{
- osd->press_button(num);
+ int code = vm_buttons[num].code;
+
+ if(code) {
+ osd->key_down_native(code, false);
+ osd->get_key_buffer()[code] = KEY_KEEP_FRAMES;
+ } else {
+ // code=0: reset virtual machine
+ vm->reset();
+ }
}
#endif
+#ifdef USE_MOUSE
void EMU::enable_mouse()
{
osd->enable_mouse();
}
-void EMU::disenable_mouse()
+void EMU::disable_mouse()
{
- osd->disenable_mouse();
+ osd->disable_mouse();
}
void EMU::toggle_mouse()
osd->toggle_mouse();
}
-bool EMU::get_mouse_enabled()
+bool EMU::is_mouse_enabled()
{
- return osd->get_mouse_enabled();
+ return osd->is_mouse_enabled();
}
+#endif
#ifdef USE_AUTO_KEY
+void EMU::initialize_auto_key()
+{
+ auto_key_buffer = new FIFO(65536);
+ auto_key_buffer->clear();
+ auto_key_phase = auto_key_shift = 0;
+ osd->now_auto_key = false;
+}
+
+void EMU::release_auto_key()
+{
+ if(auto_key_buffer) {
+ auto_key_buffer->release();
+ delete auto_key_buffer;
+ }
+}
+
void EMU::start_auto_key()
{
- osd->start_auto_key();
+ auto_key_phase = 1;
+ auto_key_shift = 0;
+ osd->now_auto_key = true;
}
void EMU::stop_auto_key()
{
- osd->stop_auto_key();
+ if(auto_key_shift) {
+ osd->key_up_native(VK_LSHIFT);
+ }
+ auto_key_phase = auto_key_shift = 0;
+ osd->now_auto_key = false;
+}
+
+#ifndef USE_AUTO_KEY_SHIFT
+#define USE_AUTO_KEY_SHIFT 0
+#endif
+#ifndef VK_LSHIFT
+#define VK_LSHIFT 0xA0
+#endif
+
+void EMU::update_auto_key()
+{
+ switch(auto_key_phase) {
+ case 1:
+ if(auto_key_buffer && !auto_key_buffer->empty()) {
+ // update shift key status
+ int shift = auto_key_buffer->read_not_remove(0) & 0x100;
+ if(shift && !auto_key_shift) {
+ osd->key_down_native(VK_LSHIFT, false);
+ } else if(!shift && auto_key_shift) {
+ osd->key_up_native(VK_LSHIFT);
+ }
+ auto_key_shift = shift;
+ auto_key_phase++;
+ break;
+ }
+ case 3 + USE_AUTO_KEY_SHIFT:
+ if(auto_key_buffer && !auto_key_buffer->empty()) {
+ osd->key_down_native(auto_key_buffer->read_not_remove(0) & 0xff, false);
+ }
+ auto_key_phase++;
+ break;
+ case USE_AUTO_KEY + USE_AUTO_KEY_SHIFT:
+ if(auto_key_buffer && !auto_key_buffer->empty()) {
+ osd->key_up_native(auto_key_buffer->read_not_remove(0) & 0xff);
+ }
+ auto_key_phase++;
+ break;
+ case USE_AUTO_KEY_RELEASE + USE_AUTO_KEY_SHIFT:
+ if(auto_key_buffer && !auto_key_buffer->empty()) {
+ // wait enough while vm analyzes one line
+ if(auto_key_buffer->read() == 0xd) {
+ auto_key_phase++;
+ break;
+ }
+ }
+ case 30:
+ if(auto_key_buffer && !auto_key_buffer->empty()) {
+ auto_key_phase = 1;
+ } else {
+ stop_auto_key();
+ }
+ break;
+ default:
+ if(auto_key_phase) {
+ auto_key_phase++;
+ }
+ }
}
+#endif
-bool EMU::now_auto_key()
+#ifdef USE_JOYSTICK
+void EMU::update_joystick()
{
- return osd->now_auto_key();
+ uint32_t *joy_buffer = osd->get_joy_buffer();
+ uint8_t *key_buffer = osd->get_key_buffer();
+
+ memset(joy_status, 0, sizeof(joy_status));
+
+ for(int i = 0; i < 4; i++) {
+ for(int j = 0; j < 16; j++) {
+ if(config.joy_buttons[i][j] < 0) {
+ int code = -config.joy_buttons[i][j];
+ if(code < 256 && key_buffer[code]) {
+ joy_status[i] |= (1 << j);
+ }
+ } else {
+ int stick = config.joy_buttons[i][j] >> 4;
+ int button = config.joy_buttons[i][j] & 15;
+ if(stick < 2 && (joy_buffer[stick & 3] & (1 << button))) {
+ joy_status[i] |= (1 << j);
+ }
+ }
+ }
+ }
}
#endif
-uint8* EMU::key_buffer()
+const uint8_t* EMU::get_key_buffer()
{
- return osd->key_buffer();
+ return (const uint8_t*)osd->get_key_buffer();
}
-uint32* EMU::joy_buffer()
+#ifdef USE_JOYSTICK
+const uint32_t* EMU::get_joy_buffer()
{
- return osd->joy_buffer();
+ return (const uint32_t*)joy_status;
}
-int* EMU::mouse_buffer()
+#endif
+
+#ifdef USE_MOUSE
+const int32_t* EMU::get_mouse_buffer()
{
- return osd->mouse_buffer();
+ return (const int32_t*)osd->get_mouse_buffer();
}
+#endif
// ----------------------------------------------------------------------------
// screen
// ----------------------------------------------------------------------------
-int EMU::get_window_width(int mode)
+int EMU::get_window_mode_width(int mode)
{
- return osd->get_window_width(mode);
+ return osd->get_window_mode_width(mode);
}
-int EMU::get_window_height(int mode)
+int EMU::get_window_mode_height(int mode)
{
- return osd->get_window_height(mode);
+ return osd->get_window_mode_height(mode);
}
-void EMU::set_window_size(int width, int height, bool window_mode)
+void EMU::set_host_window_size(int window_width, int window_height, bool window_mode)
{
- osd->set_window_size(width, height, window_mode);
+ osd->set_host_window_size(window_width, window_height, window_mode);
}
-void EMU::set_vm_screen_size(int sw, int sh, int swa, int sha, int ww, int wh)
+void EMU::set_vm_screen_size(int screen_width, int screen_height, int window_width, int window_height, int window_width_aspect, int window_height_aspect)
{
- osd->set_vm_screen_size(sw, sh, swa, sha, ww, wh);
+ osd->set_vm_screen_size(screen_width, screen_height, window_width, window_height, window_width_aspect, window_height_aspect);
+}
+
+int EMU::get_vm_window_width()
+{
+ return osd->get_vm_window_width();
+}
+
+int EMU::get_vm_window_height()
+{
+ return osd->get_vm_window_height();
+}
+
+int EMU::get_vm_window_width_aspect()
+{
+ return osd->get_vm_window_width_aspect();
+}
+
+int EMU::get_vm_window_height_aspect()
+{
+ return osd->get_vm_window_height_aspect();
}
#if defined(USE_MINIMUM_RENDERING)
-bool EMU::screen_changed()
+bool EMU::is_screen_changed()
{
- return vm->screen_changed();
+ return vm->is_screen_changed();
}
#endif
return osd->draw_screen();
}
-scrntype* EMU::screen_buffer(int y)
+scrntype_t* EMU::get_screen_buffer(int y)
{
return osd->get_vm_screen_buffer(y);
}
osd->capture_screen();
}
-bool EMU::start_rec_video(int fps)
+bool EMU::start_record_video(int fps)
{
- return osd->start_rec_video(fps);
+ return osd->start_record_video(fps);
}
-void EMU::stop_rec_video()
+void EMU::stop_record_video()
{
- osd->stop_rec_video();
+ osd->stop_record_video();
}
-bool EMU::now_rec_video()
+bool EMU::is_video_recording()
{
- return osd->now_rec_video;
+ return osd->now_record_video;
}
// ----------------------------------------------------------------------------
osd->mute_sound();
}
-void EMU::start_rec_sound()
+void EMU::start_record_sound()
{
- osd->start_rec_sound();
+ osd->start_record_sound();
}
-void EMU::stop_rec_sound()
+void EMU::stop_record_sound()
{
- osd->stop_rec_sound();
+ osd->stop_record_sound();
}
-bool EMU::now_rec_sound()
+bool EMU::is_sound_recording()
{
- return osd->now_rec_sound;
+ return osd->now_record_sound;
}
// ----------------------------------------------------------------------------
osd->set_cur_movie_frame(frame, relative);
}
-uint32 EMU::get_cur_movie_frame()
+uint32_t EMU::get_cur_movie_frame()
{
return osd->get_cur_movie_frame();
}
osd->release_font(font);
}
-void EMU::create_pen(pen_t *pen, int width, uint8 r, uint8 g, uint8 b)
+void EMU::create_pen(pen_t *pen, int width, uint8_t r, uint8_t g, uint8_t b)
{
osd->create_pen(pen, width, r, g, b);
}
osd->release_pen(pen);
}
-void EMU::clear_bitmap(bitmap_t *bitmap, uint8 r, uint8 g, uint8 b)
+void EMU::clear_bitmap(bitmap_t *bitmap, uint8_t r, uint8_t g, uint8_t b)
{
osd->clear_bitmap(bitmap, r, g, b);
}
return osd->get_text_width(bitmap, font, text);
}
-void EMU::draw_text_to_bitmap(bitmap_t *bitmap, font_t *font, int x, int y, const char *text, uint8 r, uint8 g, uint8 b)
+void EMU::draw_text_to_bitmap(bitmap_t *bitmap, font_t *font, int x, int y, const char *text, uint8_t r, uint8_t g, uint8_t b)
{
osd->draw_text_to_bitmap(bitmap, font, x, y, text, r, g, b);
}
osd->draw_line_to_bitmap(bitmap, pen, sx, sy, ex, ey);
}
-void EMU::draw_rectangle_to_bitmap(bitmap_t *bitmap, int x, int y, int width, int height, uint8 r, uint8 g, uint8 b)
+void EMU::draw_rectangle_to_bitmap(bitmap_t *bitmap, int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b)
{
osd->draw_rectangle_to_bitmap(bitmap, x, y, width, height, r, g, b);
}
-void EMU::draw_point_to_bitmap(bitmap_t *bitmap, int x, int y, uint8 r, uint8 g, uint8 b)
+void EMU::draw_point_to_bitmap(bitmap_t *bitmap, int x, int y, uint8_t r, uint8_t g, uint8_t b)
{
osd->draw_point_to_bitmap(bitmap, x, y, r, g, b);
}
return osd->get_socket(ch);
}
-void EMU::socket_connected(int ch)
+void EMU::notify_socket_connected(int ch)
{
- osd->socket_connected(ch);
+ osd->notify_socket_connected(ch);
}
-void EMU::socket_disconnected(int ch)
+void EMU::notify_socket_disconnected(int ch)
{
- osd->socket_disconnected(ch);
+ osd->notify_socket_disconnected(ch);
}
-bool EMU::init_socket_tcp(int ch)
+bool EMU::initialize_socket_tcp(int ch)
{
- return osd->init_socket_tcp(ch);
+ return osd->initialize_socket_tcp(ch);
}
-bool EMU::init_socket_udp(int ch)
+bool EMU::initialize_socket_udp(int ch)
{
- return osd->init_socket_udp(ch);
+ return osd->initialize_socket_udp(ch);
}
-bool EMU::connect_socket(int ch, uint32 ipaddr, int port)
+bool EMU::connect_socket(int ch, uint32_t ipaddr, int port)
{
return osd->connect_socket(ch, ipaddr, port);
}
return osd->listen_socket(ch);
}
-void EMU::send_data_tcp(int ch)
+void EMU::send_socket_data_tcp(int ch)
{
- osd->send_data_tcp(ch);
+ osd->send_socket_data_tcp(ch);
}
-void EMU::send_data_udp(int ch, uint32 ipaddr, int port)
+void EMU::send_socket_data_udp(int ch, uint32_t ipaddr, int port)
{
- osd->send_data_udp(ch, ipaddr, port);
+ osd->send_socket_data_udp(ch, ipaddr, port);
}
-void EMU::send_data(int ch)
+void EMU::send_socket_data(int ch)
{
- osd->send_data(ch);
+ osd->send_socket_data(ch);
}
-void EMU::recv_data(int ch)
+void EMU::recv_socket_data(int ch)
{
- osd->recv_data(ch);
+ osd->recv_socket_data(ch);
}
#endif
}
#endif
+#ifdef _DEBUG_LOG
+static _TCHAR prev_buffer[1024] = {0};
+#endif
+
void EMU::out_debug_log(const _TCHAR* format, ...)
{
#ifdef _DEBUG_LOG
va_list ap;
_TCHAR buffer[1024];
- static _TCHAR prev_buffer[1024] = {0};
va_start(ap, format);
my_vstprintf_s(buffer, 1024, format, ap);
va_end(ap);
-
+
+ if(_tcscmp(prev_buffer, buffer) == 0) {
+ return;
+ }
+ my_tcscpy_s(prev_buffer, 1024, buffer);
+
#if defined(_USE_QT) || defined(_USE_AGAR) || defined(_USE_SDL)
AGAR_DebugLog(AGAR_LOG_DEBUG, "%s", buffer);
#else
- if(my_tcscmp(prev_buffer, buffer) == 0) {
- return;
+ if(debug_log) {
+ _ftprintf(debug_log, _T("%s"), buffer);
+ static int size = 0;
+ if((size += _tcslen(buffer)) > 0x8000000) { // 128MB
+ fclose(debug_log);
+ debug_log = _tfopen(create_date_file_path(_T("log")), _T("w"));
+ size = 0;
+ }
}
+#endif
+#endif
+}
+
+void EMU::force_out_debug_log(const _TCHAR* format, ...)
+{
+#ifdef _DEBUG_LOG
+ va_list ap;
+ _TCHAR buffer[1024];
+
+ va_start(ap, format);
+ my_vstprintf_s(buffer, 1024, format, ap);
+ va_end(ap);
my_tcscpy_s(prev_buffer, 1024, buffer);
+
+#if defined(_USE_QT) || defined(_USE_AGAR) || defined(_USE_SDL)
+ AGAR_DebugLog(AGAR_LOG_DEBUG, "%s", buffer);
+#else
if(debug_log) {
_ftprintf(debug_log, _T("%s"), buffer);
static int size = 0;
// ----------------------------------------------------------------------------
-void EMU::sleep(uint32 ms)
+void EMU::sleep(uint32_t ms)
{
osd->sleep(ms);
}
// user interface
// ----------------------------------------------------------------------------
-static uint8 hex2uint8(char *value)
+static uint8_t hex2uint8(char *value)
{
char tmp[3];
memset(tmp, 0, sizeof(tmp));
memcpy(tmp, value, 2);
- return (uint8)strtoul(tmp, NULL, 16);
+ return (uint8_t)strtoul(tmp, NULL, 16);
}
-static uint16 hex2uint16(char *value)
+static uint16_t hex2uint16(char *value)
{
char tmp[5];
memset(tmp, 0, sizeof(tmp));
memcpy(tmp, value, 4);
- return (uint16)strtoul(tmp, NULL, 16);
+ return (uint16_t)strtoul(tmp, NULL, 16);
}
static bool hex2bin(const _TCHAR* file_path, const _TCHAR* dest_path)
if(fio_s->Fopen(file_path, FILEIO_READ_BINARY)) {
int length = 0;
char line[1024];
- uint8 buffer[0x10000];
+ uint8_t buffer[0x10000];
memset(buffer, 0xff, sizeof(buffer));
while(fio_s->Fgets(line, sizeof(line)) != NULL) {
if(line[0] != ':') continue;
int bytes = hex2uint8(line + 1);
int offset = hex2uint16(line + 3);
- uint8 record_type = hex2uint8(line + 7);
+ uint8_t record_type = hex2uint8(line + 7);
if(record_type == 0x01) break;
if(record_type != 0x00) continue;
for(int i = 0; i < bytes; i++) {
memset(&cart_status, 0, sizeof(cart_status));
#endif
#ifdef USE_FD1
- memset(disk_status, 0, sizeof(disk_status));
+ memset(floppy_disk_status, 0, sizeof(floppy_disk_status));
#endif
#ifdef USE_QD1
- memset(&quickdisk_status, 0, sizeof(quickdisk_status));
+ memset(&quick_disk_status, 0, sizeof(quick_disk_status));
#endif
#ifdef USE_TAPE
memset(&tape_status, 0, sizeof(tape_status));
#endif
+#ifdef USE_COMPACT_DISC
+ memset(&compact_disc_status, 0, sizeof(compact_disc_status));
+#endif
#ifdef USE_LASER_DISC
memset(&laser_disc_status, 0, sizeof(laser_disc_status));
#endif
{
#ifdef USE_FD1
for(int drv = 0; drv < MAX_FD; drv++) {
- if(disk_status[drv].wait_count != 0 && --disk_status[drv].wait_count == 0) {
- vm->open_disk(drv, disk_status[drv].path, disk_status[drv].bank);
- out_message(_T("FD%d: %s"), drv + FD_BASE_NUMBER, disk_status[drv].path);
+ if(floppy_disk_status[drv].wait_count != 0 && --floppy_disk_status[drv].wait_count == 0) {
+ vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank);
+ out_message(_T("FD%d: %s"), drv + FD_BASE_NUMBER, floppy_disk_status[drv].path);
}
}
#endif
#ifdef USE_QD1
for(int drv = 0; drv < MAX_QD; drv++) {
- if(quickdisk_status[drv].wait_count != 0 && --quickdisk_status[drv].wait_count == 0) {
- vm->open_quickdisk(drv, quickdisk_status[drv].path);
- out_message(_T("QD%d: %s"), drv + QD_BASE_NUMBER, quickdisk_status[drv].path);
+ if(quick_disk_status[drv].wait_count != 0 && --quick_disk_status[drv].wait_count == 0) {
+ vm->open_quick_disk(drv, quick_disk_status[drv].path);
+ out_message(_T("QD%d: %s"), drv + QD_BASE_NUMBER, quick_disk_status[drv].path);
}
}
#endif
out_message(_T("CMT: %s"), tape_status.path);
}
#endif
+#ifdef USE_COMPACT_DISC
+ if(compact_disc_status.wait_count != 0 && --compact_disc_status.wait_count == 0) {
+ vm->open_compact_disc(compact_disc_status.path);
+ out_message(_T("CD: %s"), compact_disc_status.path);
+ }
+#endif
#ifdef USE_LASER_DISC
if(laser_disc_status.wait_count != 0 && --laser_disc_status.wait_count == 0) {
vm->open_laser_disc(laser_disc_status.path);
out_message(_T("LD: %s"), laser_disc_status.path);
}
#endif
+#ifdef USE_BUBBLE1
+ for(int drv = 0; drv < MAX_BUBBLE; drv++) {
+ if(bubble_casette_status[drv].wait_count != 0 && --bubble_casette_status[drv].wait_count == 0) {
+ vm->open_bubble_casette(drv, bubble_casette_status[drv].path, bubble_casette_status[drv].bank);
+ out_message(_T("Bubble%d: %s"), drv, bubble_casette_status[drv].path);
+ }
+ }
+#endif
}
void EMU::restore_media()
#endif
#ifdef USE_FD1
for(int drv = 0; drv < MAX_FD; drv++) {
- if(disk_status[drv].path[0] != _T('\0')) {
- vm->open_disk(drv, disk_status[drv].path, disk_status[drv].bank);
+ if(floppy_disk_status[drv].path[0] != _T('\0')) {
+ vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank);
}
}
#endif
#ifdef USE_QD1
for(int drv = 0; drv < MAX_QD; drv++) {
- if(quickdisk_status[drv].path[0] != _T('\0')) {
- vm->open_quickdisk(drv, quickdisk_status[drv].path);
+ if(quick_disk_status[drv].path[0] != _T('\0')) {
+ vm->open_quick_disk(drv, quick_disk_status[drv].path);
}
}
#endif
}
}
#endif
+#ifdef USE_COMPACT_DISC
+ if(compact_disc_status.path[0] != _T('\0')) {
+ vm->open_compact_disc(compact_disc_status.path);
+ }
+#endif
#ifdef USE_LASER_DISC
if(laser_disc_status.path[0] != _T('\0')) {
vm->open_laser_disc(laser_disc_status.path);
}
#endif
+#ifdef USE_BUBBLE1
+ for(int drv = 0; drv < MAX_BUBBLE; drv++) {
+ if(bubble_casette_status[drv].path[0] != _T('\0')) {
+ vm->open_bubble_casette(drv, bubble_casette_status[drv].path, bubble_casette_status[drv].bank);
+ }
+ }
+#endif
}
#ifdef USE_CART1
out_message(_T("Cart%d: %s"), drv + 1, file_path);
// restart recording
- bool s = osd->now_rec_sound;
- bool v = osd->now_rec_video;
- stop_rec_sound();
- stop_rec_video();
- if(s) osd->start_rec_sound();
- if(v) osd->start_rec_video(-1);
+ bool s = osd->now_record_sound;
+ bool v = osd->now_record_video;
+ stop_record_sound();
+ stop_record_video();
+ if(s) osd->start_record_sound();
+ if(v) osd->start_record_video(-1);
}
}
out_message(_T("Cart%d: Ejected"), drv + 1);
// stop recording
- stop_rec_video();
- stop_rec_sound();
+ stop_record_video();
+ stop_record_sound();
}
}
-bool EMU::cart_inserted(int drv)
+bool EMU::is_cart_inserted(int drv)
{
if(drv < MAX_CART) {
- return vm->cart_inserted(drv);
+ return vm->is_cart_inserted(drv);
} else {
return false;
}
#endif
#ifdef USE_FD1
-void EMU::open_disk(int drv, const _TCHAR* file_path, int bank)
+void EMU::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
{
if(drv < MAX_FD) {
- if(vm->disk_inserted(drv)) {
- vm->close_disk(drv);
+ if(vm->is_floppy_disk_inserted(drv)) {
+ vm->close_floppy_disk(drv);
// wait 0.5sec
#ifdef SUPPORT_VARIABLE_TIMING
- disk_status[drv].wait_count = (int)(vm->frame_rate() / 2);
+ floppy_disk_status[drv].wait_count = (int)(vm->get_frame_rate() / 2);
#else
- disk_status[drv].wait_count = (int)(FRAMES_PER_SEC / 2);
+ floppy_disk_status[drv].wait_count = (int)(FRAMES_PER_SEC / 2);
#endif
out_message(_T("FD%d: Ejected"), drv + FD_BASE_NUMBER);
- } else if(disk_status[drv].wait_count == 0) {
- vm->open_disk(drv, file_path, bank);
+ } else if(floppy_disk_status[drv].wait_count == 0) {
+ vm->open_floppy_disk(drv, file_path, bank);
out_message(_T("FD%d: %s"), drv + FD_BASE_NUMBER, file_path);
}
- my_tcscpy_s(disk_status[drv].path, _MAX_PATH, file_path);
- disk_status[drv].bank = bank;
+ my_tcscpy_s(floppy_disk_status[drv].path, _MAX_PATH, file_path);
+ floppy_disk_status[drv].bank = bank;
}
}
-void EMU::close_disk(int drv)
+void EMU::close_floppy_disk(int drv)
{
if(drv < MAX_FD) {
- vm->close_disk(drv);
- clear_media_status(&disk_status[drv]);
+ vm->close_floppy_disk(drv);
+ clear_media_status(&floppy_disk_status[drv]);
out_message(_T("FD%d: Ejected"), drv + FD_BASE_NUMBER);
}
}
-bool EMU::disk_inserted(int drv)
+bool EMU::is_floppy_disk_inserted(int drv)
{
if(drv < MAX_FD) {
- return vm->disk_inserted(drv);
+ return vm->is_floppy_disk_inserted(drv);
} else {
return false;
}
}
-void EMU::set_disk_protected(int drv, bool value)
+void EMU::is_floppy_disk_protected(int drv, bool value)
{
if(drv < MAX_FD) {
- vm->set_disk_protected(drv, value);
+ vm->is_floppy_disk_protected(drv, value);
}
}
-bool EMU::get_disk_protected(int drv)
+bool EMU::is_floppy_disk_protected(int drv)
{
if(drv < MAX_FD) {
- return vm->get_disk_protected(drv);
+ return vm->is_floppy_disk_protected(drv);
} else {
return false;
}
}
#endif
-int EMU::get_access_lamp(void)
-{
- return 0;
-}
-
#ifdef USE_QD1
-void EMU::open_quickdisk(int drv, const _TCHAR* file_path)
+void EMU::open_quick_disk(int drv, const _TCHAR* file_path)
{
if(drv < MAX_QD) {
- if(vm->quickdisk_inserted(drv)) {
- vm->close_quickdisk(drv);
+ if(vm->is_quick_disk_inserted(drv)) {
+ vm->close_quick_disk(drv);
// wait 0.5sec
#ifdef SUPPORT_VARIABLE_TIMING
- quickdisk_status[drv].wait_count = (int)(vm->frame_rate() / 2);
+ quick_disk_status[drv].wait_count = (int)(vm->get_frame_rate() / 2);
#else
- quickdisk_status[drv].wait_count = (int)(FRAMES_PER_SEC / 2);
+ quick_disk_status[drv].wait_count = (int)(FRAMES_PER_SEC / 2);
#endif
out_message(_T("QD%d: Ejected"), drv + QD_BASE_NUMBER);
- } else if(quickdisk_status[drv].wait_count == 0) {
- vm->open_quickdisk(drv, file_path);
+ } else if(quick_disk_status[drv].wait_count == 0) {
+ vm->open_quick_disk(drv, file_path);
out_message(_T("QD%d: %s"), drv + QD_BASE_NUMBER, file_path);
}
- my_tcscpy_s(quickdisk_status[drv].path, _MAX_PATH, file_path);
+ my_tcscpy_s(quick_disk_status[drv].path, _MAX_PATH, file_path);
}
}
-void EMU::close_quickdisk(int drv)
+void EMU::close_quick_disk(int drv)
{
if(drv < MAX_QD) {
- vm->close_quickdisk(drv);
- clear_media_status(&quickdisk_status[drv]);
+ vm->close_quick_disk(drv);
+ clear_media_status(&quick_disk_status[drv]);
out_message(_T("QD%d: Ejected"), drv + QD_BASE_NUMBER);
}
}
-bool EMU::quickdisk_inserted(int drv)
+bool EMU::is_quick_disk_inserted(int drv)
{
if(drv < MAX_QD) {
- return vm->quickdisk_inserted(drv);
+ return vm->is_quick_disk_inserted(drv);
} else {
return false;
}
#ifdef USE_TAPE
void EMU::play_tape(const _TCHAR* file_path)
{
- if(vm->tape_inserted()) {
+ if(vm->is_tape_inserted()) {
vm->close_tape();
// wait 0.5sec
#ifdef SUPPORT_VARIABLE_TIMING
- tape_status.wait_count = (int)(vm->frame_rate() / 2);
+ tape_status.wait_count = (int)(vm->get_frame_rate() / 2);
#else
tape_status.wait_count = (int)(FRAMES_PER_SEC / 2);
#endif
void EMU::rec_tape(const _TCHAR* file_path)
{
- if(vm->tape_inserted()) {
+ if(vm->is_tape_inserted()) {
vm->close_tape();
// wait 0.5sec
#ifdef SUPPORT_VARIABLE_TIMING
- tape_status.wait_count = (int)(vm->frame_rate() / 2);
+ tape_status.wait_count = (int)(vm->get_frame_rate() / 2);
#else
tape_status.wait_count = (int)(FRAMES_PER_SEC / 2);
#endif
out_message(_T("CMT: Ejected"));
}
-bool EMU::tape_inserted()
+bool EMU::is_tape_inserted()
{
- return vm->tape_inserted();
+ return vm->is_tape_inserted();
}
#ifndef TAPE_BINARY_ONLY
-bool EMU::tape_playing()
+bool EMU::is_tape_playing()
{
- return vm->tape_playing();
+ return vm->is_tape_playing();
}
-bool EMU::tape_recording()
+bool EMU::is_tape_recording()
{
- return vm->tape_recording();
+ return vm->is_tape_recording();
}
-int EMU::tape_position()
+int EMU::get_tape_position()
{
- return vm->tape_position();
+ return vm->get_tape_position();
}
#endif
#endif
#endif
+#ifdef USE_COMPACT_DISC
+void EMU::open_compact_disc(const _TCHAR* file_path)
+{
+ if(vm->is_compact_disc_inserted()) {
+ vm->close_compact_disc();
+ // wait 0.5sec
+#ifdef SUPPORT_VARIABLE_TIMING
+ compact_disc_status.wait_count = (int)(vm->get_frame_rate() / 2);
+#else
+ compact_disc_status.wait_count = (int)(FRAMES_PER_SEC / 2);
+#endif
+ out_message(_T("CD: Ejected"));
+ } else if(compact_disc_status.wait_count == 0) {
+ vm->open_compact_disc(file_path);
+ out_message(_T("CD: %s"), file_path);
+ }
+ my_tcscpy_s(compact_disc_status.path, _MAX_PATH, file_path);
+}
+
+void EMU::close_compact_disc()
+{
+ vm->close_compact_disc();
+ clear_media_status(&compact_disc_status);
+ out_message(_T("CD: Ejected"));
+}
+
+bool EMU::is_compact_disc_inserted()
+{
+ return vm->is_compact_disc_inserted();
+}
+#endif
+
#ifdef USE_LASER_DISC
void EMU::open_laser_disc(const _TCHAR* file_path)
{
- if(vm->laser_disc_inserted()) {
+ if(vm->is_laser_disc_inserted()) {
vm->close_laser_disc();
// wait 0.5sec
#ifdef SUPPORT_VARIABLE_TIMING
- laser_disc_status.wait_count = (int)(vm->frame_rate() / 2);
+ laser_disc_status.wait_count = (int)(vm->get_frame_rate() / 2);
#else
laser_disc_status.wait_count = (int)(FRAMES_PER_SEC / 2);
#endif
out_message(_T("LD: Ejected"));
}
-bool EMU::laser_disc_inserted()
+bool EMU::is_laser_disc_inserted()
{
- return vm->laser_disc_inserted();
+ return vm->is_laser_disc_inserted();
}
#endif
}
}
#endif
+#ifdef USE_BUBBLE1
+void EMU::open_bubble_casette(int drv, const _TCHAR* file_path, int bank)
+{
+ if(drv < MAX_BUBBLE) {
+ if(vm->is_bubble_casette_inserted(drv)) {
+ vm->close_bubble_casette(drv);
+ // wait 0.5sec
+#ifdef SUPPORT_VARIABLE_TIMING
+ bubble_casette_status[drv].wait_count = (int)(vm->get_frame_rate() / 2);
+#else
+ bubble_casette_status[drv].wait_count = (int)(FRAMES_PER_SEC / 2);
+#endif
+ out_message(_T("Bubble%d: Ejected"), drv + 1);
+ } else if(bubble_casette_status[drv].wait_count == 0) {
+ vm->open_bubble_casette(drv, file_path, bank);
+ out_message(_T("Bubble%d: %s"), drv + 1, file_path);
+ }
+ my_tcscpy_s(bubble_casette_status[drv].path, _MAX_PATH, file_path);
+ bubble_casette_status[drv].bank = bank;
+ }
+}
-// I will decide to move this to osd?
-#ifdef SUPPORT_DUMMY_DEVICE_LED
-uint32 EMU::get_led_status(void)
+void EMU::close_bubble_casette(int drv)
+{
+ if(drv < MAX_BUBBLE) {
+ vm->close_bubble_casette(drv);
+ clear_media_status(&bubble_casette_status[drv]);
+ out_message(_T("Bubble%d: Ejected"), drv + 1);
+ }
+}
+
+bool EMU::is_bubble_casette_inserted(int drv)
+{
+ if(drv < MAX_BUBBLE) {
+ return vm->is_bubble_casette_inserted(drv);
+ } else {
+ return false;
+ }
+}
+
+bool EMU::is_bubble_casette_protected(int drv)
+{
+ if(drv < MAX_BUBBLE) {
+ return vm->is_bubble_casette_protected(drv);
+ } else {
+ return false;
+ }
+}
+
+void EMU::is_bubble_casette_protected(int drv, bool flag)
+{
+ if(drv < MAX_BUBBLE) {
+ return vm->is_bubble_casette_protected(drv, flag);
+ } else {
+ return false;
+ }
+}
+#endif
+
+#ifdef USE_ACCESS_LAMP
+uint32_t EMU::get_access_lamp_status()
+{
+ return vm->get_access_lamp_status();
+}
+#endif
+
+#ifdef USE_LED_DEVICE
+uint32_t EMU::get_led_status()
{
return vm->get_led_status();
}
#endif
+#ifdef USE_SOUND_VOLUME
+void EMU::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
+{
+ vm->set_sound_device_volume(ch, decibel_l, decibel_r);
+}
+#endif
+
void EMU::update_config()
{
vm->update_config();
void EMU::load_state()
{
- if(FILEIO::IsFileExists(create_local_path(_T("%s.sta"), _T(CONFIG_NAME)))) {
+ if(FILEIO::IsFileExisting(create_local_path(_T("%s.sta"), _T(CONFIG_NAME)))) {
save_state_tmp(create_local_path(_T("$temp$.sta")));
if(!load_state_tmp(create_local_path(_T("%s.sta"), _T(CONFIG_NAME)))) {
out_debug_log(_T("failed to load state file\n"));
fio->Fwrite(&cart_status, sizeof(cart_status), 1);
#endif
#ifdef USE_FD1
- fio->Fwrite(disk_status, sizeof(disk_status), 1);
+ fio->Fwrite(floppy_disk_status, sizeof(floppy_disk_status), 1);
fio->Fwrite(d88_file, sizeof(d88_file), 1);
#endif
#ifdef USE_QD1
- fio->Fwrite(&quickdisk_status, sizeof(quickdisk_status), 1);
+ fio->Fwrite(&quick_disk_status, sizeof(quick_disk_status), 1);
#endif
#ifdef USE_TAPE
fio->Fwrite(&tape_status, sizeof(tape_status), 1);
#endif
+#ifdef USE_COMPACT_DISC
+ fio->Fwrite(&compact_disc_status, sizeof(compact_disc_status), 1);
+#endif
#ifdef USE_LASER_DISC
fio->Fwrite(&laser_disc_status, sizeof(laser_disc_status), 1);
#endif
fio->Fread(&cart_status, sizeof(cart_status), 1);
#endif
#ifdef USE_FD1
- fio->Fread(disk_status, sizeof(disk_status), 1);
+ fio->Fread(floppy_disk_status, sizeof(floppy_disk_status), 1);
fio->Fread(d88_file, sizeof(d88_file), 1);
#endif
#ifdef USE_QD1
- fio->Fread(&quickdisk_status, sizeof(quickdisk_status), 1);
+ fio->Fread(&quick_disk_status, sizeof(quick_disk_status), 1);
#endif
#ifdef USE_TAPE
fio->Fread(&tape_status, sizeof(tape_status), 1);
#endif
+#ifdef USE_COMPACT_DISC
+ fio->Fread(&compact_disc_status, sizeof(compact_disc_status), 1);
+#endif
#ifdef USE_LASER_DISC
fio->Fread(&laser_disc_status, sizeof(laser_disc_status), 1);
#endif
delete vm;
osd->vm = vm = new VM(this);
vm->initialize_sound(sound_rate, sound_samples);
+#ifdef USE_SOUND_VOLUME
+ for(int i = 0; i < USE_SOUND_VOLUME; i++) {
+ vm->set_sound_device_volume(i, config.sound_volume_l[i], config.sound_volume_r[i]);
+ }
+#endif
vm->reset();
//osd->unlock_vm();
}
OSDN Git Service
