1

/* $Id$ */

     2

     3

/** @file dmusic.cpp */

     4

     5

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

     6

     7

#include "../stdafx.h"

     8

#include "../debug.h"

     9

#include "../win32.h"

    10

#include "dmusic.h"

    11

    12

#include <windows.h>

    13

#include <dmksctrl.h>

    14

#include <dmusici.h>

    15

#include <dmusicc.h>

    16

#include <dmusicf.h>

    17

    19

    20

/** the performance object controls manipulation of the segments */

    21

static IDirectMusicPerformance* performance = NULL;

    22

    23

/** the loader object can load many types of DMusic related files */

    24

static IDirectMusicLoader* loader = NULL;

    25

    26

/** the segment object is where the MIDI data is stored for playback */

    27

static IDirectMusicSegment* segment = NULL;

    28

    29

static bool seeking = false;

    30

    31

    32

#define M(x) x "\0"

    33

static const char ole_files[] =

    34

	M("ole32.dll")

    35

	M("CoCreateInstance")

    36

	M("CoInitialize")

    37

	M("CoUninitialize")

    38

	M("")

    39

;

    40

#undef M

    41

    42

struct ProcPtrs {

    43

	unsigned long (WINAPI * CoCreateInstance)(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID* ppv);

    44

	HRESULT (WINAPI * CoInitialize)(LPVOID pvReserved);

    45

	void (WINAPI * CoUninitialize)();

    46

};

    47

    48

static ProcPtrs proc;

    49

    50

    51

const char *MusicDriver_DMusic::Start(const char * const *parm)

    52

{

    53

	if (performance != NULL) return NULL;

    54

    55

	if (proc.CoCreateInstance == NULL) {

    56

		if (!LoadLibraryList((Function*)&proc, ole_files))

    57

			return "ole32.dll load failed";

    58

	}

    59

    60

	/* Initialize COM */

    61

	if (FAILED(proc.CoInitialize(NULL))) {

    62

		return "COM initialization failed";

    63

	}

    64

    65

	/* create the performance object */

    66

	if (FAILED(proc.CoCreateInstance(

    67

				CLSID_DirectMusicPerformance,

    68

				NULL,

    69

				CLSCTX_INPROC,

    70

				IID_IDirectMusicPerformance,

    71

				(LPVOID*)&performance

    72

			))) {

    73

		proc.CoUninitialize();

    74

		return "Failed to create the performance object";

    75

	}

    76

    77

	/* initialize it */

    78

	if (FAILED(performance->Init(NULL, NULL, NULL))) {

    79

		performance->Release();

    80

		performance = NULL;

    81

		proc.CoUninitialize();

    82

		return "Failed to initialize performance object";

    83

	}

    84

    85

	/* choose default Windows synth */

    86

	if (FAILED(performance->AddPort(NULL))) {

    87

		performance->CloseDown();

    88

		performance->Release();

    89

		performance = NULL;

    90

		proc.CoUninitialize();

    91

		return "AddPort failed";

    92

	}

    93

    94

	/* create the loader object; this will be used to load the MIDI file */

    95

	if (FAILED(proc.CoCreateInstance(

    96

				CLSID_DirectMusicLoader,

    97

				NULL,

    98

				CLSCTX_INPROC,

    99

				IID_IDirectMusicLoader,

   100

				(LPVOID*)&loader

   101

			))) {

   102

		performance->CloseDown();

   103

		performance->Release();

   104

		performance = NULL;

   105

		proc.CoUninitialize();

   106

		return "Failed to create loader object";

   107

	}

   108

   109

	return NULL;

   110

}

   111

   112

   113

void MusicDriver_DMusic::Stop()

   114

{

   115

	seeking = false;

   116

   117

	if (performance != NULL) performance->Stop(NULL, NULL, 0, 0);

   118

   119

	if (segment != NULL) {

   120

		segment->SetParam(GUID_Unload, 0xFFFFFFFF, 0, 0, performance);

   121

		segment->Release();

   122

		segment = NULL;

   123

	}

   124

   125

	if (performance != NULL) {

   126

		performance->CloseDown();

   127

		performance->Release();

   128

		performance = NULL;

   129

	}

   130

   131

	if (loader != NULL) {

   132

		loader->Release();

   133

		loader = NULL;

   134

	}

   135

   136

	proc.CoUninitialize();

   137

}

   138

   139

   140

void MusicDriver_DMusic::PlaySong(const char* filename)

   141

{

   142

	/* set up the loader object info */

   143

	DMUS_OBJECTDESC obj_desc;

   144

	ZeroMemory(&obj_desc, sizeof(obj_desc));

   145

	obj_desc.dwSize = sizeof(obj_desc);

   146

	obj_desc.guidClass = CLSID_DirectMusicSegment;

   147

	obj_desc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME | DMUS_OBJ_FULLPATH;

   148

	MultiByteToWideChar(

   149

		CP_ACP, MB_PRECOMPOSED,

   150

		filename, -1,

   151

		obj_desc.wszFileName, lengthof(obj_desc.wszFileName)

   152

	);

   153

   154

	/* release the existing segment if we have any */

   155

	if (segment != NULL) {

   156

		segment->Release();

   157

		segment = NULL;

   158

	}

   159

   160

	/* make a new segment */

   161

	if (FAILED(loader->GetObject(

   162

				&obj_desc, IID_IDirectMusicSegment, (LPVOID*)&segment

   163

			))) {

   164

		DEBUG(driver, 0, "DirectMusic: GetObject failed");

   165

		return;

   166

	}

   167

   168

	/* tell the segment what kind of data it contains */

   169

	if (FAILED(segment->SetParam(

   170

				GUID_StandardMIDIFile, 0xFFFFFFFF, 0, 0, performance

   171

			))) {

   172

		DEBUG(driver, 0, "DirectMusic: SetParam (MIDI file) failed");

   173

		return;

   174

	}

   175

   176

	/* tell the segment to 'download' the instruments */

   177

	if (FAILED(segment->SetParam(GUID_Download, 0xFFFFFFFF, 0, 0, performance))) {

   178

		DEBUG(driver, 0, "DirectMusic: failed to download instruments");

   179

		return;

   180

	}

   181

   182

	/* start playing the MIDI file */

   183

	if (FAILED(performance->PlaySegment(segment, 0, 0, NULL))) {

   184

		DEBUG(driver, 0, "DirectMusic: PlaySegment failed");

   185

		return;

   186

	}

   187

   188

	seeking = true;

   189

}

   190

   191

   192

void MusicDriver_DMusic::StopSong()

   193

{

   194

	if (FAILED(performance->Stop(segment, NULL, 0, 0))) {

   195

		DEBUG(driver, 0, "DirectMusic: StopSegment failed");

   196

	}

   197

	seeking = false;

   198

}

   199

   200

   201

bool MusicDriver_DMusic::IsSongPlaying()

   202

{

   203

	/* Not the nicest code, but there is a short delay before playing actually

   204

	 * starts. OpenTTD makes no provision for this. */

   205

	if (performance->IsPlaying(segment, NULL) == S_OK) {

   206

		seeking = false;

   207

		return true;

   208

	} else {

   209

		return seeking;

   210

	}

   211

}

   212

   213

   214

void MusicDriver_DMusic::SetVolume(byte vol)

   215

{

   216

	long db = vol * 2000 / 127 - 2000; ///< 0 - 127 -> -2000 - 0

   217

	performance->SetGlobalParam(GUID_PerfMasterVolume, &db, sizeof(db));

   218

}

   219

   220

   221

#endif /* WIN32_ENABLE_DIRECTMUSIC_SUPPORT */