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 void* drv;

    31

} DriverDesc;

    32

    33

typedef struct DriverClass {

    34

	const DriverDesc *descs;

    35

	const char *name;

    36

	void *var;

    37

} DriverClass;

    38

    87

    88

static const DriverClass _driver_classes[] = {

    89

	{_video_driver_descs, "video", &_video_driver},

    90

	{_sound_driver_descs, "sound", &_sound_driver},

    91

	{_music_driver_descs, "music", &_music_driver},

    92

};

    93

    94

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

    95

{

    96

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

    97

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

    98

	}

    99

	return NULL;

   100

}

   101

   102

void LoadDriver(int driver, const char *name)

   103

{

   104

	const DriverClass *dc = &_driver_classes[driver];

   105

	const DriverDesc *dd;

   106

	const void **var;

   107

	const void *drv;

   108

	const char *err;

   109

	char *parm;

   110

	char buffer[256];

   111

	const char *parms[32];

   112

   113

	parms[0] = NULL;

   114

   115

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

   116

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

   117

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

   118

			if (err == NULL) break;

   119

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

   120

				dc->name, dd->name, err

   121

			);

   122

		}

   123

		if (dd->name == NULL) {

   124

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

   125

		}

   126

   127

		DEBUG(driver, 1)

   128

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

   129

   130

		var = dc->var;

   131

		*var = dd->drv;

   132

	} else {

   133

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

   134

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

   135

		parm = strchr(buffer, ':');

   136

		if (parm) {

   137

			uint np = 0;

   138

			// Tokenize the parm.

   139

			do {

   140

				*parm++ = 0;

   141

				if (np < lengthof(parms) - 1)

   142

					parms[np++] = parm;

   143

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

   144

					parm++;

   145

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

   146

			parms[np] = NULL;

   147

		}

   148

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

   149

		if (dd == NULL)

   150

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

   151

   152

		var = dc->var;

   153

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

   154

		*var = NULL;

   155

		drv = dd->drv;

   156

   157

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

   158

		if (err != NULL) {

   159

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

   160

				dd->name, dd->longname, err

   161

			);

   162

		}

   163

		*var = drv;

   164

	}

   165

}

   166

   167

   168

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

   169

{

   170

	uint len = strlen(name);

   171

   172

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

   173

		const char* p = *parm;

   174

   175

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

   176

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

   177

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

   178

		}

   179

	}

   180

	return NULL;

   181

}

   182

   183

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

   184

{

   185

	return GetDriverParam(parm, name) != NULL;

   186

}

   187

   188

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

   189

{

   190

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

   191

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

   192

}

   193

   194

   195

void GetDriverList(char* p)

   196

{

   197

	const DriverClass* dc;

   198

   199

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

   200

		const DriverDesc* dd;

   201

   202

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

   203

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

   204

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

   205

		}

   206

	}

   207

}