1

/* $Id$ */

     2

     3

/** @file driver.cpp Base for all driver handling. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "driver.h"

     9

    10

#include "sound/sound_driver.hpp"

    11

#include "music/music_driver.hpp"

    12

#include "video/video_driver.hpp"

    13

    14

VideoDriver *_video_driver;

    15

char _ini_videodriver[32];

    16

int _num_resolutions;

    19

    20

SoundDriver *_sound_driver;

    21

char _ini_sounddriver[32];

    22

    23

MusicDriver *_music_driver;

    24

char _ini_musicdriver[32];

    25

    26

char _ini_blitter[32];

    27

    28

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

    29

{

    30

	size_t len;

    31

    32

	if (parm == NULL) return NULL;

    33

    34

	len = strlen(name);

    35

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

    36

		const char* p = *parm;

    37

    38

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

    39

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

    40

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

    41

		}

    42

	}

    43

	return NULL;

    44

}

    45

    46

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

    47

{

    48

	return GetDriverParam(parm, name) != NULL;

    49

}

    50

    51

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

    52

{

    53

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

    54

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

    55

}

    56

    57

/**

    58

 * Find the requested driver and return its class.

    59

 * @param name the driver to select.

    60

 * @post Sets the driver so GetCurrentDriver() returns it too.

    61

 */

    62

const Driver *DriverFactoryBase::SelectDriver(const char *name, Driver::Type type)

    63

{

    64

	if (GetDrivers().size() == 0) return NULL;

    65

    66

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

    67

		/* Probe for this driver */

    68

		for (int priority = 10; priority >= 0; priority--) {

    69

			Drivers::iterator it = GetDrivers().begin();

    70

			for (; it != GetDrivers().end(); ++it) {

    71

				DriverFactoryBase *d = (*it).second;

    72

    73

				/* Check driver type */

    74

				if (d->type != type) continue;

    75

				if (d->priority != priority) continue;

    76

    77

				Driver *newd = d->CreateInstance();

    78

				const char *err = newd->Start(NULL);

    79

				if (err == NULL) {

    80

					DEBUG(driver, 1, "Successfully probed %s driver '%s'", GetDriverTypeName(type), d->name);

    81

					delete *GetActiveDriver(type);

    82

					*GetActiveDriver(type) = newd;

    83

					return newd;

    84

				}

    85

    86

				DEBUG(driver, 1, "Probing %s driver '%s' failed with error: %s", GetDriverTypeName(type), d->name, err);

    87

				delete newd;

    88

			}

    89

		}

    90

		usererror("Couldn't find any suitable %s driver", GetDriverTypeName(type));

    91

	} else {

    92

		char *parm;

    93

		char buffer[256];

    94

		const char *parms[32];

    95

    96

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

    97

		strecpy(buffer, name, lastof(buffer));

    98

		parm = strchr(buffer, ':');

    99

		parms[0] = NULL;

   100

		if (parm != NULL) {

   101

			uint np = 0;

   102

			/* Tokenize the parm. */

   103

			do {

   104

				*parm++ = '\0';

   105

				if (np < lengthof(parms) - 1) parms[np++] = parm;

   106

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

   107

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

   108

			parms[np] = NULL;

   109

		}

   110

   111

		/* Find this driver */

   112

		Drivers::iterator it = GetDrivers().begin();

   113

		for (; it != GetDrivers().end(); ++it) {

   114

			DriverFactoryBase *d = (*it).second;

   115

   116

			/* Check driver type */

   117

			if (d->type != type) continue;

   118

   119

			/* Check driver name */

   120

			if (strcasecmp(buffer, d->name) != 0) continue;

   121

   122

			/* Found our driver, let's try it */

   123

			Driver *newd = d->CreateInstance();

   124

   125

			const char *err = newd->Start(parms);

   126

			if (err != NULL) {

   127

				delete newd;

   128

				usererror("Unable to load driver '%s'. The error was: %s", d->name, err);

   129

			}

   130

   131

			DEBUG(driver, 1, "Successfully loaded %s driver '%s'", GetDriverTypeName(type), d->name);

   132

			delete *GetActiveDriver(type);

   133

			*GetActiveDriver(type) = newd;

   134

			return newd;

   135

		}

   136

		usererror("No such %s driver: %s\n", GetDriverTypeName(type), buffer);

   137

	}

   138

}

   139

   140

/**

   141

 * Register a driver internally, based on its name.

   142

 * @param name the name of the driver.

   143

 * @note an assert() will be trigger if 2 driver with the same name try to register.

   144

 */

   145

void DriverFactoryBase::RegisterDriver(const char *name, Driver::Type type, int priority)

   146

{

   147

	/* Don't register nameless Drivers */

   148

	if (name == NULL) return;

   149

   150

	this->name = strdup(name);

   151

	this->type = type;

   152

	this->priority = priority;

   153

   154

	/* Prefix the name with driver type to make it unique */

   155

	char buf[32];

   156

	strecpy(buf, GetDriverTypeName(type), lastof(buf));

   157

	strecpy(buf + 5, name, lastof(buf));

   158

   159

	std::pair<Drivers::iterator, bool> P = GetDrivers().insert(Drivers::value_type(buf, this));

   160

	assert(P.second);

   161

}

   162

   163

/**

   164

 * Build a human readable list of available drivers, grouped by type.

   165

 */

   166

char *DriverFactoryBase::GetDriversInfo(char *p, const char *last)

   167

{

   168

	for (Driver::Type type = Driver::DT_BEGIN; type != Driver::DT_END; type++) {

   169

		p += snprintf(p, last - p, "List of %s drivers:\n", GetDriverTypeName(type));

   170

   171

		for (int priority = 10; priority >= 0; priority--) {

   172

			Drivers::iterator it = GetDrivers().begin();

   173

			for (; it != GetDrivers().end(); it++) {

   174

				DriverFactoryBase *d = (*it).second;

   175

				if (d->type != type) continue;

   176

				if (d->priority != priority) continue;

   177

				p += snprintf(p, last - p, "%18s: %s\n", d->name, d->GetDescription());

   178

			}

   179

		}

   180

   181

		p += snprintf(p, last - p, "\n");

   182

	}

   183

   184

	return p;

   185

}

   186

   187

/** Frees memory used for this->name

   188

 */

   189

DriverFactoryBase::~DriverFactoryBase() {

   190

	if (this->name == NULL) return;

   191

   192

	/* Prefix the name with driver type to make it unique */

   193

	char buf[32];

   194

	strecpy(buf, GetDriverTypeName(type), lastof(buf));

   195

	strecpy(buf + 5, this->name, lastof(buf));

   196

   197

	GetDrivers().erase(buf);

   198

	if (GetDrivers().empty()) delete &GetDrivers();

   199

	free(this->name);

   200

}