1

/* $Id$ */

     2

     3

/** @file dmusic.cpp Playing music via DirectMusic. */

     4

     5

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

     6

     7

#include "../stdafx.h"

     8

#ifdef WIN32_LEAN_AND_MEAN

     9

	#undef WIN32_LEAN_AND_MEAN // Don't exclude rarely-used stuff from Windows headers

    10

#endif

    11

#include "../debug.h"

    12

#include "../win32.h"

    13

#include "dmusic.h"

    14

    15

#include <windows.h>

    16

#include <dmksctrl.h>

    17

#include <dmusici.h>

    18

#include <dmusicc.h>

    19

#include <dmusicf.h>

    20

    21

static FMusicDriver_DMusic iFMusicDriver_DMusic;

    22

    23

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

    24

static IDirectMusicPerformance* performance = NULL;

    25

    26

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

    27

static IDirectMusicLoader* loader = NULL;

    28

    29

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

    30

static IDirectMusicSegment* segment = NULL;

    31

    32

static bool seeking = false;

    33

    34

    35

#define M(x) x "\0"

    36

static const char ole_files[] =

    37

	M("ole32.dll")

    38

	M("CoCreateInstance")

    39

	M("CoInitialize")

    40

	M("CoUninitialize")

    41

	M("")

    42

;

    43

#undef M

    44

    45

struct ProcPtrs {

    46

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

    47

	HRESULT (WINAPI * CoInitialize)(LPVOID pvReserved);

    48

	void (WINAPI * CoUninitialize)();

    49

};

    50

    51

static ProcPtrs proc;

    52

    53

    54

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

    55

{

    56

	if (performance != NULL) return NULL;

    57

    58

	if (proc.CoCreateInstance == NULL) {

    59

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

    60

			return "ole32.dll load failed";

    61

	}

    62

    63

	/* Initialize COM */

    64

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

    65

		return "COM initialization failed";

    66

	}

    67

    68

	/* create the performance object */

    69

	if (FAILED(proc.CoCreateInstance(

    70

				CLSID_DirectMusicPerformance,

    71

				NULL,

    72

				CLSCTX_INPROC,

    73

				IID_IDirectMusicPerformance,

    74

				(LPVOID*)&performance

    75

			))) {

    76

		proc.CoUninitialize();

    77

		return "Failed to create the performance object";

    78

	}

    79

    80

	/* initialize it */

    81

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

    82

		performance->Release();

    83

		performance = NULL;

    84

		proc.CoUninitialize();

    85

		return "Failed to initialize performance object";

    86

	}

    87

    88

	/* choose default Windows synth */

    89

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

    90

		performance->CloseDown();

    91

		performance->Release();

    92

		performance = NULL;

    93

		proc.CoUninitialize();

    94

		return "AddPort failed";

    95

	}

    96

    97

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

    98

	if (FAILED(proc.CoCreateInstance(

    99

				CLSID_DirectMusicLoader,

   100

				NULL,

   101

				CLSCTX_INPROC,

   102

				IID_IDirectMusicLoader,

   103

				(LPVOID*)&loader

   104

			))) {

   105

		performance->CloseDown();

   106

		performance->Release();

   107

		performance = NULL;

   108

		proc.CoUninitialize();

   109

		return "Failed to create loader object";

   110

	}

   111

   112

	return NULL;

   113

}

   114

   115

   116

void MusicDriver_DMusic::Stop()

   117

{

   118

	seeking = false;

   119

   120

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

   121

   122

	if (segment != NULL) {

   123

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

   124

		segment->Release();

   125

		segment = NULL;

   126

	}

   127

   128

	if (performance != NULL) {

   129

		performance->CloseDown();

   130

		performance->Release();

   131

		performance = NULL;

   132

	}

   133

   134

	if (loader != NULL) {

   135

		loader->Release();

   136

		loader = NULL;

   137

	}

   138

   139

	proc.CoUninitialize();

   140

}

   141

   142

   143

void MusicDriver_DMusic::PlaySong(const char* filename)

   144

{

   145

	/* set up the loader object info */

   146

	DMUS_OBJECTDESC obj_desc;

   147

	ZeroMemory(&obj_desc, sizeof(obj_desc));

   148

	obj_desc.dwSize = sizeof(obj_desc);

   149

	obj_desc.guidClass = CLSID_DirectMusicSegment;

   150

	obj_desc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME | DMUS_OBJ_FULLPATH;

   151

	MultiByteToWideChar(

   152

		CP_ACP, MB_PRECOMPOSED,

   153

		filename, -1,

   154

		obj_desc.wszFileName, lengthof(obj_desc.wszFileName)

   155

	);

   156

   157

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

   158

	if (segment != NULL) {

   159

		segment->Release();

   160

		segment = NULL;

   161

	}

   162

   163

	/* make a new segment */

   164

	if (FAILED(loader->GetObject(

   165

				&obj_desc, IID_IDirectMusicSegment, (LPVOID*)&segment

   166

			))) {

   167

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

   168

		return;

   169

	}

   170

   171

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

   172

	if (FAILED(segment->SetParam(

   173

				GUID_StandardMIDIFile, 0xFFFFFFFF, 0, 0, performance

   174

			))) {

   175

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

   176

		return;

   177

	}

   178

   179

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

   180

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

   181

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

   182

		return;

   183

	}

   184

   185

	/* start playing the MIDI file */

   186

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

   187

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

   188

		return;

   189

	}

   190

   191

	seeking = true;

   192

}

   193

   194

   195

void MusicDriver_DMusic::StopSong()

   196

{

   197

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

   198

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

   199

	}

   200

	seeking = false;

   201

}

   202

   203

   204

bool MusicDriver_DMusic::IsSongPlaying()

   205

{

   206

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

   207

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

   208

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

   209

		seeking = false;

   210

		return true;

   211

	} else {

   212

		return seeking;

   213

	}

   214

}

   215

   216

   217

void MusicDriver_DMusic::SetVolume(byte vol)

   218

{

   219

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

   220

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

   221

}

   222

   223

   224

#endif /* WIN32_ENABLE_DIRECTMUSIC_SUPPORT */