12#ifdef WIN32_LEAN_AND_MEAN
13# undef WIN32_LEAN_AND_MEAN
16#include "../os/windows/win32.h"
17#include "../core/mem_func.hpp"
19#include "../fileio_func.h"
20#include "../base_media_base.h"
22#include "midifile.hpp"
30#include "../safeguards.h"
33# pragma comment(lib, "ole32.lib")
40#define FOURCC_INFO mmioFOURCC('I', 'N', 'F', 'O')
41#define FOURCC_fmt mmioFOURCC('f', 'm', 't', ' ')
42#define FOURCC_data mmioFOURCC('d', 'a', 't', 'a')
52 std::vector<WLOOP> wave_loops;
53 std::vector<CONNECTION> articulators;
60 std::vector<CONNECTION> articulators;
61 std::vector<DLSRegion> regions;
69 std::vector<BYTE> data;
72 std::vector<WLOOP> wave_loops;
75 std::vector<DLSInstrument> instruments;
76 std::vector<POOLCUE> pool_cues;
77 std::vector<DLSWave> waves;
80 bool LoadFile(
const std::string &file);
100PACK_N(
struct ChunkHeader {
106PACK_N(
struct WAVE_DOWNLOAD {
107 DMUS_DOWNLOADINFO dlInfo;
108 ULONG ulOffsetTable[2];
110 DMUS_WAVEDATA dmWaveData;
142static IDirectMusicPort *
_port =
nullptr;
154 while (list_length > 0) {
156 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
157 list_length -= chunk.length +
sizeof(chunk);
159 if (chunk.type == FOURCC_ART1) {
160 CONNECTIONLIST conns;
161 if (fread(&conns,
sizeof(conns), 1, f) != 1)
return false;
162 fseek(f, conns.cbSize -
sizeof(conns), SEEK_CUR);
165 for (ULONG i = 0; i < conns.cConnections; i++) {
167 if (fread(&con,
sizeof(con), 1, f) != 1)
return false;
171 fseek(f, chunk.length, SEEK_CUR);
183 region.wave_sample.cbSize = 0;
185 while (list_length > 0) {
187 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
188 list_length -= chunk.length +
sizeof(chunk);
190 if (chunk.type == FOURCC_LIST) {
192 if (fread(&chunk.type,
sizeof(chunk.type), 1, f) != 1)
return false;
193 chunk.length -=
sizeof(chunk.type);
196 switch (chunk.type) {
198 if (fread(®ion.hdr,
sizeof(region.hdr), 1, f) != 1)
return false;
202 if (fread(®ion.wave_sample,
sizeof(region.wave_sample), 1, f) != 1)
return false;
203 fseek(f, region.wave_sample.cbSize -
sizeof(region.wave_sample), SEEK_CUR);
206 for (ULONG i = 0; i < region.wave_sample.cSampleLoops; i++) {
208 if (fread(&loop,
sizeof(loop), 1, f) != 1)
return false;
209 region.wave_loops.push_back(loop);
214 if (fread(®ion.wave,
sizeof(region.wave), 1, f) != 1)
return false;
223 fseek(f, chunk.length, SEEK_CUR);
227 Debug(driver, 7,
"DLS: Ignoring unknown chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
228 fseek(f, chunk.length, SEEK_CUR);
238 while (list_length > 0) {
240 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
241 list_length -= chunk.length +
sizeof(chunk);
243 if (chunk.type == FOURCC_LIST) {
245 if (fread(&list_type,
sizeof(list_type), 1, f) != 1)
return false;
247 if (list_type == FOURCC_RGN) {
248 this->
ReadDLSRegion(f, chunk.length -
sizeof(list_type), instrument.regions);
250 Debug(driver, 7,
"DLS: Ignoring unknown list chunk of type {}{}{}{}", (
char)(list_type & 0xFF), (
char)((list_type >> 8) & 0xFF), (
char)((list_type >> 16) & 0xFF), (
char)((list_type >> 24) & 0xFF));
251 fseek(f, chunk.length -
sizeof(list_type), SEEK_CUR);
254 Debug(driver, 7,
"DLS: Ignoring chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
255 fseek(f, chunk.length, SEEK_CUR);
264 DLSInstrument &instrument = this->instruments.emplace_back();
266 while (list_length > 0) {
268 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
269 list_length -= chunk.length +
sizeof(chunk);
271 if (chunk.type == FOURCC_LIST) {
273 if (fread(&chunk.type,
sizeof(chunk.type), 1, f) != 1)
return false;
274 chunk.length -=
sizeof(chunk.type);
277 switch (chunk.type) {
279 if (fread(&instrument.hdr,
sizeof(instrument.hdr), 1, f) != 1)
return false;
292 fseek(f, chunk.length, SEEK_CUR);
296 Debug(driver, 7,
"DLS: Ignoring unknown chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
297 fseek(f, chunk.length, SEEK_CUR);
307 while (list_length > 0) {
309 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
310 list_length -= chunk.length +
sizeof(chunk);
312 if (chunk.type == FOURCC_LIST) {
314 if (fread(&list_type,
sizeof(list_type), 1, f) != 1)
return false;
316 if (list_type == FOURCC_INS) {
317 Debug(driver, 6,
"DLS: Reading instrument {}", (
int)instruments.size());
321 Debug(driver, 7,
"DLS: Ignoring unknown list chunk of type {}{}{}{}", (
char)(list_type & 0xFF), (
char)((list_type >> 8) & 0xFF), (
char)((list_type >> 16) & 0xFF), (
char)((list_type >> 24) & 0xFF));
322 fseek(f, chunk.length -
sizeof(list_type), SEEK_CUR);
325 Debug(driver, 7,
"DLS: Ignoring chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
326 fseek(f, chunk.length, SEEK_CUR);
335 DLSWave &wave = this->waves.emplace_back();
339 wave.wave_sample.cbSize =
sizeof(WSMPL);
340 wave.wave_sample.usUnityNote = 60;
341 wave.file_offset = offset;
343 while (list_length > 0) {
345 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
346 list_length -= chunk.length +
sizeof(chunk);
348 if (chunk.type == FOURCC_LIST) {
350 if (fread(&chunk.type,
sizeof(chunk.type), 1, f) != 1)
return false;
351 chunk.length -=
sizeof(chunk.type);
354 switch (chunk.type) {
356 if (fread(&wave.fmt,
sizeof(wave.fmt), 1, f) != 1)
return false;
357 if (chunk.length >
sizeof(wave.fmt)) fseek(f, chunk.length -
sizeof(wave.fmt), SEEK_CUR);
361 if (fread(&wave.wave_sample,
sizeof(wave.wave_sample), 1, f) != 1)
return false;
362 fseek(f, wave.wave_sample.cbSize -
sizeof(wave.wave_sample), SEEK_CUR);
365 for (ULONG i = 0; i < wave.wave_sample.cSampleLoops; i++) {
367 if (fread(&loop,
sizeof(loop), 1, f) != 1)
return false;
368 wave.wave_loops.push_back(loop);
373 wave.data.resize(chunk.length);
374 if (fread(&wave.data[0],
sizeof(BYTE), wave.data.size(), f) != wave.data.size())
return false;
379 fseek(f, chunk.length, SEEK_CUR);
383 Debug(driver, 7,
"DLS: Ignoring unknown chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
384 fseek(f, chunk.length, SEEK_CUR);
394 long base_offset = ftell(f);
396 while (list_length > 0) {
397 long chunk_offset = ftell(f);
400 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
401 list_length -= chunk.length +
sizeof(chunk);
403 if (chunk.type == FOURCC_LIST) {
405 if (fread(&list_type,
sizeof(list_type), 1, f) != 1)
return false;
407 if (list_type == FOURCC_wave) {
408 Debug(driver, 6,
"DLS: Reading wave {}", waves.size());
410 if (!this->
ReadDLSWave(f, chunk.length -
sizeof(list_type), chunk_offset - base_offset))
return false;
412 Debug(driver, 7,
"DLS: Ignoring unknown list chunk of type {}{}{}{}", (
char)(list_type & 0xFF), (
char)((list_type >> 8) & 0xFF), (
char)((list_type >> 16) & 0xFF), (
char)((list_type >> 24) & 0xFF));
413 fseek(f, chunk.length -
sizeof(list_type), SEEK_CUR);
416 Debug(driver, 7,
"DLS: Ignoring chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
417 fseek(f, chunk.length, SEEK_CUR);
426 Debug(driver, 2,
"DMusic: Try to load DLS file {}", file);
429 if (!of.has_value())
return false;
435 if (fread(&hdr,
sizeof(hdr), 1, f) != 1)
return false;
436 if (fread(&dls_type,
sizeof(dls_type), 1, f) != 1)
return false;
437 if (hdr.type != FOURCC_RIFF || dls_type != FOURCC_DLS)
return false;
439 hdr.length -=
sizeof(FOURCC);
441 Debug(driver, 2,
"DMusic: Parsing DLS file");
447 while (hdr.length > 0) {
449 if (fread(&chunk,
sizeof(chunk), 1, f) != 1)
return false;
450 hdr.length -= chunk.length +
sizeof(chunk);
452 if (chunk.type == FOURCC_LIST) {
454 if (fread(&chunk.type,
sizeof(chunk.type), 1, f) != 1)
return false;
455 chunk.length -=
sizeof(chunk.type);
458 switch (chunk.type) {
460 if (fread(&header,
sizeof(header), 1, f) != 1)
return false;
473 if (fread(&ptbl,
sizeof(ptbl), 1, f) != 1)
return false;
474 fseek(f, ptbl.cbSize -
sizeof(ptbl), SEEK_CUR);
477 for (ULONG i = 0; i < ptbl.cCues; i++) {
479 if (fread(&cue,
sizeof(cue), 1, f) != 1)
return false;
480 this->pool_cues.push_back(cue);
486 fseek(f, chunk.length, SEEK_CUR);
490 Debug(driver, 7,
"DLS: Ignoring unknown chunk {}{}{}{}", (
char)(chunk.type & 0xFF), (
char)((chunk.type >> 8) & 0xFF), (
char)((chunk.type >> 16) & 0xFF), (
char)((chunk.type >> 24) & 0xFF));
491 fseek(f, chunk.length, SEEK_CUR);
497 if (header.cInstruments != this->instruments.size())
return false;
500 for (std::vector<POOLCUE>::iterator cue = this->pool_cues.begin(); cue != this->pool_cues.end(); cue++) {
501 std::vector<DLSWave>::iterator w = std::ranges::find(this->waves, cue->ulOffset, &DLSWave::file_offset);
502 if (w != this->waves.end()) {
503 cue->ulOffset = (ULONG)(w - this->waves.begin());
513static uint8_t ScaleVolume(uint8_t original, uint8_t scale)
515 return original * scale / 127;
518static void TransmitChannelMsg(IDirectMusicBuffer *buffer, REFERENCE_TIME rt, uint8_t status, uint8_t p1, uint8_t p2 = 0)
520 if (buffer->PackStructured(rt, 0, status | (p1 << 8) | (p2 << 16)) == E_OUTOFMEMORY) {
522 _port->PlayBuffer(buffer);
525 buffer->PackStructured(rt, 0, status | (p1 << 8) | (p2 << 16));
529static void TransmitSysex(IDirectMusicBuffer *buffer, REFERENCE_TIME rt,
const uint8_t *&msg_start,
size_t &remaining)
532 const uint8_t *msg_end = msg_start;
533 while (*msg_end != MIDIST_ENDSYSEX) msg_end++;
536 if (buffer->PackUnstructured(rt, 0, msg_end - msg_start,
const_cast<LPBYTE
>(msg_start)) == E_OUTOFMEMORY) {
538 _port->PlayBuffer(buffer);
541 buffer->PackUnstructured(rt, 0, msg_end - msg_start,
const_cast<LPBYTE
>(msg_start));
545 remaining -= msg_end - msg_start;
549static void TransmitStandardSysex(IDirectMusicBuffer *buffer, REFERENCE_TIME rt, MidiSysexMessage msg)
552 const uint8_t *data = MidiGetStandardSysexMessage(msg, length);
553 TransmitSysex(buffer, rt, data, length);
557static void TransmitNotesOff(IDirectMusicBuffer *buffer, REFERENCE_TIME block_time, REFERENCE_TIME cur_time)
559 for (
int ch = 0; ch < 16; ch++) {
560 TransmitChannelMsg(buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_MODE_ALLNOTESOFF, 0);
561 TransmitChannelMsg(buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_SUSTAINSW, 0);
562 TransmitChannelMsg(buffer, block_time + 10, MIDIST_CONTROLLER | ch, MIDICT_MODE_RESETALLCTRL, 0);
566 TransmitStandardSysex(buffer, block_time + 20, MidiSysexMessage::ResetGM);
567 TransmitStandardSysex(buffer, block_time + 30, MidiSysexMessage::RolandSetReverb);
571 _port->PlayBuffer(buffer);
578static void MidiThreadProc()
580 Debug(driver, 2,
"DMusic: Entering playback thread");
582 REFERENCE_TIME last_volume_time = 0;
583 REFERENCE_TIME block_time = 0;
592 IReferenceClock *clock;
593 _port->GetLatencyClock(&clock);
595 REFERENCE_TIME cur_time;
596 clock->GetTime(&cur_time);
601 DWORD next_timeout = 1000;
604 DWORD wfso = WaitForSingleObject(
_thread_event, next_timeout);
606 if (_playback.shutdown) {
607 _playback.playing =
false;
611 if (_playback.do_stop) {
612 Debug(driver, 2,
"DMusic thread: Stopping playback");
615 clock->GetTime(&cur_time);
618 _playback.playing =
false;
619 _playback.do_stop =
false;
625 if (wfso == WAIT_OBJECT_0) {
626 if (_playback.do_start) {
627 Debug(driver, 2,
"DMusic thread: Starting playback");
636 _playback.playing =
true;
637 _playback.do_start =
false;
641 clock->GetTime(&cur_time);
647 last_volume_time = 0;
655 if (_playback.playing) {
661 size_t preload_bytes = 0;
664 preload_bytes += block.
data.size();
667 Debug(driver, 2,
"DMusic: timer: loop from block {} (ticktime {}, realtime {:.3f}, bytes {})", bl, block.
ticktime, ((
int)block.
realtime) / 1000.0, preload_bytes);
674 Debug(driver, 2,
"DMusic: timer: start from block {} (ticktime {}, realtime {:.3f}, bytes {})", bl, block.
ticktime, ((
int)block.
realtime) / 1000.0, preload_bytes);
683 REFERENCE_TIME current_time;
684 clock->GetTime(¤t_time);
689 Debug(driver, 2,
"DMusic thread: volume change");
691 last_volume_time = current_time;
692 for (
int ch = 0; ch < 16; ch++) {
694 TransmitChannelMsg(
_buffer, block_time + 1, MIDIST_CONTROLLER | ch, MIDICT_CHANVOLUME, vol);
707 Debug(driver, 2,
"DMusic thread: Looping song");
711 _playback.do_stop =
true;
729 const uint8_t *data = block.
data.data();
730 size_t remaining = block.
data.size();
731 uint8_t last_status = 0;
732 while (remaining > 0) {
735 uint8_t status = data[0];
737 last_status = status;
741 status = last_status;
743 switch (status & 0xF0) {
745 case MIDIST_CHANPRESS:
747 TransmitChannelMsg(
_buffer, block_time, status, data[0]);
753 case MIDIST_POLYPRESS:
754 case MIDIST_PITCHBEND:
756 TransmitChannelMsg(
_buffer, block_time, status, data[0], data[1]);
760 case MIDIST_CONTROLLER:
762 if (data[0] == MIDICT_CHANVOLUME) {
766 TransmitChannelMsg(
_buffer, block_time, status, data[0], vol);
769 TransmitChannelMsg(
_buffer, block_time, status, data[0], data[1]);
778 TransmitSysex(
_buffer, block_time, data, remaining);
780 case MIDIST_TC_QFRAME:
785 case MIDIST_SONGPOSPTR:
800 DWORD used_buffer = 0;
801 _buffer->GetUsedBytes(&used_buffer);
802 if (used_buffer > 0) {
813 _playback.do_stop =
true;
820 Debug(driver, 2,
"DMusic: Exiting playback thread");
823 clock->GetTime(&cur_time);
825 Sleep(_playback.preload_time * 4);
830static void * DownloadArticulationData(
int base_offset,
void *data,
const std::vector<CONNECTION> &artic)
832 DMUS_ARTICULATION2 *art = (DMUS_ARTICULATION2 *)data;
833 art->ulArtIdx = base_offset + 1;
834 art->ulFirstExtCkIdx = 0;
835 art->ulNextArtIdx = 0;
837 CONNECTIONLIST *con_list = (CONNECTIONLIST *)(art + 1);
838 con_list->cbSize =
sizeof(CONNECTIONLIST);
839 con_list->cConnections = (ULONG)artic.size();
840 MemCpyT((CONNECTION *)(con_list + 1), &artic.front(), artic.size());
842 return (CONNECTION *)(con_list + 1) + artic.size();
845static const char *LoadDefaultDLSFile(
const char *user_dls)
849 caps.dwSize =
sizeof(DMUS_PORTCAPS);
850 _port->GetCaps(&caps);
853 if ((caps.dwFlags & (DMUS_PC_DLS | DMUS_PC_DLS2)) != 0 && (caps.dwFlags & DMUS_PC_GMINHARDWARE) == 0) {
856 if (user_dls ==
nullptr) {
859 if (SUCCEEDED(RegOpenKeyEx(HKEY_LOCAL_MACHINE, L
"Software\\Microsoft\\DirectMusic", 0, KEY_READ, &hkDM))) {
860 wchar_t dls_path[MAX_PATH];
861 DWORD buf_size =
sizeof(dls_path);
862 if (SUCCEEDED(RegQueryValueEx(hkDM, L
"GMFilePath",
nullptr,
nullptr, (LPBYTE)dls_path, &buf_size))) {
863 wchar_t expand_path[MAX_PATH * 2];
864 ExpandEnvironmentStrings(dls_path, expand_path,
static_cast<DWORD
>(std::size(expand_path)));
865 if (!dls_file.
LoadFile(
FS2OTTD(expand_path)))
Debug(driver, 1,
"Failed to load default GM DLS file from registry");
871 if (dls_file.instruments.empty()) {
872 static const wchar_t *DLS_GM_FILE = L
"%windir%\\System32\\drivers\\gm.dls";
873 wchar_t path[MAX_PATH];
874 ExpandEnvironmentStrings(DLS_GM_FILE, path,
static_cast<DWORD
>(std::size(path)));
876 if (!dls_file.
LoadFile(
FS2OTTD(path)))
return "Can't load GM DLS collection";
879 if (!dls_file.
LoadFile(user_dls))
return "Can't load GM DLS collection";
883 IDirectMusicPortDownload *download_port =
nullptr;
884 if (FAILED(
_port->QueryInterface(IID_IDirectMusicPortDownload, (LPVOID *)&download_port)))
return "Can't get download port";
886 DWORD dlid_wave = 0, dlid_inst = 0;
887 if (FAILED(download_port->GetDLId(&dlid_wave, (DWORD)dls_file.waves.size())) || FAILED(download_port->GetDLId(&dlid_inst, (DWORD)dls_file.instruments.size()))) {
888 download_port->Release();
889 return "Can't get enough DLS ids";
893 download_port->GetAppend(&dwAppend);
896 for (DWORD i = 0; i < dls_file.waves.size(); i++) {
897 IDirectMusicDownload *dl_wave =
nullptr;
898 if (FAILED(download_port->AllocateBuffer((DWORD)(
sizeof(WAVE_DOWNLOAD) + dwAppend * dls_file.waves[i].fmt.wf.nBlockAlign + dls_file.waves[i].data.size()), &dl_wave))) {
899 download_port->Release();
900 return "Can't allocate wave download buffer";
905 if (FAILED(dl_wave->GetBuffer((LPVOID *)&wave, &wave_size))) {
907 download_port->Release();
908 return "Can't get wave download buffer";
913 wave->dlInfo.dwDLType = DMUS_DOWNLOADINFO_WAVE;
914 wave->dlInfo.cbSize = wave_size;
915 wave->dlInfo.dwDLId = dlid_wave + i;
916 wave->dlInfo.dwNumOffsetTableEntries = 2;
917 wave->ulOffsetTable[0] = offsetof(WAVE_DOWNLOAD, dmWave);
918 wave->ulOffsetTable[1] = offsetof(WAVE_DOWNLOAD, dmWaveData);
919 wave->dmWave.ulWaveDataIdx = 1;
920 MemCpyT((PCMWAVEFORMAT *)&wave->dmWave.WaveformatEx, &dls_file.waves[i].fmt, 1);
921 wave->dmWaveData.cbSize = (DWORD)dls_file.waves[i].data.size();
922 MemCpyT(wave->dmWaveData.byData, &dls_file.waves[i].data[0], dls_file.waves[i].data.size());
925 if (FAILED(download_port->Download(dl_wave))) {
926 download_port->Release();
927 return "Downloading DLS wave failed";
932 for (DWORD i = 0; i < dls_file.instruments.size(); i++) {
933 DWORD offsets = 1 + (DWORD)dls_file.instruments[i].regions.size();
936 size_t i_size =
sizeof(DMUS_DOWNLOADINFO) +
sizeof(DMUS_INSTRUMENT);
937 if (!dls_file.instruments[i].articulators.empty()) {
940 i_size +=
sizeof(DMUS_ARTICULATION2) +
sizeof(CONNECTIONLIST) +
sizeof(CONNECTION) * dls_file.instruments[i].articulators.size();
943 for (std::vector<DLSFile::DLSRegion>::iterator rgn = dls_file.instruments[i].regions.begin(); rgn != dls_file.instruments[i].regions.end(); rgn++) {
944 if (!rgn->articulators.empty()) {
946 i_size +=
sizeof(DMUS_ARTICULATION2) +
sizeof(CONNECTIONLIST) +
sizeof(CONNECTION) * rgn->articulators.size();
951 if (rgn->wave_sample.cbSize != 0) {
952 i_size +=
sizeof(DMUS_REGION) -
sizeof(DMUS_REGION::WLOOP) +
sizeof(WLOOP) * rgn->wave_loops.size();
954 i_size +=
sizeof(DMUS_REGION) -
sizeof(DMUS_REGION::WLOOP) +
sizeof(WLOOP) * dls_file.waves[dls_file.pool_cues[rgn->wave.ulTableIndex].ulOffset].wave_loops.size();
958 i_size += offsets *
sizeof(ULONG);
961 IDirectMusicDownload *dl_inst =
nullptr;
962 if (FAILED(download_port->AllocateBuffer((DWORD)i_size, &dl_inst))) {
963 download_port->Release();
964 return "Can't allocate instrument download buffer";
969 if (FAILED(dl_inst->GetBuffer((LPVOID *)&instrument, &inst_size))) {
971 download_port->Release();
972 return "Can't get instrument download buffer";
974 char *inst_base = (
char *)instrument;
977 DMUS_DOWNLOADINFO *d_info = (DMUS_DOWNLOADINFO *)instrument;
978 d_info->dwDLType = DMUS_DOWNLOADINFO_INSTRUMENT2;
979 d_info->cbSize = inst_size;
980 d_info->dwDLId = dlid_inst + i;
981 d_info->dwNumOffsetTableEntries = offsets;
982 instrument = d_info + 1;
985 ULONG *offset_table = (ULONG *)instrument;
986 instrument = offset_table + offsets;
990 DMUS_INSTRUMENT *inst_data = (DMUS_INSTRUMENT *)instrument;
992 offset_table[last_offset++] = (
char *)inst_data - inst_base;
993 inst_data->ulPatch = (dls_file.instruments[i].hdr.Locale.ulBank & F_INSTRUMENT_DRUMS) | ((dls_file.instruments[i].hdr.Locale.ulBank & 0x7F7F) << 8) | (dls_file.instruments[i].hdr.Locale.ulInstrument & 0x7F);
994 instrument = inst_data + 1;
997 if (!dls_file.instruments[i].articulators.empty()) {
998 inst_data->ulGlobalArtIdx = last_offset;
999 offset_table[last_offset++] = (
char *)instrument - inst_base;
1000 offset_table[last_offset++] = (
char *)instrument +
sizeof(DMUS_ARTICULATION2) - inst_base;
1002 instrument = DownloadArticulationData(inst_data->ulGlobalArtIdx, instrument, dls_file.instruments[i].articulators);
1003 assert((
char *)instrument - inst_base <= (ptrdiff_t)inst_size);
1007 inst_data->ulFirstRegionIdx = last_offset;
1008 for (uint j = 0; j < dls_file.instruments[i].regions.size(); j++) {
1011 DMUS_REGION *inst_region = (DMUS_REGION *)instrument;
1012 offset_table[last_offset++] = (
char *)inst_region - inst_base;
1013 inst_region->RangeKey = rgn.hdr.RangeKey;
1014 inst_region->RangeVelocity = rgn.hdr.RangeVelocity;
1015 inst_region->fusOptions = rgn.hdr.fusOptions;
1016 inst_region->usKeyGroup = rgn.hdr.usKeyGroup;
1017 inst_region->ulFirstExtCkIdx = 0;
1019 ULONG wave_id = dls_file.pool_cues[rgn.wave.ulTableIndex].ulOffset;
1020 inst_region->WaveLink = rgn.wave;
1021 inst_region->WaveLink.ulTableIndex = wave_id + dlid_wave;
1024 if (rgn.wave_sample.cbSize != 0) {
1025 inst_region->WSMP = rgn.wave_sample;
1026 if (!rgn.wave_loops.empty())
MemCpyT(inst_region->WLOOP, &rgn.wave_loops.front(), rgn.wave_loops.size());
1028 instrument = (
char *)(inst_region + 1) -
sizeof(DMUS_REGION::WLOOP) +
sizeof(WLOOP) * rgn.wave_loops.size();
1030 inst_region->WSMP = rgn.wave_sample;
1031 if (!dls_file.waves[wave_id].wave_loops.empty())
MemCpyT(inst_region->WLOOP, &dls_file.waves[wave_id].wave_loops.front(), dls_file.waves[wave_id].wave_loops.size());
1033 instrument = (
char *)(inst_region + 1) -
sizeof(DMUS_REGION::WLOOP) +
sizeof(WLOOP) * dls_file.waves[wave_id].wave_loops.size();
1037 if (!rgn.articulators.empty()) {
1038 inst_region->ulRegionArtIdx = last_offset;
1039 offset_table[last_offset++] = (
char *)instrument - inst_base;
1040 offset_table[last_offset++] = (
char *)instrument +
sizeof(DMUS_ARTICULATION2) - inst_base;
1042 instrument = DownloadArticulationData(inst_region->ulRegionArtIdx, instrument, rgn.articulators);
1044 inst_region->ulRegionArtIdx = 0;
1046 assert((
char *)instrument - inst_base <= (ptrdiff_t)inst_size);
1049 inst_region->ulNextRegionIdx = j < dls_file.instruments[i].regions.size() - 1 ? last_offset : 0;
1053 if (FAILED(download_port->Download(dl_inst))) {
1054 download_port->Release();
1055 return "Downloading DLS instrument failed";
1059 download_port->Release();
1069 if (FAILED(CoInitializeEx(
nullptr, COINIT_MULTITHREADED)))
return "COM initialization failed";
1072 if (FAILED(CoCreateInstance(
1079 return "Failed to create the music object";
1083 if (FAILED(
_music->SetDirectSound(
nullptr,
nullptr)))
return "Can't set DirectSound interface";
1090 if (_debug_driver_level > 0) {
1092 char desc[DMUS_MAX_DESCRIPTION];
1096 caps.dwSize =
sizeof(DMUS_PORTCAPS);
1098 Debug(driver, 1,
"Detected DirectMusic ports:");
1099 for (
int i = 0;
_music->EnumPort(i, &caps) == S_OK; i++) {
1100 if (caps.dwClass == DMUS_PC_OUTPUTCLASS) {
1101 Debug(driver, 1,
" {}: {}{}", i,
convert_from_fs(caps.wszDescription, desc), i == pIdx ?
" (selected)" :
"");
1111 caps.dwSize =
sizeof(DMUS_PORTCAPS);
1112 if (FAILED(
_music->EnumPort(pIdx, &caps)))
return "Supplied port parameter is not a valid port";
1113 if (caps.dwClass != DMUS_PC_OUTPUTCLASS)
return "Supplied port parameter is not an output port";
1114 guidPort = caps.guidPort;
1116 if (FAILED(
_music->GetDefaultPort(&guidPort)))
return "Can't query default music port";
1120 DMUS_PORTPARAMS params;
1122 params.dwSize =
sizeof(DMUS_PORTPARAMS);
1123 params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS;
1124 params.dwChannelGroups = 1;
1125 if (FAILED(
_music->CreatePort(guidPort, ¶ms, &
_port,
nullptr)))
return "Failed to create port";
1127 if (FAILED(
_port->Activate(TRUE)))
return "Failed to activate port";
1130 DMUS_BUFFERDESC desc;
1132 desc.dwSize =
sizeof(DMUS_BUFFERDESC);
1133 desc.guidBufferFormat = KSDATAFORMAT_SUBTYPE_DIRECTMUSIC;
1134 desc.cbBuffer = 1024;
1135 if (FAILED(
_music->CreateMusicBuffer(&desc, &
_buffer,
nullptr)))
return "Failed to create music buffer";
1138 const char *dls = LoadDefaultDLSFile(
GetDriverParam(parm,
"dls"));
1139 if (dls !=
nullptr)
return dls;
1142 _thread_event = CreateEvent(
nullptr, FALSE, FALSE,
nullptr);
1143 if (
_thread_event ==
nullptr)
return "Can't create thread shutdown event";
1147 return std::nullopt;
1151MusicDriver_DMusic::~MusicDriver_DMusic()
1159 if (_dmusic_thread.joinable()) {
1160 _playback.shutdown =
true;
1167 IDirectMusicPortDownload *download_port =
nullptr;
1168 _port->QueryInterface(IID_IDirectMusicPortDownload, (LPVOID *)&download_port);
1172 for (std::vector<IDirectMusicDownload *>::reverse_iterator i =
_dls_downloads.rbegin(); download_port !=
nullptr && i !=
_dls_downloads.rend(); i++) {
1173 download_port->Unload(*i);
1178 if (download_port !=
nullptr) download_port->Release();
1186 if (
_port !=
nullptr) {
1187 _port->Activate(FALSE);
1207 if (!_playback.next_file.LoadSong(song))
return;
1211 _playback.next_segment.loop = song.
loop;
1213 _playback.do_start =
true;
1220 _playback.do_stop =
true;
1227 return _playback.playing || _playback.do_start;
1233 _playback.new_volume = vol;
Factory for the DirectX music player.
static std::optional< FileHandle > Open(const std::string &filename, const std::string &mode)
Open an RAII file handle if possible.
void SetVolume(uint8_t vol) override
Set the volume, if possible.
void StopSong() override
Stop playing the current song.
std::optional< std::string_view > Start(const StringList ¶m) override
Start this driver.
bool IsSongPlaying() override
Are we currently playing a song?
void Stop() override
Stop this driver.
void PlaySong(const MusicSongInfo &song) override
Play a particular song.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
bool playing
flag indicating that playback is active
uint8_t new_volume
volume setting to change to
bool shutdown
flag to indicate playback thread shutdown
static IDirectMusicBuffer * _buffer
The buffer object collects the data to sent.
bool do_stop
flag for stopping playback at next opportunity
int preload_time
preload time for music blocks.
static const int MIDITIME_TO_REFTIME
Time base of the midi file reader is 1 us.
static std::thread _dmusic_thread
Handle to our worker thread.
MidiFile next_file
upcoming file to play
static IDirectMusicPort * _port
The port object lets us send MIDI data to the synthesizer.
bool do_start
flag for starting playback of next_file at next opportunity
static std::vector< IDirectMusicDownload * > _dls_downloads
List of downloaded DLS instruments.
static HANDLE _thread_event
Event to signal the thread that it should look at a state change.
static const int MS_TO_REFTIME
DirectMusic time base is 100 ns.
static std::mutex _thread_mutex
Lock access to playback data that is not thread-safe.
static IDirectMusic * _music
The direct music object manages buffers and ports.
PlaybackSegment next_segment
segment info for upcoming file
static void TransmitNotesOff(IDirectMusicBuffer *buffer, REFERENCE_TIME block_time, REFERENCE_TIME cur_time)
Transmit 'Note off' messages to all MIDI channels.
Base of playing music via DirectMusic.
const char * GetDriverParam(const StringList &parm, const char *name)
Get a string parameter the list of parameters.
int GetDriverParamInt(const StringList &parm, const char *name, int def)
Get an integer parameter the list of parameters.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
void MemCpyT(T *destination, const T *source, size_t num=1)
Type-safe version of memcpy().
void MemSetT(T *ptr, uint8_t value, size_t num=1)
Type-safe version of memset().
#define lengthof(array)
Return the length of an fixed size array.
std::vector< std::string > StringList
Type for a list of strings.
Instrument definition read from a DLS file.
An instrument region maps a note range to wave data.
Wave data definition from a DLS file.
bool ReadDLSInstrumentList(FileHandle &f, DWORD list_length)
Load a list of instruments from a DLS file.
bool LoadFile(const std::string &file)
Try loading a DLS file into memory.
bool ReadDLSWaveList(FileHandle &f, DWORD list_length)
Load a list of waves from a DLS file.
bool ReadDLSRegionList(FileHandle &f, DWORD list_length, DLSInstrument &instrument)
Load a list of regions from a DLS file.
bool ReadDLSWave(FileHandle &f, DWORD list_length, long offset)
Load a single wave from a DLS file.
bool ReadDLSRegion(FileHandle &f, DWORD list_length, std::vector< DLSRegion > &out)
Load a single region from a DLS file.
bool ReadDLSInstrument(FileHandle &f, DWORD list_length)
Load a single instrument from a DLS file.
bool ReadDLSArticulation(FileHandle &f, DWORD list_length, std::vector< CONNECTION > &out)
Load an articulation structure from a DLS file.
std::vector< uint8_t > data
raw midi data contained in block
uint32_t realtime
real-time (microseconds) since start of file this block should be triggered at
uint32_t ticktime
tick number since start of file this block should be triggered at
void MoveFrom(MidiFile &other)
Move data from other to this, and clears other.
std::vector< DataBlock > blocks
sequential time-annotated data of file, merged to a single track
Metadata about a music track.
int override_start
MIDI ticks to skip over in beginning.
bool loop
song should play in a tight loop if possible, never ending
int override_end
MIDI tick to end the song at (0 if no override)
bool StartNewThread(std::thread *thr, const char *name, TFn &&_Fx, TArgs &&... _Ax)
Start a new thread.
char * convert_from_fs(const std::wstring_view src, std::span< char > dst_buf)
Convert to OpenTTD's encoding from that of the environment in UNICODE.
std::string FS2OTTD(const std::wstring &name)
Convert to OpenTTD's encoding from a wide string.
uint8_t current_volume
current effective volume setting
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
std::mutex lock
synchronization for playback status fields
uint8_t channel_volumes[16]
last seen volume controller values in raw data
DWORD playback_start_time
timestamp current file began playback