mirror of
https://github.com/OpenTTD/OpenTTD.git
synced 2025-02-11 16:54:42 +00:00
Change: [Win32] Replace the current high-level Direct Music driver with a low-level driver that directly works with MIDI data.
This allows using different music sources besides standard MIDI files on disk.
This commit is contained in:
Michael Lutz
parent
3fc9c9522d
commit
255549250f
@ -19,86 +19,464 @@
|
||||
#include "../debug.h"
|
||||
#include "../os/windows/win32.h"
|
||||
#include "../core/mem_func.hpp"
|
||||
#include "../thread/thread.h"
|
||||
#include "dmusic.h"
|
||||
#include "midifile.hpp"
|
||||
#include "midi.h"
|
||||
|
||||
#include <windows.h>
|
||||
#undef FACILITY_DIRECTMUSIC // Needed for newer Windows SDK version.
|
||||
#include <dmksctrl.h>
|
||||
#include <dmusici.h>
|
||||
#include <dmusicc.h>
|
||||
#include <dmusicf.h>
|
||||
|
||||
#include "../safeguards.h"
|
||||
|
||||
static FMusicDriver_DMusic iFMusicDriver_DMusic;
|
||||
|
||||
/** the direct music object manages buffers and ports */
|
||||
static IDirectMusic *music = NULL;
|
||||
|
||||
/** the performance object controls manipulation of the segments */
|
||||
static IDirectMusicPerformance *performance = NULL;
|
||||
|
||||
/** the loader object can load many types of DMusic related files */
|
||||
static IDirectMusicLoader *loader = NULL;
|
||||
|
||||
/** the segment object is where the MIDI data is stored for playback */
|
||||
static IDirectMusicSegment *segment = NULL;
|
||||
|
||||
static bool seeking = false;
|
||||
static const int MS_TO_REFTIME = 1000 * 10; ///< DirectMusic time base is 100 ns.
|
||||
static const int MIDITIME_TO_REFTIME = 10; ///< Time base of the midi file reader is 1 us.
|
||||
|
||||
|
||||
#define M(x) x "\0"
|
||||
static const char ole_files[] =
|
||||
M("ole32.dll")
|
||||
M("CoCreateInstance")
|
||||
M("CoInitialize")
|
||||
M("CoUninitialize")
|
||||
M("")
|
||||
;
|
||||
#undef M
|
||||
|
||||
struct ProcPtrs {
|
||||
unsigned long (WINAPI * CoCreateInstance)(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID *ppv);
|
||||
HRESULT (WINAPI * CoInitialize)(LPVOID pvReserved);
|
||||
void (WINAPI * CoUninitialize)();
|
||||
struct PlaybackSegment {
|
||||
uint32 start, end;
|
||||
size_t start_block;
|
||||
bool loop;
|
||||
};
|
||||
|
||||
static ProcPtrs proc;
|
||||
static struct {
|
||||
bool shutdown; ///< flag to indicate playback thread shutdown
|
||||
bool playing; ///< flag indicating that playback is active
|
||||
bool do_start; ///< flag for starting playback of next_file at next opportunity
|
||||
bool do_stop; ///< flag for stopping playback at next opportunity
|
||||
|
||||
int preload_time; ///< preload time for music blocks.
|
||||
byte new_volume; ///< volume setting to change to
|
||||
|
||||
MidiFile next_file; ///< upcoming file to play
|
||||
PlaybackSegment next_segment; ///< segment info for upcoming file
|
||||
} _playback;
|
||||
|
||||
/** Handle to our worker thread. */
|
||||
static ThreadObject *_dmusic_thread = NULL;
|
||||
/** Event to signal the thread that it should look at a state change. */
|
||||
static HANDLE _thread_event = NULL;
|
||||
/** Lock access to playback data that is not thread-safe. */
|
||||
static ThreadMutex *_thread_mutex = NULL;
|
||||
|
||||
/** The direct music object manages buffers and ports. */
|
||||
static IDirectMusic *_music = NULL;
|
||||
/** The port object lets us send MIDI data to the synthesizer. */
|
||||
static IDirectMusicPort *_port = NULL;
|
||||
/** The buffer object collects the data to sent. */
|
||||
static IDirectMusicBuffer *_buffer = NULL;
|
||||
/** List of downloaded DLS instruments. */
|
||||
static std::vector<IDirectMusicDownloadedInstrument *> _loaded_instruments;
|
||||
|
||||
|
||||
static FMusicDriver_DMusic iFMusicDriver_DMusic;
|
||||
|
||||
|
||||
|
||||
|
||||
static byte ScaleVolume(byte original, byte scale)
|
||||
{
|
||||
return original * scale / 127;
|
||||
}
|
||||
|
||||
static void TransmitChannelMsg(IDirectMusicBuffer *buffer, REFERENCE_TIME rt, byte status, byte p1, byte p2 = 0)
|
||||
{
|
||||
if (buffer->PackStructured(rt, 0, status | (p1 << 8) | (p2 << 16)) == E_OUTOFMEMORY) {
|
||||
/* Buffer is full, clear it and try again. */
|
||||
_port->PlayBuffer(buffer);
|
||||
buffer->Flush();
|
||||
|
||||
buffer->PackStructured(rt, 0, status | (p1 << 8) | (p2 << 16));
|
||||
}
|
||||
}
|
||||
|
||||
static void TransmitSysex(IDirectMusicBuffer *buffer, REFERENCE_TIME rt, byte *&msg_start, size_t &remaining)
|
||||
{
|
||||
/* Find end of message. */
|
||||
byte *msg_end = msg_start;
|
||||
while (*msg_end != MIDIST_ENDSYSEX) msg_end++;
|
||||
msg_end++; // Also include SysEx end byte.
|
||||
|
||||
if (buffer->PackUnstructured(rt, 0, msg_end - msg_start, msg_start) == E_OUTOFMEMORY) {
|
||||
/* Buffer is full, clear it and try again. */
|
||||
_port->PlayBuffer(buffer);
|
||||
buffer->Flush();
|
||||
|
||||
buffer->PackUnstructured(rt, 0, msg_end - msg_start, msg_start);
|
||||
}
|
||||
|
||||
/* Update position in buffer. */
|
||||
remaining -= msg_end - msg_start;
|
||||
msg_start = msg_end;
|
||||
}
|
||||
|
||||
static void TransmitSysexConst(IDirectMusicBuffer *buffer, REFERENCE_TIME rt, byte *msg_start, size_t length)
|
||||
{
|
||||
TransmitSysex(buffer, rt, msg_start, length);
|
||||
}
|
||||
|
||||
/** Transmit 'Note off' messages to all MIDI channels. */
|
||||
static void TransmitNotesOff(IDirectMusicBuffer *buffer, REFERENCE_TIME block_time, REFERENCE_TIME cur_time)
|
||||
{
|
||||
for (int ch = 0; ch < 16; ch++) {
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_MODE_ALLNOTESOFF, 0);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_SUSTAINSW, 0);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_MODE_RESETALLCTRL, 0);
|
||||
}
|
||||
/* Explicitly flush buffer to make sure the note off messages are processed
|
||||
* before we send any additional control messages. */
|
||||
_port->PlayBuffer(_buffer);
|
||||
_buffer->Flush();
|
||||
|
||||
/* Some songs change the "Pitch bend range" registered parameter. If
|
||||
* this doesn't get reset, everything else will start sounding wrong. */
|
||||
for (int ch = 0; ch < 16; ch++) {
|
||||
/* Running status, only need status for first message
|
||||
* Select RPN 00.00, set value to 02.00, and de-select again */
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_RPN_SELECT_LO, 0x00);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDICT_RPN_SELECT_HI, 0x00);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDICT_DATAENTRY, 0x02);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDICT_DATAENTRY_LO, 0x00);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDICT_RPN_SELECT_LO, 0x7F);
|
||||
TransmitChannelMsg(_buffer, block_time + 10, MIDICT_RPN_SELECT_HI, 0x7F);
|
||||
|
||||
_port->PlayBuffer(_buffer);
|
||||
_buffer->Flush();
|
||||
}
|
||||
|
||||
/* Wait until message time has passed. */
|
||||
Sleep(Clamp((block_time - cur_time) / MS_TO_REFTIME, 5, 1000));
|
||||
}
|
||||
|
||||
static void MidiThreadProc(void *)
|
||||
{
|
||||
DEBUG(driver, 2, "DMusic: Entering playback thread");
|
||||
|
||||
REFERENCE_TIME last_volume_time = 0; // timestamp of the last volume change
|
||||
REFERENCE_TIME block_time = 0; // timestamp of the last block sent to the port
|
||||
REFERENCE_TIME playback_start_time; // timestamp current file began playback
|
||||
MidiFile current_file; // file currently being played from
|
||||
PlaybackSegment current_segment; // segment info for current playback
|
||||
size_t current_block; // next block index to send
|
||||
byte current_volume = 0; // current effective volume setting
|
||||
byte channel_volumes[16]; // last seen volume controller values in raw data
|
||||
|
||||
/* Get pointer to the reference clock of our output port. */
|
||||
IReferenceClock *clock;
|
||||
_port->GetLatencyClock(&clock);
|
||||
|
||||
REFERENCE_TIME cur_time;
|
||||
clock->GetTime(&cur_time);
|
||||
|
||||
/* Standard "Enable General MIDI" message */
|
||||
static byte gm_enable_sysex[] = { 0xF0, 0x7E, 0x00, 0x09, 0x01, 0xF7 };
|
||||
TransmitSysexConst(_buffer, cur_time, &gm_enable_sysex[0], sizeof(gm_enable_sysex));
|
||||
/* Roland-specific reverb room control, used by the original game */
|
||||
static byte roland_reverb_sysex[] = { 0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x01, 0x30, 0x02, 0x04, 0x00, 0x40, 0x40, 0x00, 0x00, 0x09, 0xF7 };
|
||||
TransmitSysexConst(_buffer, cur_time, &roland_reverb_sysex[0], sizeof(roland_reverb_sysex));
|
||||
|
||||
_port->PlayBuffer(_buffer);
|
||||
_buffer->Flush();
|
||||
|
||||
DWORD next_timeout = 1000;
|
||||
while (true) {
|
||||
/* Wait for a signal from the GUI thread or until the time for the next event has come. */
|
||||
DWORD wfso = WaitForSingleObject(_thread_event, next_timeout);
|
||||
|
||||
if (_playback.shutdown) {
|
||||
_playback.playing = false;
|
||||
break;
|
||||
}
|
||||
|
||||
if (_playback.do_stop) {
|
||||
DEBUG(driver, 2, "DMusic thread: Stopping playback");
|
||||
|
||||
/* Turn all notes off and wait a bit to allow the messages to be handled. */
|
||||
clock->GetTime(&cur_time);
|
||||
TransmitNotesOff(_buffer, block_time, cur_time);
|
||||
|
||||
_playback.playing = false;
|
||||
_playback.do_stop = false;
|
||||
block_time = 0;
|
||||
next_timeout = 1000;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (wfso == WAIT_OBJECT_0) {
|
||||
if (_playback.do_start) {
|
||||
DEBUG(driver, 2, "DMusic thread: Starting playback");
|
||||
{
|
||||
/* New scope to limit the time the mutex is locked. */
|
||||
ThreadMutexLocker lock(_thread_mutex);
|
||||
|
||||
current_file.MoveFrom(_playback.next_file);
|
||||
std::swap(_playback.next_segment, current_segment);
|
||||
current_segment.start_block = 0;
|
||||
current_block = 0;
|
||||
_playback.playing = true;
|
||||
_playback.do_start = false;
|
||||
}
|
||||
|
||||
/* Turn all notes off in case we are seeking between music titles. */
|
||||
clock->GetTime(&cur_time);
|
||||
TransmitNotesOff(_buffer, block_time, cur_time);
|
||||
|
||||
MemSetT<byte>(channel_volumes, 127, lengthof(channel_volumes));
|
||||
|
||||
/* Take the current time plus the preload time as the music start time. */
|
||||
clock->GetTime(&playback_start_time);
|
||||
playback_start_time += _playback.preload_time * MS_TO_REFTIME;
|
||||
}
|
||||
}
|
||||
|
||||
if (_playback.playing) {
|
||||
/* skip beginning of file? */
|
||||
if (current_segment.start > 0 && current_block == 0 && current_segment.start_block == 0) {
|
||||
/* find first block after start time and pretend playback started earlier
|
||||
* this is to allow all blocks prior to the actual start to still affect playback,
|
||||
* as they may contain important controller and program changes */
|
||||
size_t preload_bytes = 0;
|
||||
for (size_t bl = 0; bl < current_file.blocks.size(); bl++) {
|
||||
MidiFile::DataBlock &block = current_file.blocks[bl];
|
||||
preload_bytes += block.data.Length();
|
||||
if (block.ticktime >= current_segment.start) {
|
||||
if (current_segment.loop) {
|
||||
DEBUG(driver, 2, "DMusic: timer: loop from block %d (ticktime %d, realtime %.3f, bytes %d)", (int)bl, (int)block.ticktime, ((int)block.realtime) / 1000.0, (int)preload_bytes);
|
||||
current_segment.start_block = bl;
|
||||
break;
|
||||
} else {
|
||||
DEBUG(driver, 2, "DMusic: timer: start from block %d (ticktime %d, realtime %.3f, bytes %d)", (int)bl, (int)block.ticktime, ((int)block.realtime) / 1000.0, (int)preload_bytes);
|
||||
playback_start_time -= block.realtime * MIDITIME_TO_REFTIME;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Get current playback timestamp. */
|
||||
REFERENCE_TIME current_time;
|
||||
clock->GetTime(¤t_time);
|
||||
|
||||
/* Check for volume change. */
|
||||
if (current_volume != _playback.new_volume) {
|
||||
if (current_time - last_volume_time > 10 * MS_TO_REFTIME) {
|
||||
DEBUG(driver, 2, "DMusic thread: volume change");
|
||||
current_volume = _playback.new_volume;
|
||||
last_volume_time = current_time;
|
||||
for (int ch = 0; ch < 16; ch++) {
|
||||
int vol = ScaleVolume(channel_volumes[ch], current_volume);
|
||||
TransmitChannelMsg(_buffer, block_time + 1, MIDIST_CONTROLLER | ch, MIDICT_CHANVOLUME, vol);
|
||||
}
|
||||
_port->PlayBuffer(_buffer);
|
||||
_buffer->Flush();
|
||||
}
|
||||
}
|
||||
|
||||
while (current_block < current_file.blocks.size()) {
|
||||
MidiFile::DataBlock &block = current_file.blocks[current_block];
|
||||
|
||||
/* check that block is not in the future */
|
||||
REFERENCE_TIME playback_time = current_time - playback_start_time;
|
||||
if (block.realtime * MIDITIME_TO_REFTIME > playback_time + 3 *_playback.preload_time * MS_TO_REFTIME) {
|
||||
/* Stop the thread loop until we are at the preload time of the next block. */
|
||||
next_timeout = Clamp(((int64)block.realtime * MIDITIME_TO_REFTIME - playback_time) / MS_TO_REFTIME - _playback.preload_time, 0, 1000);
|
||||
DEBUG(driver, 9, "DMusic thread: Next event in %u ms (music %u, ref %lld)", next_timeout, block.realtime * MIDITIME_TO_REFTIME, playback_time);
|
||||
break;
|
||||
}
|
||||
/* check that block isn't at end-of-song override */
|
||||
if (current_segment.end > 0 && block.ticktime >= current_segment.end) {
|
||||
if (current_segment.loop) {
|
||||
DEBUG(driver, 2, "DMusic thread: Looping song");
|
||||
current_block = current_segment.start_block;
|
||||
playback_start_time = current_time - current_file.blocks[current_block].realtime * MIDITIME_TO_REFTIME;
|
||||
} else {
|
||||
_playback.do_stop = true;
|
||||
}
|
||||
next_timeout = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Timestamp of the current block. */
|
||||
block_time = playback_start_time + block.realtime * MIDITIME_TO_REFTIME;
|
||||
DEBUG(driver, 9, "DMusic thread: Streaming block %Iu (cur=%lld, block=%lld)", current_block, (long long)(current_time / MS_TO_REFTIME), (long long)(block_time / MS_TO_REFTIME));
|
||||
|
||||
byte *data = block.data.Begin();
|
||||
size_t remaining = block.data.Length();
|
||||
byte last_status = 0;
|
||||
while (remaining > 0) {
|
||||
/* MidiFile ought to have converted everything out of running status,
|
||||
* but handle it anyway just to be safe */
|
||||
byte status = data[0];
|
||||
if (status & 0x80) {
|
||||
last_status = status;
|
||||
data++;
|
||||
remaining--;
|
||||
} else {
|
||||
status = last_status;
|
||||
}
|
||||
switch (status & 0xF0) {
|
||||
case MIDIST_PROGCHG:
|
||||
case MIDIST_CHANPRESS:
|
||||
/* 2 byte channel messages */
|
||||
TransmitChannelMsg(_buffer, block_time, status, data[0]);
|
||||
data++;
|
||||
remaining--;
|
||||
break;
|
||||
case MIDIST_NOTEOFF:
|
||||
case MIDIST_NOTEON:
|
||||
case MIDIST_POLYPRESS:
|
||||
case MIDIST_PITCHBEND:
|
||||
/* 3 byte channel messages */
|
||||
TransmitChannelMsg(_buffer, block_time, status, data[0], data[1]);
|
||||
data += 2;
|
||||
remaining -= 2;
|
||||
break;
|
||||
case MIDIST_CONTROLLER:
|
||||
/* controller change */
|
||||
if (data[0] == MIDICT_CHANVOLUME) {
|
||||
/* volume controller, adjust for user volume */
|
||||
channel_volumes[status & 0x0F] = data[1];
|
||||
int vol = ScaleVolume(data[1], current_volume);
|
||||
TransmitChannelMsg(_buffer, block_time, status, data[0], vol);
|
||||
} else {
|
||||
/* handle other controllers normally */
|
||||
TransmitChannelMsg(_buffer, block_time, status, data[0], data[1]);
|
||||
}
|
||||
data += 2;
|
||||
remaining -= 2;
|
||||
break;
|
||||
case 0xF0:
|
||||
/* system messages */
|
||||
switch (status) {
|
||||
case MIDIST_SYSEX: /* system exclusive */
|
||||
TransmitSysex(_buffer, block_time, data, remaining);
|
||||
break;
|
||||
case MIDIST_TC_QFRAME: /* time code quarter frame */
|
||||
case MIDIST_SONGSEL: /* song select */
|
||||
data++;
|
||||
remaining--;
|
||||
break;
|
||||
case MIDIST_SONGPOSPTR: /* song position pointer */
|
||||
data += 2;
|
||||
remaining -= 2;
|
||||
break;
|
||||
default: /* remaining have no data bytes */
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
current_block++;
|
||||
}
|
||||
|
||||
/* Anything in the playback buffer? Send it down the port. */
|
||||
DWORD used_buffer = 0;
|
||||
_buffer->GetUsedBytes(&used_buffer);
|
||||
if (used_buffer > 0) {
|
||||
_port->PlayBuffer(_buffer);
|
||||
_buffer->Flush();
|
||||
}
|
||||
|
||||
/* end? */
|
||||
if (current_block == current_file.blocks.size()) {
|
||||
if (current_segment.loop) {
|
||||
current_block = 0;
|
||||
clock->GetTime(&playback_start_time);
|
||||
} else {
|
||||
_playback.do_stop = true;
|
||||
}
|
||||
next_timeout = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DEBUG(driver, 2, "DMusic: Exiting playback thread");
|
||||
|
||||
/* Turn all notes off and wait a bit to allow the messages to be handled by real hardware. */
|
||||
clock->GetTime(&cur_time);
|
||||
TransmitNotesOff(_buffer, block_time, cur_time);
|
||||
Sleep(_playback.preload_time * 4);
|
||||
|
||||
clock->Release();
|
||||
}
|
||||
|
||||
static const char *LoadDefaultDLSFile()
|
||||
{
|
||||
DMUS_PORTCAPS caps;
|
||||
MemSetT(&caps, 0);
|
||||
caps.dwSize = sizeof(DMUS_PORTCAPS);
|
||||
_port->GetCaps(&caps);
|
||||
|
||||
if ((caps.dwFlags & (DMUS_PC_DLS | DMUS_PC_DLS2)) != 0 && (caps.dwFlags & DMUS_PC_GMINHARDWARE) == 0) {
|
||||
/* DLS synthesizer and no built-in GM sound set, need to download one. */
|
||||
IDirectMusicLoader *loader = NULL;
|
||||
proc.CoCreateInstance(CLSID_DirectMusicLoader, NULL, CLSCTX_INPROC, IID_IDirectMusicLoader, (LPVOID *)&loader);
|
||||
if (loader == NULL) return "Can't create DLS loader";
|
||||
|
||||
DMUS_OBJECTDESC desc;
|
||||
MemSetT(&desc, 0);
|
||||
desc.dwSize = sizeof(DMUS_OBJECTDESC);
|
||||
desc.guidClass = CLSID_DirectMusicCollection;
|
||||
desc.guidObject = GUID_DefaultGMCollection;
|
||||
desc.dwValidData = (DMUS_OBJ_CLASS | DMUS_OBJ_OBJECT);
|
||||
|
||||
IDirectMusicCollection *collection = NULL;
|
||||
if (FAILED(loader->GetObjectW(&desc, IID_IDirectMusicCollection, (LPVOID *)&collection))) {
|
||||
loader->Release();
|
||||
return "Can't load GM DLS collection";
|
||||
}
|
||||
|
||||
/* Download instruments to synthesizer. */
|
||||
DWORD idx = 0;
|
||||
DWORD patch = 0;
|
||||
while (collection->EnumInstrument(idx++, &patch, NULL, 0) == S_OK) {
|
||||
IDirectMusicInstrument *instrument = NULL;
|
||||
if (SUCCEEDED(collection->GetInstrument(patch, &instrument))) {
|
||||
IDirectMusicDownloadedInstrument *loaded = NULL;
|
||||
if (SUCCEEDED(_port->DownloadInstrument(instrument, &loaded, NULL, 0))) {
|
||||
_loaded_instruments.push_back(loaded);
|
||||
}
|
||||
instrument->Release();
|
||||
}
|
||||
}
|
||||
|
||||
collection->Release();
|
||||
loader->Release();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
const char *MusicDriver_DMusic::Start(const char * const *parm)
|
||||
{
|
||||
if (performance != NULL) return NULL;
|
||||
|
||||
if (proc.CoCreateInstance == NULL) {
|
||||
if (!LoadLibraryList((Function*)&proc, ole_files)) {
|
||||
return "ole32.dll load failed";
|
||||
}
|
||||
}
|
||||
|
||||
/* Initialize COM */
|
||||
if (FAILED(proc.CoInitialize(NULL))) {
|
||||
return "COM initialization failed";
|
||||
}
|
||||
if (FAILED(CoInitializeEx(NULL, COINITBASE_MULTITHREADED))) return "COM initialization failed";
|
||||
|
||||
/* create the performance object */
|
||||
if (FAILED(proc.CoCreateInstance(
|
||||
CLSID_DirectMusicPerformance,
|
||||
/* Create the DirectMusic object */
|
||||
if (FAILED(CoCreateInstance(
|
||||
CLSID_DirectMusic,
|
||||
NULL,
|
||||
CLSCTX_INPROC,
|
||||
IID_IDirectMusicPerformance,
|
||||
(LPVOID*)&performance
|
||||
IID_IDirectMusic,
|
||||
(LPVOID*)&_music
|
||||
))) {
|
||||
return "Failed to create the performance object";
|
||||
return "Failed to create the music object";
|
||||
}
|
||||
|
||||
/* initialize it */
|
||||
if (FAILED(performance->Init(&music, NULL, NULL))) {
|
||||
return "Failed to initialize performance object";
|
||||
}
|
||||
/* Assign sound output device. */
|
||||
if (FAILED(_music->SetDirectSound(NULL, NULL))) return "Can't set DirectSound interface";
|
||||
|
||||
int port = GetDriverParamInt(parm, "port", -1);
|
||||
/* MIDI events need to be send to the synth in time before their playback time
|
||||
* has come. By default, we try send any events at least 50 ms before playback. */
|
||||
_playback.preload_time = GetDriverParamInt(parm, "preload", 50);
|
||||
|
||||
int pIdx = GetDriverParamInt(parm, "port", -1);
|
||||
if (_debug_driver_level > 0) {
|
||||
/* Print all valid output ports. */
|
||||
char desc[DMUS_MAX_DESCRIPTION];
|
||||
@ -108,69 +486,55 @@ const char *MusicDriver_DMusic::Start(const char * const *parm)
|
||||
caps.dwSize = sizeof(DMUS_PORTCAPS);
|
||||
|
||||
DEBUG(driver, 1, "Detected DirectMusic ports:");
|
||||
for (int i = 0; music->EnumPort(i, &caps) == S_OK; i++) {
|
||||
for (int i = 0; _music->EnumPort(i, &caps) == S_OK; i++) {
|
||||
if (caps.dwClass == DMUS_PC_OUTPUTCLASS) {
|
||||
/* Description is UNICODE even for ANSI build. */
|
||||
DEBUG(driver, 1, " %d: %s%s", i, convert_from_fs(caps.wszDescription, desc, lengthof(desc)), i == port ? " (selected)" : "");
|
||||
DEBUG(driver, 1, " %d: %s%s", i, convert_from_fs(caps.wszDescription, desc, lengthof(desc)), i == pIdx ? " (selected)" : "");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
IDirectMusicPort *music_port = NULL; // NULL means 'use default port'.
|
||||
|
||||
if (port >= 0) {
|
||||
GUID guidPort;
|
||||
if (pIdx >= 0) {
|
||||
/* Check if the passed port is a valid port. */
|
||||
DMUS_PORTCAPS caps;
|
||||
MemSetT(&caps, 0);
|
||||
caps.dwSize = sizeof(DMUS_PORTCAPS);
|
||||
if (FAILED(music->EnumPort(port, &caps))) return "Supplied port parameter is not a valid port";
|
||||
if (FAILED(_music->EnumPort(pIdx, &caps))) return "Supplied port parameter is not a valid port";
|
||||
if (caps.dwClass != DMUS_PC_OUTPUTCLASS) return "Supplied port parameter is not an output port";
|
||||
|
||||
/* Create new port. */
|
||||
DMUS_PORTPARAMS params;
|
||||
MemSetT(¶ms, 0);
|
||||
params.dwSize = sizeof(DMUS_PORTPARAMS);
|
||||
params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
|
||||
params.dwChannelGroups = 1;
|
||||
|
||||
if (FAILED(music->CreatePort(caps.guidPort, ¶ms, &music_port, NULL))) {
|
||||
return "Failed to create port";
|
||||
}
|
||||
|
||||
/* Activate port. */
|
||||
if (FAILED(music_port->Activate(TRUE))) {
|
||||
music_port->Release();
|
||||
return "Failed to activate port";
|
||||
}
|
||||
guidPort = caps.guidPort;
|
||||
} else {
|
||||
if (FAILED(_music->GetDefaultPort(&guidPort))) return "Can't query default music port";
|
||||
}
|
||||
|
||||
/* Add port to performance. */
|
||||
if (FAILED(performance->AddPort(music_port))) {
|
||||
if (music_port != NULL) music_port->Release();
|
||||
return "AddPort failed";
|
||||
}
|
||||
/* Create new port. */
|
||||
DMUS_PORTPARAMS params;
|
||||
MemSetT(¶ms, 0);
|
||||
params.dwSize = sizeof(DMUS_PORTPARAMS);
|
||||
params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
|
||||
params.dwChannelGroups = 1;
|
||||
if (FAILED(_music->CreatePort(guidPort, ¶ms, &_port, NULL))) return "Failed to create port";
|
||||
/* Activate port. */
|
||||
if (FAILED(_port->Activate(TRUE))) return "Failed to activate port";
|
||||
|
||||
/* Assign a performance channel block to the performance if we added
|
||||
* a custom port to the performance. */
|
||||
if (music_port != NULL) {
|
||||
if (FAILED(performance->AssignPChannelBlock(0, music_port, 1))) {
|
||||
music_port->Release();
|
||||
return "Failed to assign PChannel block";
|
||||
}
|
||||
/* We don't need the port anymore. */
|
||||
music_port->Release();
|
||||
}
|
||||
/* Create playback buffer. */
|
||||
DMUS_BUFFERDESC desc;
|
||||
MemSetT(&desc, 0);
|
||||
desc.dwSize = sizeof(DMUS_BUFFERDESC);
|
||||
desc.guidBufferFormat = KSDATAFORMAT_SUBTYPE_DIRECTMUSIC;
|
||||
desc.cbBuffer = 1024;
|
||||
if (FAILED(_music->CreateMusicBuffer(&desc, &_buffer, NULL))) return "Failed to create music buffer";
|
||||
|
||||
/* create the loader object; this will be used to load the MIDI file */
|
||||
if (FAILED(proc.CoCreateInstance(
|
||||
CLSID_DirectMusicLoader,
|
||||
NULL,
|
||||
CLSCTX_INPROC,
|
||||
IID_IDirectMusicLoader,
|
||||
(LPVOID*)&loader
|
||||
))) {
|
||||
return "Failed to create loader object";
|
||||
}
|
||||
const char *dls = LoadDefaultDLSFile();
|
||||
if (dls != NULL) return dls;
|
||||
|
||||
/* Create playback thread and synchronization primitives. */
|
||||
_thread_event = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||||
if (_thread_event == NULL) return "Can't create thread shutdown event";
|
||||
_thread_mutex = ThreadMutex::New();
|
||||
if (_thread_mutex == NULL) return "Can't create thread mutex";
|
||||
|
||||
if (!ThreadObject::New(&MidiThreadProc, this, &_dmusic_thread, "ottd:dmusic")) return "Can't create MIDI output thread";
|
||||
|
||||
return NULL;
|
||||
}
|
||||
@ -184,114 +548,72 @@ MusicDriver_DMusic::~MusicDriver_DMusic()
|
||||
|
||||
void MusicDriver_DMusic::Stop()
|
||||
{
|
||||
seeking = false;
|
||||
|
||||
if (performance != NULL) performance->Stop(NULL, NULL, 0, 0);
|
||||
|
||||
if (segment != NULL) {
|
||||
segment->SetParam(GUID_Unload, 0xFFFFFFFF, 0, 0, performance);
|
||||
segment->Release();
|
||||
segment = NULL;
|
||||
if (_dmusic_thread != NULL) {
|
||||
_playback.shutdown = true;
|
||||
SetEvent(_thread_event);
|
||||
_dmusic_thread->Join();
|
||||
}
|
||||
|
||||
if (music != NULL) {
|
||||
music->Release();
|
||||
music = NULL;
|
||||
/* Unloaded any instruments we loaded. */
|
||||
for (std::vector<IDirectMusicDownloadedInstrument *>::iterator i = _loaded_instruments.begin(); i != _loaded_instruments.end(); i++) {
|
||||
_port->UnloadInstrument(*i);
|
||||
(*i)->Release();
|
||||
}
|
||||
_loaded_instruments.clear();
|
||||
|
||||
if (_buffer != NULL) {
|
||||
_buffer->Release();
|
||||
_buffer = NULL;
|
||||
}
|
||||
|
||||
if (performance != NULL) {
|
||||
performance->CloseDown();
|
||||
performance->Release();
|
||||
performance = NULL;
|
||||
if (_port != NULL) {
|
||||
_port->Activate(FALSE);
|
||||
_port->Release();
|
||||
_port = NULL;
|
||||
}
|
||||
|
||||
if (loader != NULL) {
|
||||
loader->Release();
|
||||
loader = NULL;
|
||||
if (_music != NULL) {
|
||||
_music->Release();
|
||||
_music = NULL;
|
||||
}
|
||||
|
||||
proc.CoUninitialize();
|
||||
CloseHandle(_thread_event);
|
||||
delete _thread_mutex;
|
||||
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
|
||||
void MusicDriver_DMusic::PlaySong(const char *filename)
|
||||
{
|
||||
/* set up the loader object info */
|
||||
DMUS_OBJECTDESC obj_desc;
|
||||
ZeroMemory(&obj_desc, sizeof(obj_desc));
|
||||
obj_desc.dwSize = sizeof(obj_desc);
|
||||
obj_desc.guidClass = CLSID_DirectMusicSegment;
|
||||
obj_desc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME | DMUS_OBJ_FULLPATH;
|
||||
MultiByteToWideChar(
|
||||
CP_ACP, MB_PRECOMPOSED,
|
||||
filename, -1,
|
||||
obj_desc.wszFileName, lengthof(obj_desc.wszFileName)
|
||||
);
|
||||
ThreadMutexLocker lock(_thread_mutex);
|
||||
|
||||
/* release the existing segment if we have any */
|
||||
if (segment != NULL) {
|
||||
segment->Release();
|
||||
segment = NULL;
|
||||
}
|
||||
_playback.next_file.LoadFile(filename);
|
||||
_playback.next_segment.start = 0;
|
||||
_playback.next_segment.end = 0;
|
||||
_playback.next_segment.loop = false;
|
||||
|
||||
/* make a new segment */
|
||||
if (FAILED(loader->GetObject(
|
||||
&obj_desc, IID_IDirectMusicSegment, (LPVOID*)&segment
|
||||
))) {
|
||||
DEBUG(driver, 0, "DirectMusic: GetObject failed");
|
||||
return;
|
||||
}
|
||||
|
||||
/* tell the segment what kind of data it contains */
|
||||
if (FAILED(segment->SetParam(
|
||||
GUID_StandardMIDIFile, 0xFFFFFFFF, 0, 0, performance
|
||||
))) {
|
||||
DEBUG(driver, 0, "DirectMusic: SetParam (MIDI file) failed");
|
||||
return;
|
||||
}
|
||||
|
||||
/* tell the segment to 'download' the instruments */
|
||||
if (FAILED(segment->SetParam(GUID_Download, 0xFFFFFFFF, 0, 0, performance))) {
|
||||
DEBUG(driver, 0, "DirectMusic: failed to download instruments");
|
||||
return;
|
||||
}
|
||||
|
||||
/* start playing the MIDI file */
|
||||
if (FAILED(performance->PlaySegment(segment, 0, 0, NULL))) {
|
||||
DEBUG(driver, 0, "DirectMusic: PlaySegment failed");
|
||||
return;
|
||||
}
|
||||
|
||||
seeking = true;
|
||||
_playback.do_start = true;
|
||||
SetEvent(_thread_event);
|
||||
}
|
||||
|
||||
|
||||
void MusicDriver_DMusic::StopSong()
|
||||
{
|
||||
if (FAILED(performance->Stop(segment, NULL, 0, 0))) {
|
||||
DEBUG(driver, 0, "DirectMusic: StopSegment failed");
|
||||
}
|
||||
seeking = false;
|
||||
_playback.do_stop = true;
|
||||
SetEvent(_thread_event);
|
||||
}
|
||||
|
||||
|
||||
bool MusicDriver_DMusic::IsSongPlaying()
|
||||
{
|
||||
/* Not the nicest code, but there is a short delay before playing actually
|
||||
* starts. OpenTTD makes no provision for this. */
|
||||
if (performance->IsPlaying(segment, NULL) == S_OK) {
|
||||
seeking = false;
|
||||
return true;
|
||||
} else {
|
||||
return seeking;
|
||||
}
|
||||
return _playback.playing || _playback.do_start;
|
||||
}
|
||||
|
||||
|
||||
void MusicDriver_DMusic::SetVolume(byte vol)
|
||||
{
|
||||
long db = vol * 2000 / 127 - 2000; ///< 0 - 127 -> -2000 - 0
|
||||
performance->SetGlobalParam(GUID_PerfMasterVolume, &db, sizeof(db));
|
||||
_playback.new_volume = vol;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user