Initial commit

backends/platform/atari/osystem_atari.cpp

@@ -0,0 +1,519 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <gem.h>
+#include <mint/cookie.h>
+#include <mint/falcon.h>
+#include <mint/osbind.h>
+
+#define FORBIDDEN_SYMBOL_EXCEPTION_FILE
+#define FORBIDDEN_SYMBOL_EXCEPTION_fputs
+#define FORBIDDEN_SYMBOL_EXCEPTION_getenv
+#define FORBIDDEN_SYMBOL_EXCEPTION_sprintf
+#define FORBIDDEN_SYMBOL_EXCEPTION_stderr
+#define FORBIDDEN_SYMBOL_EXCEPTION_stdout
+#define FORBIDDEN_SYMBOL_EXCEPTION_time_h
+#define FORBIDDEN_SYMBOL_EXCEPTION_fprintf
+#define FORBIDDEN_SYMBOL_EXCEPTION_exit
+
+#include "backends/platform/atari/osystem_atari.h"
+
+#include "backends/audiocd/default/default-audiocd.h"
+#include "common/config-manager.h"
+#include "backends/events/atari/atari-events.h"
+#include "backends/events/default/default-events.h"
+#include "backends/graphics/atari/atari-graphics.h"
+#include "backends/keymapper/hardware-input.h"
+#include "backends/mixer/atari/atari-mixer.h"
+#include "backends/mutex/null/null-mutex.h"
+#include "backends/platform/atari/atari-debug.h"
+#include "backends/saves/default/default-saves.h"
+#include "backends/timer/default/default-timer.h"
+#include "base/main.h"
+
+#define INPUT_ACTIVE
+
+/*
+ * Include header files needed for the getFilesystemFactory() method.
+ */
+#include "backends/fs/atari/atari-fs-factory.h"
+
+bool g_gameEngineActive = false;
+
+extern "C" void atari_kbdvec(void *);
+extern "C" void atari_mousevec(void *);
+typedef void (*KBDVEC)(void *);
+extern "C" KBDVEC atari_old_kbdvec;
+extern "C" KBDVEC atari_old_mousevec;
+
+extern void nf_init(void);
+extern void nf_print(const char* msg);
+
+static int s_app_id = -1;
+static void (*s_old_procterm)(void) = nullptr;
+
+static volatile uint32 counter_200hz;
+
+static bool s_dtor_already_called = false;
+
+static long atari_200hz_init(void)
+{
+	__asm__ __volatile__(
+	"\tmove		%%sr,-(%%sp)\n"
+	"\tor.w		#0x700,%%sr\n"
+
+	"\tmove.l	0x114.w,old_200hz\n"
+	"\tmove.l	#my_200hz,0x114.w\n"
+
+	"\tmove		(%%sp)+,%%sr\n"
+	"\tjbra		1f\n"
+
+	"\tdc.l		0x58425241\n" /* "XBRA" */
+	"\tdc.l		0x5343554d\n" /* "SCUM" */
+"old_200hz:\n"
+	"\tdc.l		0\n"
+"my_200hz:\n"
+	"\taddq.l	#1,%0\n"
+
+	"\tmove.l	old_200hz(%%pc),-(%%sp)\n"
+	"\trts\n"
+"1:\n"
+	: /* output */
+	: "m"(counter_200hz) /* inputs */
+	: "memory", "cc");
+
+	return 0;
+}
+
+static long atari_200hz_shutdown(void)
+{
+	__asm__ __volatile__(
+	"\tmove		%%sr,-(%%sp)\n"
+	"\tor.w		#0x700,%%sr\n"
+
+	"\tmove.l	old_200hz,0x114.w\n"
+
+	"\tmove		(%%sp)+,%%sr\n"
+	: /* output */
+	: /* inputs */
+	: "memory", "cc");
+
+	return 0;
+}
+
+static void critical_restore() {
+	//atari_debug("critical_restore()");
+
+	Supexec(atari_200hz_shutdown);
+
+#ifdef INPUT_ACTIVE
+	if (atari_old_kbdvec && atari_old_mousevec) {
+		_KBDVECS *kbdvecs = Kbdvbase();
+		((uintptr *)kbdvecs)[-1] = (uintptr)atari_old_kbdvec;
+		kbdvecs->mousevec = atari_old_mousevec;
+		atari_old_kbdvec = atari_old_mousevec = nullptr;
+	}
+
+	// don't call GEM cleanup in the critical handler: it seems that v_clsvwk()
+	// somehow manipulates the same memory area used for the critical handler's stack
+	// what causes v_clsvwk() never returning and leading to a bus error (and another
+	// critical_restore() called...)
+	if (s_app_id != -1) {
+		// ok, restore mouse cursor at least
+		graf_mouse(M_ON, NULL);
+	}
+#endif
+
+	// avoid infinite recursion if either of the shutdown procedures fails
+	(void)Setexc(VEC_PROCTERM, s_old_procterm);
+
+	extern void AtariAudioShutdown();
+	extern void AtariGraphicsShutdown();
+
+	AtariAudioShutdown();
+	AtariGraphicsShutdown();
+}
+
+// called on normal program termination (via exit() or returning from main())
+static void exit_restore() {
+	// causes a crash upon termination
+	//atari_debug("exit_restore()");
+
+	if (!s_dtor_already_called)
+		g_system->destroy();
+	// else critical_restore() will be called, too
+}
+
+OSystem_Atari::OSystem_Atari() {
+	_fsFactory = new AtariFilesystemFactory();
+
+	nf_init();
+
+	enum {
+		VDO_NO_ATARI_HW = 0xffff,
+		VDO_ST = 0,
+		VDO_STE,
+		VDO_TT,
+		VDO_FALCON,
+		VDO_MILAN
+	};
+
+	long vdo = VDO_NO_ATARI_HW<<16;
+	Getcookie(C__VDO, &vdo);
+	vdo >>= 16;
+
+	if (vdo != VDO_TT && vdo != VDO_FALCON) {
+		fprintf(stderr, "ScummVM requires Atari TT/Falcon compatible video\n");
+		exit(EXIT_FAILURE);
+	}
+
+	enum {
+		MCH_ST = 0,
+		MCH_STE,
+		MCH_TT,
+		MCH_FALCON,
+		MCH_CLONE,
+		MCH_ARANYM
+	};
+
+	long mch = MCH_ST<<16;
+	Getcookie(C__MCH, &mch);
+	mch >>= 16;
+
+	if (mch == MCH_ARANYM && Getcookie(C_fVDI, NULL) == C_FOUND) {
+		fprintf(stderr, "Disable fVDI, ScummVM uses XBIOS video calls\n");
+		exit(EXIT_FAILURE);
+	}
+
+#ifdef INPUT_ACTIVE
+	_KBDVECS *kbdvecs = Kbdvbase();
+	atari_old_kbdvec = (KBDVEC)(((uintptr *)kbdvecs)[-1]);
+	atari_old_mousevec = kbdvecs->mousevec;
+
+	((uintptr *)kbdvecs)[-1] = (uintptr)atari_kbdvec;
+	kbdvecs->mousevec = atari_mousevec;
+#endif
+
+	Supexec(atari_200hz_init);
+	_timerInitialized = true;
+
+	// protect against sudden exit()
+	atexit(exit_restore);
+	// protect against sudden crash
+	s_old_procterm = Setexc(VEC_PROCTERM, -1);
+	(void)Setexc(VEC_PROCTERM, critical_restore);
+}
+
+OSystem_Atari::~OSystem_Atari() {
+	atari_debug("OSystem_Atari::~OSystem_Atari()");
+
+	s_dtor_already_called = true;
+
+	// _audiocdManager needs to be deleted before _mixerManager to avoid a crash.
+	delete _audiocdManager;
+	_audiocdManager = nullptr;
+
+	delete _mixerManager;
+	_mixerManager = nullptr;
+
+	delete _graphicsManager;
+	_graphicsManager = nullptr;
+
+	delete _eventManager;
+	_eventManager = nullptr;
+
+	delete _savefileManager;
+	_savefileManager = nullptr;
+
+	delete _timerManager;
+	_timerManager = nullptr;
+
+	delete _fsFactory;
+	_fsFactory = nullptr;
+
+	if (_timerInitialized) {
+		Supexec(atari_200hz_shutdown);
+		_timerInitialized = false;
+	}
+
+	if (atari_old_kbdvec && atari_old_mousevec) {
+		_KBDVECS *kbdvecs = Kbdvbase();
+		((uintptr *)kbdvecs)[-1] = (uintptr)atari_old_kbdvec;
+		kbdvecs->mousevec = atari_old_mousevec;
+		atari_old_kbdvec = atari_old_mousevec = nullptr;
+	}
+
+	if (s_app_id != -1) {
+		//wind_update(END_UPDATE);
+
+		// redraw screen
+		form_dial(FMD_FINISH, 0, 0, 0, 0, 0, 0, _vdi_width, _vdi_height);
+		graf_mouse(M_ON, NULL);
+
+		v_clsvwk(_vdi_handle);
+		appl_exit();
+	}
+
+	// graceful exit
+	(void)Setexc(VEC_PROCTERM, s_old_procterm);
+}
+
+void OSystem_Atari::initBackend() {
+	atari_debug("OSystem_Atari::initBackend()");
+
+	s_app_id = appl_init();
+	if (s_app_id != -1) {
+		// get the ID of the current physical screen workstation
+		int16 dummy;
+		_vdi_handle = graf_handle(&dummy, &dummy, &dummy, &dummy);
+		if (_vdi_handle < 1) {
+			appl_exit();
+			error("graf_handle() failed");
+		}
+
+		int16 work_in[16] = {};
+		int16 work_out[57] = {};
+
+		// open a virtual screen workstation
+		v_opnvwk(work_in, &_vdi_handle, work_out);
+
+		if (_vdi_handle == 0) {
+			appl_exit();
+			error("v_opnvwk() failed");
+		}
+
+		_vdi_width = work_out[0] + 1;
+		_vdi_height = work_out[1] + 1;
+
+#ifdef INPUT_ACTIVE
+		graf_mouse(M_OFF, NULL);
+		// see https://github.com/freemint/freemint/issues/312
+		//wind_update(BEG_UPDATE);
+#endif
+	}
+
+	_timerManager = new DefaultTimerManager();
+	_savefileManager = new DefaultSaveFileManager("saves");
+
+	AtariEventSource *atariEventSource = new AtariEventSource();
+	_eventManager = new DefaultEventManager(makeKeyboardRepeatingEventSource(atariEventSource));
+
+	// AtariGraphicsManager needs _eventManager ready
+	AtariGraphicsManager *atariGraphicsManager = new AtariGraphicsManager();
+	_graphicsManager = atariGraphicsManager;
+
+	atariEventSource->setGraphicsManager(atariGraphicsManager);
+
+#ifdef DISABLE_FANCY_THEMES
+	// On the lite build force "STMIDI" as the audio driver, i.e. do not attempt
+	// to emulate anything by default. That prevents mixing silence and enable
+	// us to stop DMA playback which takes unnecessary cycles.
+	if (!ConfMan.hasKey("music_driver")) {
+		ConfMan.set("music_driver", "stmidi");
+	}
+	if (!ConfMan.hasKey("gm_device")) {
+		ConfMan.set("gm_device", "auto");
+	}
+	if (!ConfMan.hasKey("mt32_device")) {
+		ConfMan.set("mt32_device", "auto");
+	}
+#endif
+
+	_mixerManager = new AtariMixerManager();
+	// Setup and start mixer
+	_mixerManager->init();
+
+	_startTime = counter_200hz;
+
+	BaseBackend::initBackend();
+}
+
+void OSystem_Atari::engineInit() {
+	//atari_debug("engineInit");
+
+	g_gameEngineActive = true;
+}
+
+void OSystem_Atari::engineDone() {
+	//atari_debug("engineDone");
+
+	g_gameEngineActive = false;
+}
+
+Common::MutexInternal *OSystem_Atari::createMutex() {
+	return new NullMutexInternal();
+}
+
+uint32 OSystem_Atari::getMillis(bool skipRecord) {
+	// CLOCKS_PER_SEC is 200, so no need to use floats
+	return 1000 * (counter_200hz - _startTime) / CLOCKS_PER_SEC;
+}
+
+void OSystem_Atari::delayMillis(uint msecs) {
+	const uint32 threshold = getMillis() + msecs;
+	while (getMillis() < threshold) {
+		update();
+	}
+}
+
+void OSystem_Atari::getTimeAndDate(TimeDate &td, bool skipRecord) const {
+	//atari_debug("getTimeAndDate");
+	time_t curTime = time(0);
+	struct tm t = *localtime(&curTime);
+	td.tm_sec = t.tm_sec;
+	td.tm_min = t.tm_min;
+	td.tm_hour = t.tm_hour;
+	td.tm_mday = t.tm_mday;
+	td.tm_mon = t.tm_mon;
+	td.tm_year = t.tm_year;
+	td.tm_wday = t.tm_wday;
+}
+
+Common::KeymapArray OSystem_Atari::getGlobalKeymaps() {
+	Common::KeymapArray globalMaps = BaseBackend::getGlobalKeymaps();
+
+	Common::Keymap *keymap = ((AtariGraphicsManager*)_graphicsManager)->getKeymap();
+	globalMaps.push_back(keymap);
+
+	return globalMaps;
+}
+
+Common::HardwareInputSet *OSystem_Atari::getHardwareInputSet() {
+	Common::CompositeHardwareInputSet *inputSet = new Common::CompositeHardwareInputSet();
+	inputSet->addHardwareInputSet(new Common::MouseHardwareInputSet(Common::defaultMouseButtons));
+	inputSet->addHardwareInputSet(new Common::KeyboardHardwareInputSet(Common::defaultKeys, Common::defaultModifiers));
+
+	return inputSet;
+}
+
+void OSystem_Atari::quit() {
+	atari_debug("OSystem_Atari::quit()");
+
+	if (!s_dtor_already_called)
+		destroy();
+}
+
+void OSystem_Atari::fatalError() {
+	atari_debug("OSystem_Atari::fatalError()");
+
+	quit();
+
+	// let exit_restore() and critical_restore() handle the recovery
+	exit(1);
+}
+
+void OSystem_Atari::logMessage(LogMessageType::Type type, const char *message) {
+	extern long nf_stderr_id;
+
+	static char str[1024+1];
+	snprintf(str, sizeof(str), "[%08d] %s", getMillis(), message);
+
+	if (nf_stderr_id) {
+		nf_print(str);
+	} else {
+		FILE *output = 0;
+
+		if (type == LogMessageType::kInfo || type == LogMessageType::kDebug)
+			output = stdout;
+		else
+			output = stderr;
+
+		fputs(str, output);
+		fflush(output);
+	}
+}
+
+void OSystem_Atari::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
+	{
+		Common::FSDirectory currentDirectory{ Common::Path(getFilesystemFactory()->makeCurrentDirectoryFileNode()->getPath()) };
+		Common::FSDirectory *dataDirectory = currentDirectory.getSubDirectory("data");
+		if (dataDirectory) {
+			Common::FSNode dataNode = dataDirectory->getFSNode();
+			if (dataNode.exists() && dataNode.isDirectory() && dataNode.isReadable()) {
+				s.addDirectory(dataNode.getPath(), priority);
+			}
+		}
+	}
+#ifdef DATA_PATH
+	{
+		// Add the global DATA_PATH to the directory search list
+		// See also OSystem_SDL::addSysArchivesToSearchSet()
+		Common::FSNode dataNode(DATA_PATH);
+		if (dataNode.exists() && dataNode.isDirectory() && dataNode.isReadable()) {
+			s.add(DATA_PATH, new Common::FSDirectory(dataNode, 4), priority);
+		}
+	}
+#endif
+}
+
+Common::Path OSystem_Atari::getDefaultConfigFileName() {
+	const Common::Path baseConfigName = OSystem::getDefaultConfigFileName();
+
+	const char *envVar = getenv("HOME");
+	if (envVar && *envVar) {
+		Common::Path configFile(envVar);
+		configFile.joinInPlace(baseConfigName);
+
+		if (configFile.toString(Common::Path::kNativeSeparator).size() < MAXPATHLEN)
+			return configFile;
+	}
+
+	return baseConfigName;
+}
+
+void OSystem_Atari::update() {
+	// avoid a recursion loop if a timer callback decides to call OSystem::delayMillis()
+	static bool inTimer = false;
+
+	if (!inTimer) {
+		inTimer = true;
+		((DefaultTimerManager *)_timerManager)->checkTimers();
+		inTimer = false;
+	} else {
+		const Common::ConfigManager::Domain *activeDomain = ConfMan.getActiveDomain();
+		assert(activeDomain);
+
+		warning("%s/%s calls update() from timer",
+			activeDomain->getValOrDefault("engineid").c_str(),
+			activeDomain->getValOrDefault("gameid").c_str());
+	}
+
+	((AtariMixerManager *)_mixerManager)->update();
+}
+
+OSystem *OSystem_Atari_create() {
+	return new OSystem_Atari();
+}
+
+int main(int argc, char *argv[]) {
+	g_system = OSystem_Atari_create();
+	assert(g_system);
+
+	// Invoke the actual ScummVM main entry point:
+	int res = scummvm_main(argc, argv);
+	g_system->destroy();
+
+	return res;
+}