mirrors
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

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 2018-05-05 23:32:21 +02:00
parent 3fc9c9522d
commit 255549250f
1 changed files with 500 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

678
src/music/dmusic.cpp
View File

@ -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(&current_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(&params, 0);
params.dwSize = sizeof(DMUS_PORTPARAMS);
params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
params.dwChannelGroups = 1;
if (FAILED(music->CreatePort(caps.guidPort, &params, &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(&params, 0);
params.dwSize = sizeof(DMUS_PORTPARAMS);
params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
params.dwChannelGroups = 1;
if (FAILED(_music->CreatePort(guidPort, &params, &_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;
}