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 {

    28

	const DriverDesc *descs;

    29

	const char *name;

    30

	void *var;

    31

} DriverClass;

    32

    33

static DriverClass _driver_classes[] = {

    34

	{_video_driver_descs, "video", &_video_driver},

    35

	{_sound_driver_descs, "sound", &_sound_driver},

    36

	{_music_driver_descs, "music", &_music_driver},

    37

};

    38

    39

enum {

    40

	DF_PRIORITY_MASK = 0xF,

    41

};

    42

    43

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

    44

{

    45

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

    46

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

    47

	}

    48

	return NULL;

    49

}

    50

    51

void LoadDriver(int driver, const char *name)

    52

{

    53

	const DriverClass *dc = &_driver_classes[driver];

    54

	const DriverDesc *dd;

    55

	const void **var;

    56

	const void *drv;

    57

	const char *err;

    58

	char *parm;

    59

	char buffer[256];

    60

	const char *parms[32];

    61

    62

	parms[0] = NULL;

    63

    64

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

    65

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

    66

			err = ((const HalCommonDriver*)dd->drv)->start(parms);

    67

			if (err == NULL) break;

    68

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

    69

				dc->name, dd->name, err

    70

			);

    71

		}

    72

		if (dd->name == NULL) {

    73

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

    74

		}

    75

    76

		DEBUG(driver, 1)

    77

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

    78

    79

		var = dc->var;

    80

		*var = dd->drv;

    81

	} else {

    82

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

    83

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

    84

		parm = strchr(buffer, ':');

    85

		if (parm) {

    86

			uint np = 0;

    87

			// Tokenize the parm.

    88

			do {

    89

				*parm++ = 0;

    90

				if (np < lengthof(parms) - 1)

    91

					parms[np++] = parm;

    92

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

    93

					parm++;

    94

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

    95

			parms[np] = NULL;

    96

		}

    97

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

    98

		if (dd == NULL)

    99

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

   100

   101

		var = dc->var;

   102

		if (*var != NULL) ((const HalCommonDriver*)*var)->stop();

   103

		*var = NULL;

   104

		drv = dd->drv;

   105

   106

		err = ((const HalCommonDriver*)drv)->start(parms);

   107

		if (err != NULL) {

   108

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

   109

				dd->name, dd->longname, err

   110

			);

   111

		}

   112

		*var = drv;

   113

	}

   114

}

   115

   116

   117

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

   118

{

   119

	uint len = strlen(name);

   120

   121

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

   122

		const char* p = *parm;

   123

   124

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

   125

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

   126

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

   127

		}

   128

	}

   129

	return NULL;

   130

}

   131

   132

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

   133

{

   134

	return GetDriverParam(parm, name) != NULL;

   135

}

   136

   137

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

   138

{

   139

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

   140

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

   141

}

   142

   143

   144

void GetDriverList(char* p)

   145

{

   146

	const DriverClass* dc;

   147

   148

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

   149

		const DriverDesc* dd;

   150

   151

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

   152

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

   153

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

   154

		}

   155

	}

   156

}

   157

   158

   159

const DriverDesc _music_driver_descs[] = {

   160

#ifdef __BEOS__

   161

	{ "bemidi",  "BeOS MIDI Driver",        &_bemidi_music_driver },

   162

#endif

   163

#ifdef __OS2__

   164

	{ "os2",     "OS/2 Music Driver",       &_os2_music_driver},

   165

#endif

   166

#ifdef WIN32_ENABLE_DIRECTMUSIC_SUPPORT

   167

	{ "dmusic",  "DirectMusic MIDI Driver", &_dmusic_midi_driver },

   168

#endif

   169

#ifdef WIN32

   170

	{ "win32",   "Win32 MIDI Driver",       &_win32_music_driver },

   171

#endif

   172

#ifdef UNIX

   173

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

   174

	{ "extmidi", "External MIDI Driver",    &_extmidi_music_driver },

   175

#endif

   176

#endif

   177

	{ "null",    "Null Music Driver",       &_null_music_driver },

   178

	{ NULL, NULL, NULL}

   179

};

   180

   181

const DriverDesc _sound_driver_descs[] = {

   182

#ifdef WIN32

   183

	{ "win32", "Win32 WaveOut Driver", &_win32_sound_driver },

   184

#endif

   185

#ifdef WITH_SDL

   186

	{	"sdl",   "SDL Sound Driver",     &_sdl_sound_driver },

   187

#endif

   188

	{	"null",  "Null Sound Driver",    &_null_sound_driver },

   189

	{	NULL, NULL, NULL}

   190

};

   191

   192

const DriverDesc _video_driver_descs[] = {

   193

#ifdef WIN32

   194

	{ "win32",      "Win32 GDI Video Driver", &_win32_video_driver },

   195

#endif

   196

#ifdef WITH_SDL

   197

	{ "sdl",        "SDL Video Driver",       &_sdl_video_driver },

   198

#endif

   199

	{ "null",       "Null Video Driver",      &_null_video_driver},

   200

#ifdef ENABLE_NETWORK

   201

	{ "dedicated",	"Dedicated Video Driver",	&_dedicated_video_driver},

   202

#endif

   203

	{ NULL, NULL, NULL}

   204

};