case FOURCC_INFO:

				/* We don't care about info stuff. */

				fseek(f, chunk.length, SEEK_CUR);

				break;

			default:

				fseek(f, chunk.length, SEEK_CUR);

				break;

		}

	}

	return true;

			FOURCC list_type;

			if (fread(&list_type, sizeof(list_type), 1, f) != 1) return false;

			if (list_type == FOURCC_RGN) {

				this->ReadDLSRegion(f, chunk.length - sizeof(list_type), instrument.regions);

			} else {

				fseek(f, chunk.length - sizeof(list_type), SEEK_CUR);

			}

		} else {

			fseek(f, chunk.length, SEEK_CUR);

		}

	}

	return true;

}

			case FOURCC_INFO:

				/* We don't care about info stuff. */

				fseek(f, chunk.length, SEEK_CUR);

				break;

			default:

				fseek(f, chunk.length, SEEK_CUR);

				break;

		}

	}

	return true;

		if (chunk.type == FOURCC_LIST) {

			FOURCC list_type;

			if (fread(&list_type, sizeof(list_type), 1, f) != 1) return false;

			if (list_type == FOURCC_INS) {

				if (!this->ReadDLSInstrument(f, chunk.length - sizeof(list_type))) return false;

			} else {

				fseek(f, chunk.length - sizeof(list_type), SEEK_CUR);

			}

		} else {

			fseek(f, chunk.length, SEEK_CUR);

		}

	}

	return true;

}

			case FOURCC_INFO:

				/* We don't care about info stuff. */

				fseek(f, chunk.length, SEEK_CUR);

				break;

			default:

				fseek(f, chunk.length, SEEK_CUR);

				break;

		}

	}

	return true;

		if (chunk.type == FOURCC_LIST) {

			FOURCC list_type;

			if (fread(&list_type, sizeof(list_type), 1, f) != 1) return false;

			if (list_type == FOURCC_wave) {

				if (!this->ReadDLSWave(f, chunk.length - sizeof(list_type), chunk_offset - base_offset)) return false;

			} else {

				fseek(f, chunk.length - sizeof(list_type), SEEK_CUR);

			}

		} else {

			fseek(f, chunk.length, SEEK_CUR);

		}

	}

	return true;

}

bool DLSFile::LoadFile(const wchar_t *file)

{

	FILE *f = _wfopen(file, L"rb");

	if (f == nullptr) return false;

	FileCloser f_scope(f);

	if (fread(&hdr, sizeof(hdr), 1, f) != 1) return false;

	if (fread(&dls_type, sizeof(dls_type), 1, f) != 1) return false;

	if (hdr.type != FOURCC_RIFF || dls_type != FOURCC_DLS) return false;

	hdr.length -= sizeof(FOURCC);

	DLSHEADER header;

	MemSetT(&header, 0);

	/* Iterate over all chunks in the file. */

	while (hdr.length > 0) {

			case FOURCC_INFO:

				/* We don't care about info stuff. */

				fseek(f, chunk.length, SEEK_CUR);

				break;

			default:

				fseek(f, chunk.length, SEEK_CUR);

				break;

		}

	}

	/* Have we read as many instruments as indicated? */

	/* Wait until message time has passed. */

	Sleep(Clamp((block_time - cur_time) / MS_TO_REFTIME, 5, 1000));

}

static void MidiThreadProc()

{

	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

		if (_playback.shutdown) {

			_playback.playing = false;

			break;

		}

		if (_playback.do_stop) {

			/* 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;

			next_timeout = 1000;

			continue;

		}

		if (wfso == WAIT_OBJECT_0) {

			if (_playback.do_start) {

				{

					/* New scope to limit the time the mutex is locked. */

					std::lock_guard<std::mutex> lock(_thread_mutex);

					current_file.MoveFrom(_playback.next_file);

					std::swap(_playback.next_segment, current_segment);

				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.size();

					if (block.ticktime >= current_segment.start) {

						if (current_segment.loop) {

							current_segment.start_block = bl;

							break;

						} else {

							/* Skip the transmission delay compensation performed in the Win32 MIDI driver.

							 * The DMusic driver will most likely be used with the MS softsynth, which is not subject to transmission delays.

							 */

							playback_start_time -= block.realtime * MIDITIME_TO_REFTIME;

							break;

						}

					}

				}

			}

			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) {

					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);

					}

			while (current_block < current_file.blocks.size()) {

				MidiFile::DataBlock &block = current_file.blocks[current_block];

				/* check that block isn't at end-of-song override */

				if (current_segment.end > 0 && block.ticktime >= current_segment.end) {

					if (current_segment.loop) {

						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;

				}

				/* 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);

					break;

				}

				/* Timestamp of the current block. */

				block_time = playback_start_time + block.realtime * MIDITIME_TO_REFTIME;

				const byte *data = block.data.data();

				size_t remaining = block.data.size();

				byte last_status = 0;

				while (remaining > 0) {

					/* MidiFile ought to have converted everything out of running status,

				}

				next_timeout = 0;

			}

		}

	}

	/* 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);

			if (SUCCEEDED(RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\DirectMusic", 0, KEY_READ, &hkDM))) {

				wchar_t dls_path[MAX_PATH];

				DWORD buf_size = sizeof(dls_path); // Buffer size as to be given in bytes!

				if (SUCCEEDED(RegQueryValueEx(hkDM, L"GMFilePath", nullptr, nullptr, (LPBYTE)dls_path, &buf_size))) {

					wchar_t expand_path[MAX_PATH * 2];

					ExpandEnvironmentStrings(dls_path, expand_path, lengthof(expand_path));

				}

				RegCloseKey(hkDM);

			}

			/* If we couldn't load the file from the registry, try again at the default install path of the GM DLS file. */

			if (dls_file.instruments.size() == 0) {

		char desc[DMUS_MAX_DESCRIPTION];

		DMUS_PORTCAPS caps;

		MemSetT(&caps, 0);

		caps.dwSize = sizeof(DMUS_PORTCAPS);

		for (int i = 0; _music->EnumPort(i, &caps) == S_OK; i++) {

			if (caps.dwClass == DMUS_PC_OUTPUTCLASS) {

			}

		}

	}

	GUID guidPort;

	if (pIdx >= 0) {