- This also contains logging by SIGNAL()/SLOT() model of Qt for OSD::.
See osd_base.cpp & osd_base.h .
- Some names of signals and slots are changed . see mainwidget_base.h .
- On EMU:: , for open/close CD-ROM, needs wait correctly.
See EMU::open_compact_disc() and EMU::close_compact_disc() at emu.cpp .
- [VM][FMTOWNS] Cue parser : Fix typo of .ccd file detection.
See vm/fmtowns/cdrom/cdrom_ccd_parser.cpp .
// Sanitize string
memset(strDestination, 0x00, numberOfElements);
_dst.copy(strDestination, numberOfElements - 1);
-
return 0;
}
count = numberOfElements - 1;
}
strncpy(strDestination, strSource, count);
-
return 0;
}
}
#elif defined(_USE_QT)
QString tmp_path = QString::fromLocal8Bit(src);
+// QString tmp_path = QString::fromUtf8(src);
QFileInfo info(tmp_path);
+// strncpy(dst, info.absoluteFilePath().toLocal8Bit().constData(), dst_len);
my_tcscpy_s(dst, dst_len, info.absoluteFilePath().toLocal8Bit().constData());
+// my_tcscpy_s(dst, dst_len, info.absoluteFilePath().toUtf8().constData());
#else
// write code for your environment
for(int drv = 0; drv < USE_COMPACT_DISC; drv++) {
if(compact_disc_status[drv].wait_count != 0 && --compact_disc_status[drv].wait_count == 0) {
vm->open_compact_disc(drv, compact_disc_status[drv].path);
+ //printf(_T("update_media(): LOAD CDROM: %s\n"), compact_disc_status[drv].path);
#if USE_COMPACT_DISC > 1
out_message(_T("CD%d: %s"), drv + BASE_COMPACT_DISC_NUM, compact_disc_status[drv].path);
#else
if(tape_status[drv].path[0] != _T('\0')) {
if(tape_status[drv].play) {
vm->play_tape(drv, tape_status[drv].path);
- EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
- osdcall_string(EMU_MEDIA_TYPE::HARD_DISK,
- drv,
- mess,
- tape_status[drv].path);
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ osdcall_string(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ mess,
+ tape_status[drv].path);
} else {
tape_status[drv].path[0] = _T('\0');
}
for(int drv = 0; drv < USE_COMPACT_DISC; drv++) {
if(compact_disc_status[drv].path[0] != _T('\0')) {
vm->open_compact_disc(drv, compact_disc_status[drv].path);
+ //printf(_T("restore_media(): LOAD CDROM: %s\n"), compact_disc_status[drv].path);
+ osdcall_string(EMU_MEDIA_TYPE::COMPACT_DISC,
+ drv,
+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ (_TCHAR*)compact_disc_status[drv].path);
}
}
#endif
for(int drv = 0; drv < USE_LASER_DISC; drv++) {
if(laser_disc_status[drv].path[0] != _T('\0')) {
vm->open_laser_disc(drv, laser_disc_status[drv].path);
+ osdcall_string(EMU_MEDIA_TYPE::LASER_DISC,
+ drv,
+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ laser_disc_status[drv].path);
}
}
#endif
for(int drv = 0; drv < USE_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);
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ mess |= ((is_bubble_casette_protected(drv)) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
+
+ osdcall_string(EMU_MEDIA_TYPE::BUBBLE_CASETTE | (bubble_casette_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
+ drv,
+ mess,
+ (_TCHAR *)bubble_casette_status[drv].path);
}
}
#endif
void EMU::open_compact_disc(int drv, const _TCHAR* file_path)
{
if(drv < USE_COMPACT_DISC) {
+ //printf(_T("open_compact_disc(): CALLED: %s\n"), file_path);
if(vm->is_compact_disc_inserted(drv)) {
vm->close_compact_disc(drv);
// wait 0.5sec
+ clear_media_status(&compact_disc_status[drv]);
compact_disc_status[drv].wait_count = (int)(vm->get_frame_rate() / 2);
#if USE_COMPACT_DISC > 1
out_message(_T("CD%d: Ejected"), drv + BASE_COMPACT_DISC_NUM);
0);
} else if(compact_disc_status[drv].wait_count == 0) {
vm->open_compact_disc(drv, file_path);
+ //printf(_T("open_compact_disc(): LOAD CDROM: %s\n"), file_path);
#if USE_COMPACT_DISC > 1
out_message(_T("CD%d: %s"), drv + BASE_COMPACT_DISC_NUM, file_path);
#else
EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
(_TCHAR*)file_path);
}
- my_tcscpy_s(compact_disc_status[drv].path, _MAX_PATH, file_path);
+ my_tcscpy_s(compact_disc_status[drv].path, _MAX_PATH, file_path);
}
}
if(drv < USE_COMPACT_DISC) {
vm->close_compact_disc(drv);
clear_media_status(&compact_disc_status[drv]);
+ compact_disc_status[drv].wait_count = (int)(vm->get_frame_rate() / 2);
#if USE_COMPACT_DISC > 1
out_message(_T("CD%d: Ejected"), drv + BASE_COMPACT_DISC_NUM);
#else
{
std::shared_ptr<USING_FLAGS> p = using_flags;
if(p.get() == nullptr) return;
+
if((p->is_use_compact_disc()) && (p->get_max_cd() > drv)) {
//QMutexLocker _locker(&uiMutex);
+
p_emu->close_compact_disc(drv);
emit sig_change_virtual_media(CSP_DockDisks_Domain_CD, drv, QString::fromUtf8(""));
}
if(path.isNull()) return;
std::shared_ptr<USING_FLAGS>up = using_flags;
- if(up.get() != nullptr) return;
+ if(up.get() == nullptr) return;
if(!((up->get_max_cd() > drv) && (up->is_use_compact_disc()))) return;
const _TCHAR *file_path = (const _TCHAR *)(path.toLocal8Bit().constData());
if(cp == nullptr) return;
struct CSP_Ui_Menu::DriveIndexPair tmp = cp->data().value<CSP_Ui_Menu::DriveIndexPair>();
int drv = tmp.drive;
- sub_close_laser_disc_internal(drv);
+ sub_close_compact_disc_internal(drv);
}
QThread::msleep(100);
}
delete console_printer;
-
+
loglist.clear();
log_sysname.clear();
squeue.clear();
device_names.clear();
max_cpus = 0;
max_devices = 0;
-
+
const char *components[] = {
"GENERAL",
"OSD",
vfile_names.append(tmps + ss);
}
}
-
+
tmps = QString::fromUtf8("CPU"); // Enable to update
for(int i = 0; i < 8; i++) {
QString ss;
void CSP_Logger::open(bool b_syslog, bool cons, const char *devname)
{
int flags = 0;
-
+
QMutexLocker locker(lock_mutex);
log_onoff = true;
-
+
loglist.clear();
log_sysname.clear();
squeue.clear();
-
+
QString dname;
if(devname != NULL) {
dname = QString::fromUtf8(devname);
}
log_sysname = QString::fromUtf8("CSP(");
log_sysname = log_sysname + dname + QString::fromUtf8(")");
-
+
if(b_syslog) {
#if !defined(Q_OS_WIN)
syslog_flag = true;
- if(cons) {
+ if(cons) {
flags = LOG_CONS;
}
//openlog(devname, flags | LOG_PID | LOG_NOWAIT, LOG_USER);
log_opened = true;
log_cons_out = log_cons;
syslog_flag_out = syslog_flag;
-
+
cons_log_levels = 1 << CSP_LOG_INFO;
-
-#if !defined(Q_OS_WIN)
+
+#if !defined(Q_OS_WIN)
sys_log_levels = 1 << CSP_LOG_INFO;
sys_log_levels |= (1 << CSP_LOG_DEBUG);
sys_log_levels |= (1 << CSP_LOG_WARN);
#endif
linenum = 1;
line_wrap = 0;
-
+
this->debug_log(CSP_LOG_INFO, "Start logging.");
}
-
+
void CSP_Logger::debug_log(int level, const char *fmt, ...)
{
QMutexLocker locker(lock_mutex);
char strbuf[4096];
va_list ap;
-
- va_start(ap, fmt);
+
+ va_start(ap, fmt);
vsnprintf(strbuf, 4095, fmt, ap);
debug_log(level, 0, strbuf);
va_end(ap);
QMutexLocker locker(lock_mutex);
char strbuf[4096];
va_list ap;
-
- va_start(ap, fmt);
+
+ va_start(ap, fmt);
vsnprintf(strbuf, 4095, fmt, ap);
debug_log(level, domain_num, strbuf);
va_end(ap);
char strbuf2[256];
char strbuf3[24];
struct timeval tv;
-
+
if(!log_opened) return;
+ if(strbuf == nullptr) return;
if(level < 0) level = 0;
if(level >= CSP_LOG_LEVELS) level = CSP_LOG_LEVELS - 1;
-
-#if !defined(Q_OS_WIN)
+
+#if !defined(Q_OS_WIN)
int level_flag = LOG_USER;
if(level == CSP_LOG_DEBUG) {
level_flag |= LOG_DEBUG;
- } else if(level == CSP_LOG_INFO) {
+ } else if(level == CSP_LOG_INFO) {
level_flag |= LOG_INFO;
} else if(level == CSP_LOG_WARN) {
level_flag |= LOG_WARNING;
level_flag |= LOG_DEBUG;
}
#endif
- char *p;
+ char *p = strbuf;
char *p_bak;
const char delim[2] = "\n";
+
QMutexLocker locker(lock_mutex);
{
#ifdef __MINGW32__
p = strtok(strbuf, delim);
#else
- p = strtok_r(strbuf, delim, &p_bak);
+ p = strtok_r(strbuf, delim, &p_bak);
#endif
}
if(strbuf != NULL) {
timedat = localtime(&nowtime);
strftime(strbuf2, 255, "%Y-%m-%d %H:%M:%S", timedat);
snprintf(strbuf3, 23, ".%06ld", tv.tv_usec);
-
+
QString time_s = QString::fromLocal8Bit(strbuf2) + QString::fromLocal8Bit(strbuf3);
-
+
int cons_log_level_n = (1 << level) & cons_log_levels;
int sys_log_level_n = (1 << level) & sys_log_levels;
QString domain_s;
bool record_flag = true;
-
+
domain_s.clear();
if((domain_num > 0) && (domain_num < CSP_LOG_TYPE_COMPONENT_END)) {
domain_s = component_names.at(domain_num - 1);
} else if((domain_num >= CSP_LOG_TYPE_VM_CPU0) && (domain_num < CSP_LOG_TYPE_VM_DEVICE_0)) {
domain_s = cpu_names.at(domain_num - CSP_LOG_TYPE_VM_CPU0);
-
+
record_flag = level_cpu_out_record[domain_num - CSP_LOG_TYPE_VM_CPU0][level];
if(!level_cpu_out_syslog[domain_num - CSP_LOG_TYPE_VM_CPU0][level]) sys_log_level_n = 0;
if(!level_cpu_out_console[domain_num - CSP_LOG_TYPE_VM_CPU0][level]) cons_log_level_n = 0;
} else if((domain_num >= CSP_LOG_TYPE_VM_DEVICE_0) && (domain_num <= CSP_LOG_TYPE_VM_DEVICE_END)) {
domain_s = device_names.at(domain_num - CSP_LOG_TYPE_VM_DEVICE_0);
-
+
record_flag = level_dev_out_record[domain_num - CSP_LOG_TYPE_VM_DEVICE_0][level];
if(!level_dev_out_syslog[domain_num - CSP_LOG_TYPE_VM_DEVICE_0][level]) sys_log_level_n = 0;
if(!level_dev_out_console[domain_num - CSP_LOG_TYPE_VM_DEVICE_0][level]) cons_log_level_n = 0;
}
if(!log_cons || !log_cons_out) cons_log_level_n = 0;
if(!syslog_flag || !syslog_flag_out) sys_log_level_n = 0;
-
+
do {
if(p != NULL) {
CSP_LoggerLine *tmps = NULL;
if(cons_log_level_n != 0) {
emit sig_console_message(log_sysname, tmps->get_element_console());
}
-#if !defined(Q_OS_WIN)
+#if !defined(Q_OS_WIN)
if(sys_log_level_n != 0) {
syslog(level_flag, "%s",
tmps->get_element_syslog().toLocal8Bit().constData());
}
#endif
-
+
}
{
#ifdef __MINGW32__
{
fflush(stdout);
}
-#endif
+#endif
} while(p != NULL);
}
}
{
log_onoff = sw;
}
-
+
void CSP_Logger::set_log_stdout(int level, bool sw)
{
if((level < 0) || (level >= 32)) {
void CSP_Logger::set_log_syslog(int level, bool sw)
{
-#if !defined(Q_OS_WIN)
+#if !defined(Q_OS_WIN)
if((level < 0) || (level >= 32)) {
syslog_flag_out = sw;
return;
{
return log_opened;
}
-
-
+
+
void CSP_Logger::close(void)
{
QMutexLocker locker(lock_mutex);
log_opened = false;
-#if !defined(Q_OS_WIN)
+#if !defined(Q_OS_WIN)
if(syslog_flag != 0) {
closelog();
}
#endif
syslog_flag = false;
syslog_flag_out = false;
-
+
log_cons = false;
log_cons_out = false;
-
+
log_onoff = false;
-
+
// while(!squeue.isEmpty()) {
// CSP_LoggerLine *p = squeue.dequeue();
// if(p != NULL) delete p;
log_sysname = log_sysname + dname + QString::fromUtf8(")");
}
-void CSP_Logger::set_device_name(int num, char *devname)
+void CSP_Logger::do_set_device_name(int num, QString devname)
{
- QString tmps;
if(num < 0) return;
if(num > (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0)) return;
-
+
QMutexLocker locker(lock_mutex);
- if(devname == NULL) {
+
+ if(devname.isEmpty()) {
QString s;
s.setNum(num);
- tmps = QString::fromUtf8("Device#");
+ QString tmps = QString::fromUtf8("Device#");
tmps = tmps + s;
+ device_names.replace(num, tmps);
} else {
- tmps = QString::fromUtf8(devname);
+ device_names.replace(num, devname);
}
- device_names.replace(num, tmps);
+
if(max_devices <= num) max_devices = num + 1;
}
+void CSP_Logger::set_device_name(int num, char *devname)
+{
+ QString tmps;
+ if(devname == nullptr) {
+ do_set_device_name(num, QString::fromUtf8(""));
+ } else {
+ do_set_device_name(num, QString::fromUtf8(devname));
+ }
+}
+
void CSP_Logger::set_cpu_name(int num, char *devname)
{
+ if(devname == nullptr) return;
+ do_set_cpu_name(num, QString::fromUtf8(devname));
+}
+
+void CSP_Logger::do_set_cpu_name(int num, QString devname)
+{
if(num < 0) return;
if(num > (CSP_LOG_TYPE_VM_CPU7 - CSP_LOG_TYPE_VM_CPU0)) return;
- if(devname == NULL) return;
+
QMutexLocker locker(lock_mutex);
-
- QString tmps = QString::fromUtf8(devname);
- device_names.replace(num, tmps);
+ device_names.replace(num, devname);
if(max_cpus <= num) max_cpus = num + 1;
}
{
if(flags == NULL) return;
if(start < 0) return;
-
+
int i;
bool f;
for(i = 0; i < devices; i++) {
char strbuf2[4096];
char *p = NULL;
p = (char *)(device_names.at(device_id).toLocal8Bit().constData());
-
+
va_list ap;
- va_start(ap, fmt);
+ va_start(ap, fmt);
vsnprintf(strbuf2, 4095, fmt, ap);
- snprintf(strbuf, 4500, "[%s] %s", p, strbuf2);
+ snprintf(strbuf, 4500, "[%s] %s", p, strbuf2);
debug_log(level, CSP_LOG_TYPE_EVENT, strbuf);
va_end(ap);
}
{
int64_t n_len = (int64_t)-1;
if(name == NULL) return n_len;
-
+
FILEIO *fio = new FILEIO();
if(fio == NULL) return n_len;
-
+
if(!fio->Fopen(name, FILEIO_READ_WRITE_BINARY)) {
delete fio;
return n_len;
int64_t ssize = start_size;
if(ssize < 0) ssize = 0;
if(start_size >= buf_size) return -1;
-
+
char *p = &(buffer[start_size]);
-
+
if(line < 0) line = 0;
{
QMutexLocker locker(lock_mutex);
/*
* Log functions
* (C) 2014-06-30 K.Ohta
- *
+ *
* History:
* Dec 30, 2014 Move from XM7/SDL, this was Ohta's original code.
* Licence : GPLv2
#define CSP_LOG_ON 1
#define CSP_LOG_OFF 0
-
+
#define CSP_LOG_DEBUG 0
#define CSP_LOG_INFO 1
#define CSP_LOG_WARN 2
void run() override;
public slots:
void do_message(QString header, QString message);
-
+
};
class DLL_PREFIX CSP_Logger: public QObject {
bool level_state_out_record;
bool level_state_out_syslog;
bool level_state_out_console;
-
+
QString loglist;
QString log_sysname;
QStringList component_names;
QStringList cpu_names;
QStringList device_names;
CSP_Log_ConsoleThread *console_printer;
-
+
// Device
bool level_dev_out_record[CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1][CSP_LOG_LEVELS]; // Record to log chain
bool level_dev_out_syslog[CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1][CSP_LOG_LEVELS]; // Syslog chain
bool level_cpu_out_record[8][CSP_LOG_LEVELS]; // Record to log chain
bool level_cpu_out_syslog[8][CSP_LOG_LEVELS]; // Syslog chain
bool level_cpu_out_console[8][CSP_LOG_LEVELS]; // Console log chain
-
+
QVector<CSP_LoggerLine *> squeue;
#if QT_VERSION >= 0x051400
QRecursiveMutex *lock_mutex;
~CSP_Logger();
void set_osd(OSD_BASE *p) { p_osd = p; }
void open(bool b_syslog, bool cons, const char *devname);
- void reset(void);
void debug_log(int level, const char *fmt, ...);
void debug_log(int level, int domain_num, const char *fmt, ...);
void debug_log(int level, int domain_num, char *strbuf);
void set_log_syslog(int level, bool sw);
void set_log_stdout(int level, bool sw);
bool get_status(void);
-
+
void set_emu_vm_name(const char *devname);
void set_device_name(int num, char *devname);
void set_cpu_name(int num, char *devname);
int64_t copy_log(char *buffer, int64_t buf_size, int64_t *lines = NULL, char *domainname = NULL, bool utf8 = true, bool forget = false, int64_t start = 0, int64_t start_size = 0, int64_t *end_line = 0);
void *get_raw_data(bool forget = false, int64_t start = 0, int64_t *end_line = NULL);
public slots:
+ void reset(void);
void do_debug_log(int level, int domain_num, QString mes);
void set_device_node_log(int device_id, int to_output, int type, bool flag);
void set_device_node_log(int to_output, int type, bool* flags, int start, int devices);
void set_device_node_log(int to_output, int type, int *flags, int start, int devices);
-
+ void do_set_device_name(int num, QString devname);
+ void do_set_cpu_name(int num, QString devname);
+
signals:
int sig_console_message(QString, QString);
int sig_console_quit();
int set_recent_compact_disc(int drv, int num);
void do_eject_compact_disc(int drv);
- void do_open_compact_disc(int drv, QString path);
+ void do_open_compact_disc_ui(int drv, QString path);
void do_update_compact_disc_history(int drive, QStringList lst);
void do_ui_compact_disc_insert_history(int drv, QString fname);
void do_ui_eject_compact_disc(int drv);
{
use_write_protect = false;
use_d88_menus = false;
+}
+
+Menu_CompactDiscClass::~Menu_CompactDiscClass()
+{
+}
+
+
+void Menu_CompactDiscClass::create_pulldown_menu_device_sub(void)
+{
+ //
action_swap_byteorder = new Action_Control(p_wid, using_flags);
struct CSP_Ui_Menu::DriveIndexPair tmp;
action_swap_byteorder->setVisible(true);
action_swap_byteorder->setCheckable(true);
+ std::shared_ptr<USING_FLAGS>p = using_flags;
if(p.get() != nullptr) {
action_swap_byteorder->setChecked(p->is_cdaudio_swap_byteorder(media_drive));
} else {
addAction(action_swap_byteorder);
}
-Menu_CompactDiscClass::~Menu_CompactDiscClass()
-{
-}
-
-
-void Menu_CompactDiscClass::create_pulldown_menu_device_sub(void)
-{
- //
-}
-
void Menu_CompactDiscClass::connect_menu_device_sub(void)
{
- connect(this, SIGNAL(sig_open_media(int, QString)), p_wid, SLOT(do_open_compact_disc(int, QString)));
+ connect(this, SIGNAL(sig_open_media(int, QString)), p_wid, SLOT(do_open_compact_disc_ui(int, QString)));
connect(this, SIGNAL(sig_eject_media(int)), p_wid, SLOT(do_eject_compact_disc(int)));
connect(this, SIGNAL(sig_set_recent_media(int, int)), p_wid, SLOT(set_recent_compact_disc(int, int)));
// Will move to EMUTHREADCLASS?
connect(action_eject, SIGNAL(triggered()), p, SLOT(do_eject_compact_disc()), Qt::QueuedConnection);
}
+
void Menu_CompactDiscClass::retranslate_pulldown_menu_device_sub(void)
{
action_insert->setText(QApplication::translate("MenuMedia", "Insert Compact Disc", 0));
static inline void SETUP_HISTORY(void* recent, QStringList& list, const ssize_t width = MAX_HISTORY)
{
if(recent == nullptr) return;
-
+
list.clear();
const size_t length = _MAX_PATH;
_TCHAR* p = (_TCHAR *)recent;
{
const size_t length = _MAX_PATH;
if(recent == nullptr) return;
-
+
_TCHAR* p = (_TCHAR *)recent;
- // Clear LIST
+ // Clear LIST
for(int i = 0; i < width; i++) {
memset(p, 0x00, length);
p = &(p[length]);
// Set temporally list
QStringList tmpl;
SETUP_HISTORY(recent, tmpl, width);
-
+
if(!(path.isEmpty())) {
tmpl.push_front(path);
}
WRITEBACK_TO_HISTORY(recent, tmpl2, width);
list = tmpl2;
}
-
+
static inline void UPDATE_HISTORY(_TCHAR *path, void *recent, QStringList& list, const ssize_t width = MAX_HISTORY)
{
-
+
if(recent == nullptr) return;
if(path == nullptr) return;
QString _path = QString::fromLocal8Bit(path);
+ //QString _path = QString::fromUtf8(path);
UPDATE_HISTORY(_path, recent, list, width);
}
menu_CDROM[drv]->create_pulldown_menu();
// Translate Menu
+ ext_play = "*.ccd *.cue *.iso *.gz";
+ desc_play = "Compact Disc";
+ menu_CDROM[drv]->do_clear_inner_media();
+ menu_CDROM[drv]->do_add_media_extension(ext_play, desc_play);
+
SETUP_HISTORY(p_config->recent_compact_disc_path[drv], listCDROM[drv]);
menu_CDROM[drv]->do_update_histories(listCDROM[drv]);
menu_CDROM[drv]->do_set_initialize_directory(p_config->initial_compact_disc_dir);
- ext_play = "*.ccd *.cue *.iso *.bin *.gz";
- desc_play = "Compact Disc";
- menu_CDROM[drv]->do_add_media_extension(ext_play, desc_play);
-
}
void Ui_MainWindowBase::CreateCDROMPulldownMenu(void)
s_path = QString::fromLocal8Bit(p_config->recent_compact_disc_path[drv][num]);
if(s_path.isEmpty()) return -1;
- do_open_compact_disc(drv, s_path);
+ do_open_compact_disc_ui(drv, s_path);
return 0;
}
if(p.get() == nullptr) return;
if(fname.length() <= 0) return;
- if(using_flags->get_max_cd() <= drv) return;
+ if(p->get_max_cd() <= drv) return;
_TCHAR path_shadow[_MAX_PATH] = {0};
my_strncpy_s(path_shadow, _MAX_PATH, fname.toLocal8Bit().constData(), _TRUNCATE);
if(!(FILEIO::IsFileExisting(path_shadow))) return;
- UPDATE_HISTORY(path_shadow, p_config->recent_compact_disc_path[drv], listCDROM[drv]);
+ UPDATE_HISTORY(fname, p_config->recent_compact_disc_path[drv], listCDROM[drv]);
my_strncpy_s(p_config->initial_compact_disc_dir,
sizeof(p_config->initial_compact_disc_dir) / sizeof(_TCHAR),
get_parent_dir((const _TCHAR*)path_shadow),
_TRUNCATE);
- my_strncpy_s(path_shadow,
- _MAX_PATH,
- fname.toLocal8Bit().constData(),
- _TRUNCATE);
menu_CDROM[drv]->do_set_initialize_directory(p_config->initial_compact_disc_dir);
do_update_compact_disc_history(drv, listCDROM[drv]);
}
}
-void Ui_MainWindowBase::do_open_compact_disc(int drv, QString path)
+void Ui_MainWindowBase::do_open_compact_disc_ui(int drv, QString path)
{
std::shared_ptr<USING_FLAGS>p = using_flags;
if(p.get() == nullptr) return;
m_sound_period = 0;
sound_initialized = false;
sound_ok = false;
+
+ connect(this, SIGNAL(sig_debug_log(int, int, QString)), p_logger.get(), SLOT(do_debug_log(int, int, QString)), Qt::QueuedConnection);
+ connect(this, SIGNAL(sig_logger_reset()), p_logger.get(), SLOT(reset()), Qt::QueuedConnection);
+ connect(this, SIGNAL(sig_logger_set_device_name(int, QString)), p_logger.get(), SLOT(do_set_device_name(int, QString)), Qt::QueuedConnection);
+ connect(this, SIGNAL(sig_logger_set_cpu_name(int, QString)), p_logger.get(), SLOT(do_set_cpu_name(int, QString)), Qt::QueuedConnection);
}
OSD_BASE::~OSD_BASE()
{
device_node_t sp;
device_node_list.clear();
- p_logger->reset();
+ emit sig_logger_reset();
max_vm_nodes = 0;
}
void OSD_BASE::debug_log(int level, int domain_num, char *strbuf)
{
- p_logger->debug_log(level, domain_num, strbuf);
+ QString tmps = QString::fromLocal8Bit(strbuf);
+ emit sig_debug_log(level, domain_num, tmps);
}
void OSD_BASE::set_device_name(int id, char *name)
{
- p_logger->set_device_name(id, (char *)name);
+ if(name != nullptr) {
+ emit sig_logger_set_device_name(id, QString::fromUtf8(name));
+ } else {
+ emit sig_logger_set_device_name(id, QString::fromUtf8(""));
+ }
}
void OSD_BASE::set_vm_node(int id, const _TCHAR *name)
int sig_ui_bubble_close(int);
int sig_ui_bubble_write_protect(int, quint64);
+ // To Logger.
+ int sig_debug_log(int, int, QString);
+ int sig_logger_reset();
+ int sig_logger_set_device_name(int, QString);
+ int sig_logger_set_cpu_name(int, QString);
};
QT_END_NAMESPACE
}
delete fio;
now_auto_key = false;
-
+
// initialize shift+numpad conversion
memset(key_converted, 0, sizeof(key_converted));
key_shift_pressed = key_shift_released = false;
double factor = (double)(p_config->mouse_sensitivity & ((1 << 16) - 1));
diffx = (diffx * factor) / 8192.0;
diffy = (diffy * factor) / 8192.0;
-
+
mouse_status[0] = (int32_t)rint(diffx);
- mouse_status[1] = (int32_t)rint(diffy);
+ mouse_status[1] = (int32_t)rint(diffy);
mouse_status[2] = mouse_button;
//printf("Mouse delta(%d, %d)\n", delta_x, delta_y);
mouse_oldx = mouse_ptrx;
status[vk[i]] = 1;
}
}
- } else if(p_config->joy_to_key_type == 1) { // 2468
+ } else if(p_config->joy_to_key_type == 1) { // 2468
std::lock_guard<std::recursive_timed_mutex> n(joystick_mutex);
static const int vk[] = {VK_NUMPAD8, VK_NUMPAD2, VK_NUMPAD4, VK_NUMPAD6};
for(int i = 0; i < 4; i++) {
case 0x01 : status[VK_NUMPAD8] = 1; break; // up
case 0x01 + 0x08: status[VK_NUMPAD9] = 1; break; // up-right
}
- } else if(p_config->joy_to_key_type == 3) { // 1235
+ } else if(p_config->joy_to_key_type == 3) { // 1235
static const int vk[] = {VK_NUMPAD5, VK_NUMPAD2, VK_NUMPAD1, VK_NUMPAD3};
std::lock_guard<std::recursive_timed_mutex> n(joystick_mutex);
for(int i = 0; i < 4; i++) {
}
}
}
- }
+ }
// release keys
if(lost_focus && !now_auto_key) {
// we lost key focus so release all pressed keys
// update mouse status
//update_input_mouse();
-
+
}
void OSD_BASE::key_down(int code, bool extended, bool repeat)
default:
break;
}
-
+
// if(code == VK_LSHIFT || code == VK_RSHIFT) {
if(code == VK_LSHIFT) {
key_shift_pressed = true;
//#ifdef USE_AUTO_KEY
if(!__USE_AUTO_KEY || (!now_auto_key && !p_config->romaji_to_kana)) {
//#endif
- //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_OSD, "KEY UP %d", code);
+ // _TCHAR __tmps1[128] = {0};
+ // my_stprintf_s(__tmps1, sizeof(__tmps1) - 1, "KEY UP %d", code);
+ //emit sig_debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_OSD, QString::fromUtf8(__tmps));
//if(!dinput_key_available) {
if(code == VK_SHIFT) {
if((key_status[VK_LSHIFT] & 0x80) && !(GetAsyncKeyState(VK_LSHIFT) & 0x8000)) {
default:
break;
}
-
+
// if(code == VK_LSHIFT || code == VK_RSHIFT) {
if(code == VK_LSHIFT) {
key_shift_pressed = false;
void OSD_BASE::key_down_native(int code, bool repeat)
{
bool keep_frames = false;
-
+
if(code == 0xf0) {
code = VK_CAPITAL;
keep_frames = true;
uint8_t prev_shift = key_status[VK_SHIFT];
uint8_t prev_control = key_status[VK_CONTROL];
uint8_t prev_menu = key_status[VK_MENU];
-
+
key_status[VK_SHIFT] = key_status[VK_LSHIFT] | key_status[VK_RSHIFT];
key_status[VK_CONTROL] = key_status[VK_LCONTROL] | key_status[VK_RCONTROL];
key_status[VK_MENU] = key_status[VK_LMENU] | key_status[VK_RMENU];
-
+
if(code == VK_LSHIFT || code == VK_RSHIFT) {
if(prev_shift == 0 && key_status[VK_SHIFT] != 0) {
vm_key_down(VK_SHIFT, repeat);
return;
}
vm_key_up(code);
-
+
uint8_t prev_shift = key_status[VK_SHIFT];
uint8_t prev_control = key_status[VK_CONTROL];
uint8_t prev_menu = key_status[VK_MENU];
-
+
key_status[VK_SHIFT] = key_status[VK_LSHIFT] | key_status[VK_RSHIFT];
key_status[VK_CONTROL] = key_status[VK_LCONTROL] | key_status[VK_RCONTROL];
key_status[VK_MENU] = key_status[VK_LMENU] | key_status[VK_RMENU];
-
+
if(code == VK_LSHIFT || code == VK_RSHIFT) {
if(prev_shift != 0 && key_status[VK_SHIFT] == 0) {
vm_key_up(VK_SHIFT);
void OSD_BASE::key_down_sub(int code, bool repeat)
{
bool keep_frames = false;
-
+
if(code == 0xf0) {
code = VK_CAPITAL;
keep_frames = true;
if(!(code == VK_LSHIFT || code == VK_RSHIFT || code == VK_LCONTROL || code == VK_RCONTROL || code == VK_LMENU || code == VK_RMENU || code == VK_MENU)) {
code = keycode_conv[code];
}
-
+
if(get_dont_keeep_key_pressed()) {
if(!(code == VK_LSHIFT || code == VK_RSHIFT || code == VK_LCONTROL || code == VK_RCONTROL || code == VK_LMENU || code == VK_RMENU || code == VK_MENU)) {
uint8_t prev_shift = key_status[VK_SHIFT];
uint8_t prev_control = key_status[VK_CONTROL];
uint8_t prev_menu = key_status[VK_MENU];
-
+
key_status[VK_SHIFT] = key_status[VK_LSHIFT] | key_status[VK_RSHIFT];
key_status[VK_CONTROL] = key_status[VK_LCONTROL] | key_status[VK_RCONTROL];
key_status[VK_MENU] = key_status[VK_LMENU] | key_status[VK_RMENU];
-
+
{
if(keep_frames) {
repeat = false;
if((key_status[code] &= 0x7f) != 0) {
return;
}
-
+
uint8_t prev_shift = key_status[VK_SHIFT];
uint8_t prev_control = key_status[VK_CONTROL];
uint8_t prev_menu = key_status[VK_MENU];
{
if(get_one_board_micro_computer()) {
int code = get_vm_buttons_code(num);
-
+
if(code) {
key_down_sub(code, false);
key_status[code] = KEY_KEEP_FRAMES;
std::lock_guard<std::recursive_timed_mutex> n(mouse_mutex);
double xx = (double)(get_screen_width() / 2);
double yy = (double)(get_screen_height() / 2);
-
+
mouse_oldx = xx;
mouse_oldy = yy;
mouse_ptrx = xx;
{
if((mouse_enabled)) {
std::lock_guard<std::recursive_timed_mutex> n(mouse_mutex);
-
+
mouse_ptrx = x;
mouse_ptry = y;
}
}
-void OSD_BASE::set_mouse_button(int button)
+void OSD_BASE::set_mouse_button(int button)
{
std::lock_guard<std::recursive_timed_mutex> n(mouse_mutex);
mouse_button = button;
}
-int32_t OSD_BASE::get_mouse_button()
+int32_t OSD_BASE::get_mouse_button()
{
std::lock_guard<std::recursive_timed_mutex> n(mouse_mutex);
return mouse_button;
}
}
}
-
+
const _TCHAR *OSD_BASE::get_key_name_by_scancode(uint32_t scancode)
{
if(vm != NULL) {
#else
return 0;
#endif
-}
+}
QString OSD::get_vm_config_name(void)
host_window_width = base_window_width = WINDOW_WIDTH;
host_window_height = base_window_height = WINDOW_HEIGHT;
host_window_mode = true;
-
+
vm_screen_width = SCREEN_WIDTH;
vm_screen_height = SCREEN_HEIGHT;
vm_window_width = WINDOW_WIDTH;
vm_window_height = WINDOW_HEIGHT;
vm_window_width_aspect = WINDOW_WIDTH_ASPECT;
vm_window_height_aspect = WINDOW_HEIGHT_ASPECT;
-
+
QColor col(0, 0, 0, 255);
vm_screen_buffer.width = SCREEN_WIDTH;
vm_screen_buffer.pImage = QImage(SCREEN_WIDTH, SCREEN_HEIGHT, QImage::Format_ARGB32);
vm_screen_buffer.pImage.fill(col);
now_record_video = false;
-
+
first_draw_screen = false;
first_invalidate = true;
self_invalidate = false;
connect(this, SIGNAL(sig_movie_seek_frame(bool, int)), movie_loader, SLOT(do_seek_frame(bool, int)));
//connect(this, SIGNAL(sig_movie_mute(bool, bool)), movie_loader, SLOT(do_mute(bool, bool)));
connect(movie_loader, SIGNAL(sig_decoding_error(int)), this, SLOT(do_video_decoding_error(int)));
-#endif
+#endif
}
void OSD::release_video()
{
#if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
delete movie_loader;
-#endif
+#endif
movie_loader = NULL;
}
if(movie_loader != NULL) {
ret = movie_loader->open(QString::fromUtf8(file_path));
}
-#endif
+#endif
return ret;
}
}
return (uint32_t)pos;
}
-#endif
+#endif
return 0;
}
#if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
//movie_loader->do_decode_frames(frames, SCREEN_WIDTH, SCREEN_HEIGHT);
movie_loader->do_decode_frames(frames, vm_window_width_aspect, vm_window_height_aspect);
-#endif
+#endif
}
void OSD::get_video_buffer()
udp_socket[i] = NULL;
}
}
-#endif
+#endif
}
// ToDo: Really need to lock? 20221011 K.O
std::lock_guard<std::recursive_timed_mutex> lv(vm_mutex);
vm->notify_socket_connected(ch);
-#endif
+#endif
}
}
}
}
- if((p != nullptr) && (vm != nullptr)) {
+ if((p != nullptr) && (vm != nullptr)) {
// recv
bytes = p->bytesAvailable();
if(bytes > 0) {
uint8_t* buf0 = vm->get_socket_recv_buffer0(i, &size0, &size1);
uint8_t* buf1 = vm->get_socket_recv_buffer1(i);
qint64 size;
-
+
if(bytes > (qint64)(size0 + size1)) {
bytes = (qint64)(size0 + size1);
}
}
}
}
-#endif
+#endif
}
bool OSD::initialize_socket_tcp(int ch)
connect(tcp_socket[ch], SIGNAL(sig_connected(int)), this, SLOT(do_notify_socket_connected(int)));
connect(tcp_socket[ch], SIGNAL(disconnected()), tcp_socket[ch], SLOT(do_disconnected()));
connect(tcp_socket[ch], SIGNAL(sig_disconnected(int)), this, SLOT(do_notify_socket_disconnected(int)));
-#endif
+#endif
return true;
}
connect(udp_socket[ch], SIGNAL(sig_connected(int)), this, SLOT(do_notify_socket_connected(int)));
connect(udp_socket[ch], SIGNAL(disconnected()), udp_socket[ch], SLOT(do_disconnected()));
connect(udp_socket[ch], SIGNAL(sig_disconnected(int)), this, SLOT(do_notify_socket_disconnected(int)));
-#endif
+#endif
return true;
}
}
if(vm == nullptr) return;
vm->notify_socket_disconnected(ch);
-#endif
+#endif
}
bool OSD::listen_socket(int ch)
//connect(udp_socket[ch], SIGNAL(sig_connected(int)), this, SLOT(do_notify_socket_connected(int)));
//connect(udp_socket[ch], SIGNAL(disconnected()), udp_socket[ch], SLOT(do_disconnected()));
//connect(udp_socket[ch], SIGNAL(sig_disconnected(int)), this, SLOT(do_notify_socket_disconnected(int)));
-#endif
+#endif
return false;
}
vm->inc_socket_send_buffer_ptr(ch, (int)size2);
}
}
-#endif
+#endif
}
void OSD::send_socket_data_udp(int ch, uint32_t ipaddr, int port)
return;
}
qint64 size2 = 0;
-
+
if(udp_socket[ch] != NULL) {
size2 = udp_socket[ch]->writeDatagram((const char *)buf, (qint64)size, addr, (quint16)port);
if(size2 < 0) {
vm->inc_socket_send_buffer_ptr(ch, (int)size2);
}
}
-#endif
+#endif
}
void OSD::send_socket_data(int ch)
return 0;
}
draw_screen_buffer = &vm_screen_buffer;
-
+
// calculate screen size
// invalidate window
// ToDo: Support MAX_DRAW_RANGES. 20221212 K.O
emit sig_update_screen((void *)draw_screen_buffer, mapped);
first_draw_screen = self_invalidate = true;
-
+
// record avi file
if(now_record_video) {
add_video_frames();
counter++;
}
}
-
+
if(using_flags->is_use_one_board_computer()) {
//int size = vm_screen_buffer.pImage.byteCount();
int i = counter;
if(pixel != 0x000000ff) {
rec_image_buffer.setPixel(xx, yy, pixel);
}
-#endif
+#endif
}
}
if(i > 0) {
emit sig_enqueue_video(i, vm_screen_width, vm_screen_height, &video_result);
//i--;
}
- //p_logger->debug_log(CSP_LOG_DEBUG2, CSP_LOG_TYPE_SCREEN, "Push Video %d frames\n", counter);
+ // _TCHAR __tmps1[128] = {0};
+ // my_stprintf_s(__tmps1, sizeof(__tmps1) - 1, "Push Video %d frames\n", counter);
+ //emit sig_debug_log(CSP_LOG_DEBUG2, CSP_LOG_TYPE_SCREEN, QString::fromUtf8(__tmps1) );
}
return counter;
}
device_node_t sp;
device_node_list.clear();
- p_logger->reset();
+ emit sig_logger_reset();
+
max_vm_nodes = 0;
if(vm == NULL) return;
for(DEVICE *p = vm->first_device; p != NULL; p = p->next_device) {
sp.id = p->this_device_id;
sp.name = p->this_device_name;
- p_logger->set_device_name(sp.id, (char *)sp.name);
- p_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Device %d :%s", sp.id, sp.name);
+ emit sig_logger_set_device_name(sp.id, QString::fromUtf8(sp.name));
+
+ _TCHAR tmps2[512] = {0};
+ my_stprintf_s(tmps2, sizeof(tmps2) - 1, "Device %d :%s", sp.id, sp.name);
+ emit sig_debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, QString::fromUtf8(tmps2));
+
device_node_list.append(sp);
if(max_vm_nodes <= p->this_device_id) max_vm_nodes = p->this_device_id + 1;
}
emit sig_update_device_node_name(p->this_device_id, p->this_device_name);
}
}
-
{
return read_data32w(addr, wait);
}
-
+
//<! i/o bus
void DEVICE::write_io8(uint32_t addr, uint32_t data)
{
return read_io32w(addr, wait);
}
-
+
// memory mapped i/o
void DEVICE::write_memory_mapped_io8(uint32_t addr, uint32_t data)
{
void DEVICE::update_intr()
{
-
+
}
void DEVICE::notify_intr_reti()
void DEVICE::notify_intr_ei()
{
}
-
+
void DEVICE::do_dma()
{
}
{
return 0;
}
-
+
//<! bios
bool DEVICE::bios_call_far_i86(uint32_t PC, uint16_t regs[], const uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag, int* cycles, uint64_t* total_cycles)
{
if(event_manager == NULL) return -1;
return event_manager->release_sound_in_source(bank);
}
-
+
bool DEVICE::is_sound_in_source_exists(int bank)
{
if(event_manager == NULL) {
}
uint64_t DEVICE::get_current_clock_uint64()
-{
+{
__UNLIKELY_IF(event_manager == NULL) {
event_manager = vm->first_device->next_device;
}
// Force render sound immediately when device's status has changed.
// You must call this after you changing registers (or anything).
// If has problems, try set_realtime_render.
-// See mb8877.cpp and ym2203.cpp.
+// See mb8877.cpp and ym2203.cpp.
// -- 20161010 K.O
void DEVICE::touch_sound(void)
{
if(format != NULL) {
va_list ap;
_TCHAR buffer[1024];
-
+
va_start(ap, format);
my_vstprintf_s(buffer, 1024, format, ap);
va_end(ap);
void DEVICE::out_debug_log(const char *fmt, ...)
{
#if defined(_USE_QT)
- __UNLIKELY_IF(p_logger == NULL) return;
- char strbuf[4096];
+ __UNLIKELY_IF(osd == nullptr) return;
+ char strbuf[4096] = {0};
va_list ap;
-
+
va_start(ap, fmt);
vsnprintf(strbuf, 4095, fmt, ap);
- p_logger->debug_log(CSP_LOG_DEBUG, this_device_id + CSP_LOG_TYPE_VM_DEVICE_0, "%s", strbuf);
va_end(ap);
+ osd->debug_log(CSP_LOG_DEBUG, this_device_id + CSP_LOG_TYPE_VM_DEVICE_0, strbuf);
#else
- char strbuf[4096];
+ char strbuf[4096] = {0};
va_list ap;
va_start(ap, fmt);
{
if(!(logging)) return;
#if defined(_USE_QT)
- __UNLIKELY_IF(p_logger == NULL) return;
- char strbuf[4096];
+ __UNLIKELY_IF(osd == nullptr) return;
+ char strbuf[4096] = {0};
va_list ap;
-
+
va_start(ap, fmt);
vsnprintf(strbuf, 4095, fmt, ap);
- p_logger->debug_log(CSP_LOG_DEBUG, this_device_id + CSP_LOG_TYPE_VM_DEVICE_0, "%s", strbuf);
va_end(ap);
+ osd->debug_log(CSP_LOG_DEBUG, this_device_id + CSP_LOG_TYPE_VM_DEVICE_0, strbuf);
+
#else
char strbuf[4096];
va_list ap;
return (const _TCHAR *)__LIBRARY_NAME;
#else
return (const _TCHAR *)"\0";
-#endif
+#endif
}
return true;
}
}
-
#pragma pack()
#pragma pack(1)
/*!
- *
- *
+ *
+ *
*/
typedef struct {
cd_data_head_t header;
#pragma pack()
#pragma pack(1)
/*!
- * @note
+ * @note
* @note 20201116 K.O
*/
typedef union cdimage_buffer_s {
CCD_PREGAP_MODE = 0x201,
CCD_PREGAP_SUBC
};
-
+
enum {
CDROM_READ_MODE1 = 1,
CDROM_READ_MODE2 = 2,
TOWNS_CD_ACCEPT_04H_FOR_CMD_A0H = 0x04,
TOWNS_CD_ACCEPT_08H_FOR_CMD_A0H = 0x08,
TOWNS_CD_ACCEPT_MEDIA_CHANGED = 0x09,
- TOWNS_CD_ACCEPT_WAIT = 0x0d,
+ TOWNS_CD_ACCEPT_WAIT = 0x0d,
};
-
+
// status[1] @ status[0] == 21h
// From Tsugaru Thanks to Yamakawa-San.
enum {
TOWNS_CD_PAUSE_CDDA,
TOWNS_CD_UNPAUSE_CDDA,
};
-
+
/*class TOWNS_CDROM : public SCSI_CDROM */
class TOWNS_CDROM: public DEVICE {
protected:
// For Debugging, will remove 20200822 K.O
DEVICE* d_cpu;
DEVICE* d_dmac;
-
+
uint32_t max_fifo_length;
uint32_t fifo_length;
-
+
uint16_t cpu_id;
uint16_t machine_id;
-
+
uint8_t data_reg;
bool dma_transfer;
bool pio_transfer;
bool cdrom_halted;
bool status_seek;
-
+
SUBC_t subq_buffer[98]; // OK?
int subq_bitptr;
int subq_bitwidth;
bool subq_overrun;
bool is_playing;
-
+
int stat_track;
bool is_cue;
int physical_size;
int logical_size;
} toc_table[108];
- _TCHAR track_data_path[100][_MAX_PATH];
+ _TCHAR track_data_path[101][_MAX_PATH];
_TCHAR img_file_path_bak[_MAX_PATH];
- bool with_filename[100];
+ bool with_filename[101];
uint32_t cdda_start_frame;
uint32_t cdda_end_frame;
int cdda_repeat_count;
bool cdda_interrupt;
int cdda_buffer_ptr;
-
+
int mix_loop_num;
int current_track;
int read_sector;
int next_seek_lba;
int read_mode;
-
+
uint8_t prev_command;
uint8_t latest_command;
uint8_t reserved_command;
bool dma_intr;
bool mcu_intr_mask;
bool dma_intr_mask;
-
+
bool mcuint_val;
-
+
int event_drq;
int event_seek;
int event_next_sector;
int event_delay_command;
int event_time_out;
int event_eot;
-
+
int cdda_sample_l;
int cdda_sample_r;
-
+
int _decibel_l;
int _decibel_r;
int volume_l;
bool mute_left;
bool mute_right;
-
+
uint8_t w_regs[16];
static const uint16_t crc_table[256];
uint8_t param_queue[8];
bool command_received;
-
+
double seek_time;
int track_num;
uint32_t max_logical_block;
uint32_t read_lba;
bool cdrom_prefetch;
-
+
int extra_status;
void play_cdda_from_cmd();
void unpause_cdda_from_cmd();
virtual bool seek_relative_frame_in_image(uint32_t frame_no);
virtual int prefetch_audio_sectors(int sectors);
virtual int __FASTCALL dequeue_audio_data(pair16_t& left, pair16_t& right);
-
+
virtual void read_cdrom();
- virtual int read_sectors_image(int sectors, uint32_t& transferred_bytes);
+ virtual int read_sectors_image(int sectors, uint32_t& transferred_bytes);
bool check_notready_and_changed(bool force_int);
-
+
virtual void execute_command(uint8_t command);
-
+
bool __FASTCALL status_not_ready(bool forceint);
bool __FASTCALL status_media_changed(bool forceint);
bool __FASTCALL status_media_changed_or_not_ready(bool forceint);
-
+
void __FASTCALL status_hardware_error(bool forceint);
void __FASTCALL status_parameter_error(bool forceint);
void __FASTCALL status_read_done(bool forceint);
void __FASTCALL status_data_ready(bool forceint);
-
+
void __FASTCALL status_accept(int extra, uint8_t s2, uint8_t s3);
void __FASTCALL status_not_accept(int extra, uint8_t s1, uint8_t s2, uint8_t s3);
-
+
void __FASTCALL status_illegal_lba(int extra, uint8_t s1, uint8_t s2, uint8_t s3);
void set_delay_ready();
void set_delay_ready_nostatus();
void set_delay_ready_eot();
void set_delay_ready_cddareply();
-
+
uint32_t cdrom_get_adr(int trk);
void __FASTCALL set_dma_intr(bool val);
* @param use_mask true when masking mcu and dma.
*/
void __FASTCALL set_intrs_force(bool mcu, bool dma, bool use_mask = false);
-
+
void __FASTCALL make_bitslice_subc_q(uint8_t *data, int bitwidth);
uint16_t __FASTCALL calc_subc_crc16(uint8_t *databuf, int bytes, uint16_t initval);
virtual bool open_iso_file(const _TCHAR* file_path);
virtual bool open_ccd_file(const _TCHAR* file_path, _TCHAR* img_file_path);
-
+
virtual uint8_t read_subq();
virtual uint8_t get_subq_status();
virtual void set_subq(void);
-
+
virtual int get_track_noop(uint32_t lba);
virtual void get_track_by_track_num(int track);
virtual uint32_t get_image_cur_position();
status_queue = NULL;
_decibel_l = 0;
_decibel_r = 0;
-
+
memset(subq_buffer, 0x00, sizeof(subq_buffer));
-
+
initialize_output_signals(&outputs_drq);
initialize_output_signals(&outputs_mcuint);
set_device_name(_T("FM-Towns CD-ROM drive"));
virtual void __FASTCALL write_io8(uint32_t addr, uint32_t data);
virtual uint32_t __FASTCALL read_dma_io8(uint32_t addr);
virtual void __FASTCALL write_dma_io8(uint32_t addr, uint32_t data);
-
+
virtual void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
virtual uint32_t __FASTCALL read_signal(int id);
-
+
virtual void __FASTCALL event_callback(int event_id, int err);
virtual void __FASTCALL mix(int32_t* buffer, int cnt);
-
+
virtual bool process_state(FILEIO* state_fio, bool loading);
virtual bool mounted();
return 0x1fff; // Will change
}
-
+
virtual void set_volume(int ch, int decibel_l, int decibel_r);
virtual void get_volume(int ch, int& decibel_l, int& decibel_r);
virtual bool read_buffer(int sectors);
{
cpu_id = val & 0x07;
}
-
+
void set_context_mpuint_line(DEVICE* dev, int id, uint32_t mask)
{
register_output_signal(&outputs_mcuint, dev, id, mask);
}
};
-
+
}
// get image file name
if(open_ccd_file(file_path, img_file_path)) {
strncpy(img_file_path_bak, img_file_path, _MAX_PATH - 1);
+// strncpy(img_file_path_bak, file_path, _MAX_PATH - 1);
}
}
bool TOWNS_CDROM::open_ccd_file(const _TCHAR* file_path, _TCHAR* img_file_path)
{
my_stprintf_s(img_file_path, _MAX_PATH, _T("%s.img"), get_file_path_without_extensiton(file_path));
+
if(!FILEIO::IsFileExisting(img_file_path)) {
my_stprintf_s(img_file_path, _MAX_PATH, _T("%s.gz"), get_file_path_without_extensiton(file_path));
if(!FILEIO::IsFileExisting(img_file_path)) {
image_tmp_data_path.clear();
get_long_full_path_name(file_path, full_path_ccd, sizeof(full_path_ccd));
+// out_debug_log(_T("open_ccd_file(): file_path = %s / full_path_ccd = %s"), file_path, full_path_ccd);
const _TCHAR *parent_dir = get_parent_dir((const _TCHAR *)full_path_ccd);
std::map<std::string, int> ccd_phase;
std::map<std::string, int> ccd_enum;
ccd_phase.insert(std::make_pair("[ENTRY ", CCD_PHASE_ENTRY));
ccd_phase.insert(std::make_pair("[SESSION ", CCD_PHASE_SESSION));
ccd_phase.insert(std::make_pair("[TRACK ", CCD_PHASE_TRACK));
- ccd_phase.insert(std::make_pair("[CLONECDCD] ", CCD_PHASE_CLONECD));
+ ccd_phase.insert(std::make_pair("[CLONECD] ", CCD_PHASE_CLONECD));
ccd_phase.insert(std::make_pair("[DISC] ", CCD_PHASE_DISC));
-
+
// [Entry foo]
// ToDo:
// Support AMin/ASec/AFrame and PMin/PSec/PFrame.
// Convert String to upper.
std::transform(line_buf.begin(), line_buf.end(), line_buf.begin(),
[](unsigned char c) -> unsigned char{ return std::toupper(c); });
+// out_debug_log(_T("FILE_PATH=\"%s\" line=\"%s\""), file_path, line_buf.c_str());
//
// Check Phase
;
} catch (std::out_of_range &e) {
arg2 = "";
}
-
+
}
} else if(ptr2 != std::string::npos) {
token.resize(ptr2 + 1);
}
-
+
try {
tmp_phase = ccd_phase.at(token);
} catch (std::out_of_range &e) {
if(tmp_phase != CCD_PHASE_NULL) {
phase = tmp_phase;
}
+// out_debug_log(_T("open_ccd_file(): file_path = %s / full_path_ccd = %s"), file_path, full_path_ccd);
switch(phase) {
case CCD_PHASE_ENTRY:
phase_arg = string_to_numeric(arg2);
}
switch(phase) {
case CCD_PHASE_SESSION:
-
+
// ToDo: Imprement around pregap.
break;
case CCD_PHASE_DISC:
break;
}
break;
+ default:
+ break;
}
}
_n_continue:
toc_table[i].lba_offset = 0;
toc_table[i].lba_size = toc_table[i + 1].index1 - toc_table[i].index0;
}
+
// if((track_num == 2) && (max_logical_block > 0)) {
// toc_table[track_num - 1].lba_size -= 1;
// max_logical_block--;
// }
+
+ // ToDo: Will fix brakes insize of *file_ptr . 20230217 K.O
+#if 1
for(int i = 1; i < track_num; i++) {
// toc_table[i].index0 += toc_table[i].lba_offset;
// toc_table[i].index1 += toc_table[i].lba_offset;
- out_debug_log(_T("TRACK#%02d TYPE=%s PREGAP=%d INDEX0=%d INDEX1=%d LBA_SIZE=%d LBA_OFFSET=%d PATH=%s\n"),
- i, (toc_table[i].is_audio) ? _T("AUDIO") : _T("MODE1/2352"),
- toc_table[i].pregap, toc_table[i].index0, toc_table[i].index1,
- toc_table[i].lba_size, toc_table[i].lba_offset, track_data_path[i - 1]);
+
+ out_debug_log(_T("TRACK#%d TYPE=%s PREGAP=%d INDEX0=%d INDEX1=%d LBA_SIZE=%d LBA_OFFSET=%d"),
+
+ i, ((toc_table[i].is_audio) ? _T("AUDIO") : _T("MODE1/2352")),
+ toc_table[i].pregap, toc_table[i].index0, toc_table[i].index1,
+ toc_table[i].lba_size, toc_table[i].lba_offset);
//#endif
}
-
+#endif
+// out_debug_log(_T("open_ccd_file(): track_num = %d file_path = %s / full_path_ccd = %s"), track_num, file_path, full_path_ccd);
break;
}
}
if((max_logical_block = fio_img->FileLength() / 2352) > 0) {
// read ccd file
FILEIO* fio = new FILEIO();
- if(fio->Fopen(file_path, FILEIO_READ_BINARY)) {
+ if(fio->Fopen(file_path, FILEIO_READ_ASCII)) {
char line[1024] = {0};
char *ptr;
int track = -1;
track = -1;
} else if((ptr = strstr(line, "Point=0x")) != NULL) {
if((track = hexatoi(ptr + 8)) > 0 && track < 0xa0) {
- if((track + 1) > track_num) {
+ if(((track + 1) > track_num) && (track <= 100)) {
track_num = track + 1;
}
}
} else if((ptr = strstr(line, "Control=0x")) != NULL) {
- if(track > 0 && track < 0xa0) {
+ if(track > 0 && track <= 100) {
toc_table[track].is_audio = (hexatoi(ptr + 10) != 4);
}
} else if((ptr = strstr(line, "ALBA=-")) != NULL) {
- if(track > 0 && track < 0xa0) {
+ if(track > 0 && track <= 100) {
toc_table[track].pregap = atoi(ptr + 6);
}
} else if((ptr = strstr(line, "PLBA=")) != NULL) {
- if(track > 0 && track < 0xa0) {
+ if(track > 0 && track <= 100) {
toc_table[track + 1].index0 = atoi(ptr + 5);
}
} else if((ptr = strstr(line, "[TRACK ")) != NULL) {
char numbuf[3] = {0};
strncpy(numbuf, ptr + 7, (size_t)n);
track = atoi(numbuf);
- if((track + 1) > track_num) {
+ if(((track + 1) > track_num) && (track <= 100)) {
track_num = track + 1;
}
}
} else if((ptr = strstr(line, "INDEX 0=")) != NULL) {
- if(track > 0 && track < 0xa0) {
+ if(track > 0 && track <= 100) {
toc_table[track].index0 = atoi(ptr + 8);
}
} else if((ptr = strstr(line, "INDEX 1=")) != NULL) {
- if(track > 0 && track < 0xa0) {
+ if(track > 0 && track <= 100) {
toc_table[track].index1 = atoi(ptr + 8);
}
} else if((ptr = strstr(line, "MODE=")) != NULL) {
- if(track > 0 && track < 0xa0) {
+ if(track > 0 && track <= 100) {
int mode;
mode = atoi(ptr + 5);
switch(mode) {
toc_table[0].physical_size = 0;
toc_table[0].logical_size = 0;
if(track_num > 0) {
+ if(track_num > 100) track_num = 101;
for(int i = 1; i < track_num; i++) {
// ToDo: Some types.
toc_table[i].physical_size = 2352;
image_tmp_data_path.clear();
get_long_full_path_name(file_path, full_path_cue, sizeof(full_path_cue));
-
+
const _TCHAR *parent_dir = get_parent_dir((const _TCHAR *)full_path_cue);
size_t _arg1_ptr;
cue_enum.insert(std::make_pair("INDEX", CUE_INDEX));
cue_enum.insert(std::make_pair("PREGAP", CUE_PREGAP));
-
+
if(fio->Fopen(file_path, FILEIO_READ_ASCII)) { // ToDo: Support not ASCII cue file (i.e. SJIS/UTF8).20181118 K.O
line_buf.clear();
for(int i = 0; i < 100; i++) {
bool is_eof = false;
int sptr = 0;
bool have_filename = false;
-// int _nr_num = 0;
+// int _nr_num = 0;
while(1) {
line_buf.clear();
int _np = 0;
_arg1.clear();
_arg2.clear();
_arg3.clear();
-
+
ptr = line_buf.find_first_not_of((const char*)" \t");
if(ptr == std::string::npos) {
goto _n_continue;
if((nr_current_track > 0) && (nr_current_track < 100)) {
_arg2_ptr_s = _arg2.find_first_of((const char *)" \t");
_arg2 = _arg2.substr(0, _arg2_ptr_s - 1);
-
+
toc_table[nr_current_track].pregap = get_frames_from_msf(_arg2.c_str());
}
break;
for(int i = 1; i < track_num; i++) {
toc_table[i].index0 += toc_table[i].lba_offset;
toc_table[i].index1 += toc_table[i].lba_offset;
+#if 1
out_debug_log(_T("TRACK#%02d TYPE=%s PREGAP=%d INDEX0=%d INDEX1=%d LBA_SIZE=%d LBA_OFFSET=%d PATH=%s\n"),
i, (toc_table[i].is_audio) ? _T("AUDIO") : _T("MODE1/2352"),
toc_table[i].pregap, toc_table[i].index0, toc_table[i].index1,
toc_table[i].lba_size, toc_table[i].lba_offset, track_data_path[i - 1]);
- //#endif
+#endif
}
toc_table[0].index0 = toc_table[0].index1 = toc_table[0].pregap = 0;
toc_table[0].physical_size = 2352;
// Not Cue FILE.
return is_cue;
}
-
+
bool TOWNS_CDROM::parse_cue_file_args(std::string& _arg2, const _TCHAR *parent_dir, std::string& imgpath)
{
size_t _arg2_ptr;
size_t _arg3_ptr;
std::string _arg3;
-
+
_arg2_ptr = _arg2.find_first_of((const char *)"\"") + 1;
if(_arg2_ptr == std::string::npos) return false;
-
+
_arg2 = _arg2.substr(_arg2_ptr);
_arg3_ptr = _arg2.find_first_of((const char *)"\"");
if(_arg3_ptr == std::string::npos) return false;
_arg2 = _arg2.substr(0, _arg3_ptr);
-
+
imgpath.clear();
imgpath = std::string(parent_dir);
imgpath.append(_arg2);
-
+
// cdrom_debug_log(_T("**FILE %s\n"), imgpath.c_str());
return true;
size_t _arg2_ptr_s;
size_t _arg2_ptr;
_arg2_ptr_s = _arg2.find_first_of((const char *)" \t");
-
+
std::string _arg3 = _arg2.substr(_arg2_ptr_s);
_arg2 = _arg2.substr(0, _arg2_ptr_s);
size_t _arg3_ptr = _arg3.find_first_not_of((const char *)" \t");
size_t _arg3_ptr_s;
int _nr_num = atoi(_arg2.c_str());
-
+
// Set image file
if((_nr_num > 0) && (_nr_num < 100) && (_arg3_ptr != std::string::npos)) {
std::map<std::string, int> cue_type;
nr_current_track = _nr_num;
_arg3 = _arg3.substr(_arg3_ptr);
-
+
memset(track_data_path[_nr_num - 1], 0x00, sizeof(_TCHAR) * _MAX_PATH);
strncpy((char *)(track_data_path[_nr_num - 1]), imgpath.c_str(), _MAX_PATH - 1);
// image_tmp_data_path.clear();
// have_filename = false;
_arg3_ptr_s = _arg3.find_first_of((const char *)" \t\n");
_arg3.substr(0, _arg3_ptr_s);
-
+
std::transform(_arg3.begin(), _arg3.end(), _arg3.begin(),
[](unsigned char c) -> unsigned char{ return std::toupper(c); });
-
+
toc_table[nr_current_track].is_audio = false;
toc_table[nr_current_track].index0 = 0;
toc_table[nr_current_track].index1 = 0;
track_type = MODE_NONE;
}
toc_table[nr_current_track].type = track_type;
-
+
switch(track_type) {
case MODE_AUDIO:
- toc_table[nr_current_track].is_audio = true;
+ toc_table[nr_current_track].is_audio = true;
toc_table[nr_current_track].logical_size = 2352;
break;
case MODE_MODE1_2048:
if((nr_current_track > 0) && (nr_current_track < 100)) {
_arg2_ptr_s = _arg2.find_first_of((const char *)" \t");
if(_arg2_ptr_s == std::string::npos) return -1;;
-
+
_arg3 = _arg2.substr(_arg2_ptr_s);
_arg2 = _arg2.substr(0, _arg2_ptr_s);
_arg3_ptr = _arg3.find_first_not_of((const char *)" \t");
if(_arg3_ptr == std::string::npos) return -1;
-
+
_arg3 = _arg3.substr(_arg3_ptr);
_arg3_ptr_s = _arg3.find_first_of((const char *)" \t");
_arg3.substr(0, _arg3_ptr_s);
index = atoi(_arg2.c_str());
-
+
switch(index) {
case 0:
toc_table[nr_current_track].index0 = get_frames_from_msf(_arg3.c_str());
}
return index;
}
-
+
}
OSDN Git Service
