scummvm/backends/midi/camd.cpp
2021-12-26 18:48:43 +01:00

289 lines
6.6 KiB
C++

/* 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/>.
*
*/
// Disable symbol overrides so that we can use system headers.
#define FORBIDDEN_SYMBOL_ALLOW_ALL
#include "common/scummsys.h"
#if defined(__amigaos4__) || defined(__MORPHOS__)
#include "common/textconsole.h"
#include "common/error.h"
#include "common/endian.h"
#include "common/util.h"
#include "common/str.h"
#include "audio/musicplugin.h"
#include "audio/mpu401.h"
#include <proto/camd.h>
#include <proto/exec.h>
#include <proto/dos.h>
/*
* CAMD sequencer driver
* Mostly cut'n'pasted from FreeSCI by Christoph Reichenbach
*/
class MidiDriver_CAMD : public MidiDriver_MPU401 {
public:
MidiDriver_CAMD();
int open();
bool isOpen() const { return _isOpen; }
void close();
void send(uint32 b) override;
void sysEx(const byte *msg, uint16 length);
private:
bool _isOpen;
struct Library *_CamdBase;
#if defined(__amigaos4__)
struct CamdIFace *_ICamd;
#endif
struct MidiNode *_midi_node;
struct MidiLink *_midi_link;
char _outport[128];
char *getDevice();
void closeAll();
};
MidiDriver_CAMD::MidiDriver_CAMD()
#if defined(__amigaos4__)
: _isOpen(false), _CamdBase(NULL), _ICamd(NULL), _midi_link(NULL) {
#else
: _isOpen(false), _CamdBase(NULL), _midi_link(NULL) {
#endif
}
int MidiDriver_CAMD::open() {
if (_isOpen)
return MERR_ALREADY_OPEN;
#if defined(__amigaos4__)
_CamdBase = IExec->OpenLibrary("camd.library", 36L);
#else
_CamdBase = OpenLibrary("camd.library", 36L);
#endif
if (!_CamdBase) {
error("Could not open 'camd.library'");
return -1;
}
#if defined(__amigaos4__)
_ICamd = (struct CamdIFace *) IExec->GetInterface(_CamdBase, "main", 1, NULL);
if (!_ICamd) {
closeAll();
error("Error while retrieving CAMD interface");
return -1;
}
#endif
#if defined(__amigaos4__)
_midi_node = _ICamd->CreateMidi(MIDI_MsgQueue, 0L, MIDI_SysExSize, 4096L, MIDI_Name, "scummvm", TAG_END);
#else
TagItem tags[] = { MIDI_MsgQueue, 0L, MIDI_SysExSize, 4096L, MIDI_Name, (ULONG)"scummvm", TAG_END, 0};
_midi_node = CreateMidiA(tags);
#endif
if (!_midi_node) {
closeAll();
error("Could not create CAMD MIDI node");
return -1;
}
char *devicename = getDevice();
if (!devicename) {
closeAll();
error("Could not find an output device");
return MERR_DEVICE_NOT_AVAILABLE;
}
#if defined(__amigaos4__)
_midi_link = _ICamd->AddMidiLink(_midi_node, MLTYPE_Sender, MLINK_Location, devicename, TAG_END);
#else
TagItem tagsLink[] = { MLINK_Location, (ULONG)devicename, TAG_END, 0};
_midi_link = AddMidiLinkA(_midi_node, MLTYPE_Sender, tagsLink);
#endif
if (!_midi_link) {
closeAll();
error("Could not create CAMD MIDI link to '%s'", devicename);
return MERR_CANNOT_CONNECT;
}
_isOpen = true;
return 0;
}
void MidiDriver_CAMD::close() {
MidiDriver_MPU401::close();
closeAll();
}
void MidiDriver_CAMD::send(uint32 b) {
if (!_isOpen) {
warning("MidiDriver_CAMD: Got event while not open");
return;
}
midiDriverCommonSend(b);
ULONG data = READ_LE_UINT32(&b);
#if defined(__amigaos4__)
_ICamd->PutMidi(_midi_link, data);
#else
PutMidi(_midi_link, data);
#endif
}
void MidiDriver_CAMD::sysEx(const byte *msg, uint16 length) {
if (!_isOpen) {
warning("MidiDriver_CAMD: Got SysEx while not open");
return;
}
unsigned char buf[266];
assert(length + 2 <= ARRAYSIZE(buf));
// Add SysEx frame
buf[0] = 0xF0;
memcpy(buf + 1, msg, length);
buf[length + 1] = 0xF7;
// Send it
#if defined(__amigaos4__)
_ICamd->PutSysEx(_midi_link, buf);
#else
PutSysEx(_midi_link, buf);
#endif
}
char *MidiDriver_CAMD::getDevice() {
char *retname = NULL;
#if defined(__amigaos4__)
APTR key = _ICamd->LockCAMD(CD_Linkages);
#else
APTR key = LockCAMD(CD_Linkages);
#endif
if (key != NULL) {
#if defined(__amigaos4__)
struct MidiCluster *cluster = _ICamd->NextCluster(NULL);
#else
struct MidiCluster *cluster = NextCluster(NULL);
#endif
while (cluster && !retname) {
// Get the current cluster name
char *dev = cluster->mcl_Node.ln_Name;
if (strstr(dev, "out") != NULL) {
// This is an output device, return this
Common::strlcpy(_outport, dev, sizeof(_outport));
retname = _outport;
} else {
// Search the next one
#if defined(__amigaos4__)
cluster = _ICamd->NextCluster(cluster);
#else
cluster = NextCluster(cluster);
#endif
}
}
// If the user has a preference outport set, use this instead
#if defined(__amigaos4__)
if(IDOS->GetVar("DefMidiOut", _outport, 128, 0))
#else
if (GetVar("DefMidiOut", _outport, 128, 0))
#endif
retname = _outport;
#if defined(__amigaos4__)
_ICamd->UnlockCAMD(key);
#else
UnlockCAMD(key);
#endif
}
return retname;
}
void MidiDriver_CAMD::closeAll() {
if (_CamdBase) {
#if defined(__amigaos4__)
if (_ICamd)
IExec->DropInterface((struct Interface *)_ICamd);
IExec->CloseLibrary(_CamdBase);
_CamdBase = NULL;
#else
FlushMidi(_midi_node);
if (_midi_link) {
RemoveMidiLink(_midi_link);
_midi_link = NULL;
}
if (_midi_node) {
DeleteMidi(_midi_node);
_midi_node = NULL;
}
CloseLibrary(_CamdBase);
_CamdBase = NULL;
#endif
}
_isOpen = false;
}
// Plugin interface
class CamdMusicPlugin : public MusicPluginObject {
public:
const char *getName() const {
return "CAMD";
}
const char *getId() const {
return "camd";
}
MusicDevices getDevices() const;
Common::Error createInstance(MidiDriver **mididriver, MidiDriver::DeviceHandle = 0) const;
};
MusicDevices CamdMusicPlugin::getDevices() const {
MusicDevices devices;
// TODO: Return a different music type depending on the configuration
// TODO: List the available devices
devices.push_back(MusicDevice(this, "", MT_GM));
return devices;
}
Common::Error CamdMusicPlugin::createInstance(MidiDriver **mididriver, MidiDriver::DeviceHandle) const {
*mididriver = new MidiDriver_CAMD();
return Common::kNoError;
}
REGISTER_PLUGIN_STATIC(CAMD, PLUGIN_TYPE_MUSIC, CamdMusicPlugin);
#endif