1

/* $Id$ */

     2

     3

/** @file driver.h */

     4

     5

#ifndef DRIVER_H

     6

#define DRIVER_H

     7

     8

#include "debug.h"

     9

#include "core/enum_type.hpp"

    10

#include "string.h"

    11

#include <string>

    12

#include <map>

    13

    14

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

    15

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

    16

    17

class Driver {

    18

public:

    19

	virtual const char *Start(const char * const *parm) = 0;

    20

    21

	virtual void Stop() = 0;

    22

    23

	virtual ~Driver() { }

    24

    25

	enum Type {

    26

		DT_BEGIN = 0,

    27

		DT_SOUND = 0,

    28

		DT_MUSIC,

    29

		DT_VIDEO,

    30

		DT_END,

    31

	};

    32

};

    33

    34

DECLARE_POSTFIX_INCREMENT(Driver::Type);

    35

    36

    37

class DriverFactoryBase {

    38

private:

    39

	Driver::Type type;

    40

	char *name;

    41

	int priority;

    42

	typedef std::map<std::string, DriverFactoryBase *> Drivers;

    43

    44

	static Drivers &GetDrivers()

    45

	{

    46

		static Drivers &s_drivers = *new Drivers();

    47

		return s_drivers;

    48

	}

    49

    50

	static Driver **GetActiveDriver(Driver::Type type)

    51

	{

    52

		static Driver *s_driver[3] = { NULL, NULL, NULL };

    53

		return &s_driver[type];

    54

	}

    55

    56

	static const char *GetDriverTypeName(Driver::Type type)

    57

	{

    58

		static const char *driver_type_name[] = { "sound", "music", "video" };

    59

		return driver_type_name[type];

    60

	}

    61

    62

protected:

    63

	/**

    64

	 * Register a driver internally, based on its name.

    65

	 * @param name the name of the driver.

    66

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

    67

	 */

    68

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

    69

	{

    70

		/* Don't register nameless Drivers */

    71

		if (name == NULL) return;

    72

    73

		this->name = strdup(name);

    74

		this->type = type;

    75

		this->priority = priority;

    76

    77

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

    78

		char buf[32];

    79

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

    80

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

    81

    82

#if !defined(NDEBUG) || defined(WITH_ASSERT)

    83

		/* NDEBUG disables asserts and gives a warning: unused variable 'P' */

    84

		std::pair<Drivers::iterator, bool> P =

    85

#endif /* !NDEBUG */

    86

		GetDrivers().insert(Drivers::value_type(buf, this));

    87

		assert(P.second);

    88

	}

    89

    90

public:

    91

	DriverFactoryBase() :

    92

		name(NULL)

    93

	{}

    94

    95

	virtual ~DriverFactoryBase() { if (this->name != NULL) GetDrivers().erase(this->name); free(this->name); }

    96

    97

	/**

    98

	 * Find the requested driver and return its class.

    99

	 * @param name the driver to select.

   100

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

   101

	 */

   102

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

   103

	{

   104

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

   105

   106

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

   107

			/* Probe for this driver */

   108

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

   109

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

   110

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

   111

					DriverFactoryBase *d = (*it).second;

   112

   113

					/* Check driver type */

   114

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

   115

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

   116

   117

					Driver *newd = d->CreateInstance();

   118

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

   119

					if (err == NULL) {

   120

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

   121

						delete *GetActiveDriver(type);

   122

						*GetActiveDriver(type) = newd;

   123

						return newd;

   124

					}

   125

   126

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

   127

					delete newd;

   128

				}

   129

			}

   130

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

   131

		} else {

   132

			char *parm;

   133

			char buffer[256];

   134

			const char *parms[32];

   135

   136

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

   137

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

   138

			parm = strchr(buffer, ':');

   139

			parms[0] = NULL;

   140

			if (parm != NULL) {

   141

				uint np = 0;

   142

				/* Tokenize the parm. */

   143

				do {

   144

					*parm++ = '\0';

   145

					if (np < lengthof(parms) - 1)

   146

						parms[np++] = parm;

   147

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

   148

						parm++;

   149

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

   150

				parms[np] = NULL;

   151

			}

   152

   153

			/* Find this driver */

   154

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

   155

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

   156

				DriverFactoryBase *d = (*it).second;

   157

   158

				/* Check driver type */

   159

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

   160

   161

				/* Check driver name */

   162

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

   163

   164

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

   165

				Driver *newd = d->CreateInstance();

   166

   167

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

   168

				if (err != NULL) {

   169

					delete newd;

   170

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

   171

				}

   172

   173

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

   174

				delete *GetActiveDriver(type);

   175

				*GetActiveDriver(type) = newd;

   176

				return newd;

   177

			}

   178

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

   179

		}

   180

	}

   181

   182

	/**

   183

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

   184

	 */

   185

	static char *GetDriversInfo(char *p, const char *last)

   186

	{

   187

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

   188

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

   189

   190

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

   191

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

   192

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

   193

					DriverFactoryBase *d = (*it).second;

   194

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

   195

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

   196

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

   197

				}

   198

			}

   199

   200

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

   201

		}

   202

   203

		return p;

   204

	}

   205

   206

	/**

   207

	 * Get a nice description of the driver-class.

   208

	 */

   209

	virtual const char *GetDescription() = 0;

   210

   211

	/**

   212

	 * Create an instance of this driver-class.

   213

	 */

   214

	virtual Driver *CreateInstance() = 0;

   215

};

   216

   217

#endif /* DRIVER_H */