1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "driver.h"

     7

#include "functions.h"

     8

#include "hal.h"

     9

#include "string.h"

    10

    11

#include "music/bemidi.h"

    12

#include "music/dmusic.h"

    13

#include "music/extmidi.h"

    14

#include "music/null_m.h"

    15

#include "music/os2_m.h"

    16

#include "music/win32_m.h"

    17

    18

#include "sound/null_s.h"

    19

#include "sound/sdl_s.h"

    20

#include "sound/win32_s.h"

    21

    22

#include "video/dedicated_v.h"

    23

#include "video/null_v.h"

    24

#include "video/sdl_v.h"

    25

#include "video/win32_v.h"

    26

    27

typedef struct DriverDesc {

    28

	const char* name;

    29

	const char* longname;

    30

	const HalCommonDriver* drv;

    31

} DriverDesc;

    32

    33

typedef struct DriverClass {

    34

	const DriverDesc *descs;

    35

	const char *name;

    36

	const HalCommonDriver** drv;

    37

} DriverClass;

    38

    39

    40

#define M(x, y, z) { x, y, (const HalCommonDriver*)z }

    41

static const DriverDesc _music_driver_descs[] = {

    42

#ifdef __BEOS__

    43

	M("bemidi",  "BeOS MIDI Driver",        &_bemidi_music_driver),

    44

#endif

    45

#ifdef __OS2__

    46

	M("os2",     "OS/2 Music Driver",       &_os2_music_driver),

    47

#endif

    48

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

    49

	M("dmusic",  "DirectMusic MIDI Driver", &_dmusic_midi_driver),

    50

#endif

    51

#ifdef WIN32

    52

	M("win32",   "Win32 MIDI Driver",       &_win32_music_driver),

    53

#endif

    54

#ifdef UNIX

    55

#if !defined(__MORPHOS__) && !defined(__AMIGA__)

    56

	M("extmidi", "External MIDI Driver",    &_extmidi_music_driver),

    57

#endif

    58

#endif

    59

	M("null",    "Null Music Driver",       &_null_music_driver),

    60

	M(NULL, NULL, NULL)

    61

};

    62

    63

static const DriverDesc _sound_driver_descs[] = {

    64

#ifdef WIN32

    65

	M("win32", "Win32 WaveOut Driver", &_win32_sound_driver),

    66

#endif

    67

#ifdef WITH_SDL

    68

	M("sdl",   "SDL Sound Driver",     &_sdl_sound_driver),

    69

#endif

    70

	M("null",  "Null Sound Driver",    &_null_sound_driver),

    71

	M(NULL, NULL, NULL)

    72

};

    73

    74

static const DriverDesc _video_driver_descs[] = {

    75

#ifdef WIN32

    76

	M("win32",      "Win32 GDI Video Driver", &_win32_video_driver),

    77

#endif

    78

#ifdef WITH_SDL

    79

	M("sdl",        "SDL Video Driver",       &_sdl_video_driver),

    80

#endif

    81

	M("null",       "Null Video Driver",      &_null_video_driver),

    82

#ifdef ENABLE_NETWORK

    83

	M("dedicated",  "Dedicated Video Driver", &_dedicated_video_driver),

    84

#endif

    85

	M(NULL, NULL, NULL)

    86

};

    87

#undef M

    88

    89

    90

#define M(x, y, z) { x, y, (const HalCommonDriver**)z }

    91

static const DriverClass _driver_classes[] = {

    92

	M(_video_driver_descs, "video", &_video_driver),

    93

	M(_sound_driver_descs, "sound", &_sound_driver),

    94

	M(_music_driver_descs, "music", &_music_driver)

    95

};

    96

#undef M

    97

    98

static const DriverDesc* GetDriverByName(const DriverDesc* dd, const char* name)

    99

{

   100

	for (; dd->name != NULL; dd++) {

   101

		if (strcmp(dd->name, name) == 0) return dd;

   102

	}

   103

	return NULL;

   104

}

   105

   106

void LoadDriver(int driver, const char *name)

   107

{

   108

	const DriverClass *dc = &_driver_classes[driver];

   109

	const DriverDesc *dd;

   110

	const char *err;

   111

   112

	if (*name == '\0') {

   113

		for (dd = dc->descs; dd->name != NULL; dd++) {

   114

			err = dd->drv->start(NULL);

   115

			if (err == NULL) break;

   116

			DEBUG(driver, 1) ("Probing %s driver \"%s\" failed with error: %s",

   117

				dc->name, dd->name, err

   118

			);

   119

		}

   120

		if (dd->name == NULL) {

   121

			error("Couldn't find any suitable %s driver", dc->name);

   122

		}

   123

   124

		DEBUG(driver, 1)

   125

			("Successfully probed %s driver \"%s\"", dc->name, dd->name);

   126

   127

		*dc->drv = dd->drv;

   128

	} else {

   129

		char* parm;

   130

		char buffer[256];

   131

		const char* parms[32];

   132

   133

		// Extract the driver name and put parameter list in parm

   134

		ttd_strlcpy(buffer, name, sizeof(buffer));

   135

		parm = strchr(buffer, ':');

   136

		parms[0] = NULL;

   137

		if (parm != NULL) {

   138

			uint np = 0;

   139

			// Tokenize the parm.

   140

			do {

   141

				*parm++ = '\0';

   142

				if (np < lengthof(parms) - 1)

   143

					parms[np++] = parm;

   144

				while (*parm != '\0' && *parm != ',')

   145

					parm++;

   146

			} while (*parm == ',');

   147

			parms[np] = NULL;

   148

		}

   149

		dd = GetDriverByName(dc->descs, buffer);

   150

		if (dd == NULL)

   151

			error("No such %s driver: %s\n", dc->name, buffer);

   152

   153

		if (*dc->drv != NULL) (*dc->drv)->stop();

   154

		*dc->drv = NULL;

   155

   156

		err = dd->drv->start(parms);

   157

		if (err != NULL) {

   158

			error("Unable to load driver %s(%s). The error was: %s\n",

   159

				dd->name, dd->longname, err

   160

			);

   161

		}

   162

		*dc->drv = dd->drv;

   163

	}

   164

}

   165

   166

   167

static const char* GetDriverParam(const char* const* parm, const char* name)

   168

{

   169

	uint len;

   170

   171

	if (parm == NULL) return NULL;

   172

   173

	len = strlen(name);

   174

	for (; *parm != NULL; parm++) {

   175

		const char* p = *parm;

   176

   177

		if (strncmp(p, name, len) == 0) {

   178

			if (p[len] == '=')  return p + len + 1;

   179

			if (p[len] == '\0') return p + len;

   180

		}

   181

	}

   182

	return NULL;

   183

}

   184

   185

bool GetDriverParamBool(const char* const* parm, const char* name)

   186

{

   187

	return GetDriverParam(parm, name) != NULL;

   188

}

   189

   190

int GetDriverParamInt(const char* const* parm, const char* name, int def)

   191

{

   192

	const char* p = GetDriverParam(parm, name);

   193

	return p != NULL ? atoi(p) : def;

   194

}

   195

   196

   197

void GetDriverList(char* p)

   198

{

   199

	const DriverClass* dc;

   200

   201

	for (dc = _driver_classes; dc != endof(_driver_classes); dc++) {

   202

		const DriverDesc* dd;

   203

   204

		p += sprintf(p, "List of %s drivers:\n", dc->name);

   205

		for (dd = dc->descs; dd->name != NULL; dd++) {

   206

			p += sprintf(p, "%10s: %s\n", dd->name, dd->longname);

   207

		}

   208

	}

   209

}