1

/* $Id$ */

     2

     3

/**

     4

 * @file qtmidi.c

     5

 * @brief MIDI music player for MacOS X using QuickTime.

     6

 *

     7

 * This music player should work in all MacOS X releases starting from 10.0,

     8

 * as QuickTime is an integral part of the system since the old days of the

     9

 * Motorola 68k-based Macintoshes. The only extra dependency apart from

    10

 * QuickTime itself is Carbon, which is included since 10.0 as well.

    11

 *

    12

 * QuickTime gets fooled with the MIDI files from Transport Tycoon Deluxe

    13

 * because of the @c .gm suffix. To force QuickTime to load the MIDI files

    14

 * without the need of dealing with the individual QuickTime components

    15

 * needed to play music (data source, MIDI parser, note allocators,

    16

 * synthesizers and the like) some Carbon functions are used to set the file

    17

 * type as seen by QuickTime, using @c FSpSetFInfo() (which modifies the

    18

 * file's resource fork).

    19

 */

    20

    21

    22

/*

    23

 * OpenTTD includes.

    24

 */

    25

#define  WindowClass OSX_WindowClass

    26

#include <QuickTime/QuickTime.h>

    27

#undef   WindowClass

    28

    29

#include "../stdafx.h"

    30

#include "../openttd.h"

    31

#include "qtmidi.h"

    32

    33

/*

    34

 * System includes. We need to workaround with some defines because there's

    35

 * stuff already defined in QuickTime headers.

    36

 */

    37

#define  OTTD_Random OSX_OTTD_Random

    38

#undef   OTTD_Random

    39

#undef   WindowClass

    40

#undef   SL_ERROR

    41

#undef   bool

    42

    43

#include <assert.h>

    44

#include <unistd.h>

    45

#include <fcntl.h>

    46

    47

// we need to include debug.h after CoreServices because defining DEBUG will break CoreServices in OSX 10.2

    48

#include "../debug.h"

    49

    50

    51

enum {

    52

	midiType = 'Midi' /**< OSType code for MIDI songs. */

    53

};

    54

    55

    56

/**

    57

 * Converts a Unix-like pathname to a @c FSSpec structure which may be

    58

 * used with functions from several MacOS X frameworks (Carbon, QuickTime,

    59

 * etc). The pointed file or directory must exist.

    60

 *

    61

 * @param *path A string containing a Unix-like path.

    62

 * @param *spec Pointer to a @c FSSpec structure where the result will be

    63

 *              stored.

    64

 * @return Wether the conversion was successful.

    65

 */

    66

static bool PathToFSSpec(const char *path, FSSpec *spec)

    67

{

    68

	FSRef ref;

    69

	assert(spec != NULL);

    70

	assert(path != NULL);

    71

    72

	return

    73

		FSPathMakeRef((UInt8*)path, &ref, NULL) == noErr &&

    74

		FSGetCatalogInfo(&ref, kFSCatInfoNone, NULL, NULL, spec, NULL) == noErr;

    75

}

    76

    77

    78

/**

    79

 * Sets the @c OSType of a given file to @c 'Midi', but only if it's not

    80

 * already set.

    81

 *

    82

 * @param *spec A @c FSSpec structure referencing a file.

    83

 */

    84

static void SetMIDITypeIfNeeded(const FSSpec *spec)

    85

{

    86

	FInfo info;

    87

	assert(spec);

    88

    89

	if (noErr != FSpGetFInfo(spec, &info)) return;

    90

    91

	/* Set file type to 'Midi' if the file is _not_ an alias. */

    92

	if (info.fdType != midiType && !(info.fdFlags & kIsAlias)) {

    93

		info.fdType = midiType;

    94

		FSpSetFInfo(spec, &info);

    95

		DEBUG(driver, 3, "qtmidi: changed filetype to 'Midi'");

    96

	}

    97

}

    98

    99

   100

/**

   101

 * Loads a MIDI file and returns it as a QuickTime Movie structure.

   102

 *

   103

 * @param *path String with the path of an existing MIDI file.

   104

 * @param *moov Pointer to a @c Movie where the result will be stored.

   105

 * @return Wether the file was loaded and the @c Movie successfully created.

   106

 */

   107

static bool LoadMovieForMIDIFile(const char *path, Movie *moov)

   108

{

   109

	int fd;

   110

	int ret;

   111

	char magic[4];

   112

	FSSpec fsspec;

   113

	short refnum = 0;

   114

	short resid  = 0;

   115

   116

	assert(path != NULL);

   117

	assert(moov != NULL);

   118

   119

	DEBUG(driver, 2, "qtmidi: start loading '%s'...", path);

   120

   121

	/*

   122

	 * XXX Manual check for MIDI header ('MThd'), as I don't know how to make

   123

	 * QuickTime load MIDI files without a .mid suffix without knowing it's

   124

	 * a MIDI file and setting the OSType of the file to the 'Midi' value.

   125

	 * Perhahaps ugly, but it seems that it does the Right Thing(tm).

   126

	 */

   127

	fd = open(path, O_RDONLY, 0);

   128

	if (fd == -1) return false;

   129

	ret = read(fd, magic, 4);

   130

	close(fd);

   131

	if (ret < 4) return false;

   132

   133

	DEBUG(driver, 3, "qtmidi: header is '%.4s'", magic);

   134

	if (magic[0] != 'M' || magic[1] != 'T' || magic[2] != 'h' || magic[3] != 'd')

   135

		return false;

   136

   137

	if (!PathToFSSpec(path, &fsspec)) return false;

   138

	SetMIDITypeIfNeeded(&fsspec);

   139

   140

	if (OpenMovieFile(&fsspec, &refnum, fsRdPerm) != noErr) return false;

   141

	DEBUG(driver, 3, "qtmidi: '%s' successfully opened", path);

   142

   143

	if (noErr != NewMovieFromFile(moov, refnum, &resid, NULL,

   144

				newMovieActive | newMovieDontAskUnresolvedDataRefs, NULL)) {

   145

		CloseMovieFile(refnum);

   146

		return false;

   147

	}

   148

	DEBUG(driver, 3, "qtmidi: movie container created");

   149

   150

	CloseMovieFile(refnum);

   151

	return true;

   152

}

   153

   154

   155

/**

   156

 * Flag which has the @c true value when QuickTime is available and

   157

 * initialized.

   158

 */

   159

static bool _quicktime_started = false;

   160

   161

   162

/**

   163

 * Initialize QuickTime if needed. This function sets the

   164

 * #_quicktime_started flag to @c true if QuickTime is present in the system

   165

 * and it was initialized properly.

   166

 */

   167

static void InitQuickTimeIfNeeded(void)

   168

{

   169

	OSStatus dummy;

   170

   171

	if (_quicktime_started) return;

   172

   173

	DEBUG(driver, 2, "qtmidi: initializing Quicktime");

   174

	/* Be polite: check wether QuickTime is available and initialize it. */

   175

	_quicktime_started =

   176

		(noErr == Gestalt(gestaltQuickTime, &dummy)) &&

   177

		(noErr == EnterMovies());

   178

	if (!_quicktime_started) DEBUG(driver, 0, "qtmidi: Quicktime initialization failed!");

   179

}

   180

   181

   182

/** Possible states of the QuickTime music driver. */

   183

enum {

   184

	QT_STATE_IDLE, /**< No file loaded. */

   185

	QT_STATE_PLAY, /**< File loaded, playing. */

   186

	QT_STATE_STOP, /**< File loaded, stopped. */

   187

};

   188

   189

   190

static Movie _quicktime_movie;                  /**< Current QuickTime @c Movie. */

   191

static byte  _quicktime_volume = 127;           /**< Current volume. */

   192

static int   _quicktime_state  = QT_STATE_IDLE; /**< Current player state. */

   193

   194

   195

/**

   196

 * Maps OpenTTD volume to QuickTime notion of volume.

   197

 */

   198

#define VOLUME  ((short)((0x00FF & _quicktime_volume) << 1))

   199

   200

   201

static void StopSong(void);

   202

   203

   204

/**

   205

 * Initialized the MIDI player, including QuickTime initialization.

   206

 *

   207

 * @todo Give better error messages by inspecting error codes returned by

   208

 * @c Gestalt() and @c EnterMovies(). Needs changes in

   209

 * #InitQuickTimeIfNeeded.

   210

 */

   211

static const char* StartDriver(const char * const *parm)

   212

{

   213

	InitQuickTimeIfNeeded();

   214

	return (_quicktime_started) ? NULL : "can't initialize QuickTime";

   215

}

   216

   217

   218

/**

   219

 * Checks wether the player is active.

   220

 *

   221

 * This function is called at regular intervals from OpenTTD's main loop, so

   222

 * we call @c MoviesTask() from here to let QuickTime do its work.

   223

 */

   224

static bool SongIsPlaying(void)

   225

{

   226

	if (!_quicktime_started) return true;

   227

   228

	switch (_quicktime_state) {

   229

		case QT_STATE_IDLE:

   230

		case QT_STATE_STOP:

   231

			/* Do nothing. */

   232

			break;

   233

		case QT_STATE_PLAY:

   234

			MoviesTask(_quicktime_movie, 0);

   235

			/* Check wether movie ended. */

   236

			if (IsMovieDone(_quicktime_movie) ||

   237

					(GetMovieTime(_quicktime_movie, NULL) >=

   238

					 GetMovieDuration(_quicktime_movie)))

   239

				_quicktime_state = QT_STATE_STOP;

   240

	}

   241

   242

	return _quicktime_state == QT_STATE_PLAY;

   243

}

   244

   245

   246

/**

   247

 * Stops the MIDI player.

   248

 *

   249

 * Stops playing and frees any used resources before returning. As it

   250

 * deinitilizes QuickTime, the #_quicktime_started flag is set to @c false.

   251

 */

   252

static void StopDriver(void)

   253

{

   254

	if (!_quicktime_started) return;

   255

   256

	DEBUG(driver, 2, "qtmidi: stopping driver...");

   257

	switch (_quicktime_state) {

   258

		case QT_STATE_IDLE:

   259

			DEBUG(driver, 3, "qtmidi: stopping not needed, already idle");

   260

			/* Do nothing. */

   261

			break;

   262

		case QT_STATE_PLAY:

   263

			StopSong();

   264

		case QT_STATE_STOP:

   265

			DisposeMovie(_quicktime_movie);

   266

	}

   267

   268

	ExitMovies();

   269

	_quicktime_started = false;

   270

}

   271

   272

   273

/**

   274

 * Starts playing a new song.

   275

 *

   276

 * @param filename Path to a MIDI file.

   277

 */

   278

static void PlaySong(const char *filename)

   279

{

   280

	if (!_quicktime_started) return;

   281

   282

	DEBUG(driver, 2, "qtmidi: trying to play '%s'", filename);

   283

	switch (_quicktime_state) {

   284

		case QT_STATE_PLAY:

   285

			StopSong();

   286

			DEBUG(driver, 3, "qtmidi: previous tune stopped");

   287

			/* XXX Fall-through -- no break needed. */

   288

		case QT_STATE_STOP:

   289

			DisposeMovie(_quicktime_movie);

   290

			DEBUG(driver, 3, "qtmidi: previous tune disposed");

   291

			_quicktime_state = QT_STATE_IDLE;

   292

			/* XXX Fall-through -- no break needed. */

   293

		case QT_STATE_IDLE:

   294

			LoadMovieForMIDIFile(filename, &_quicktime_movie);

   295

			SetMovieVolume(_quicktime_movie, VOLUME);

   296

			StartMovie(_quicktime_movie);

   297

			_quicktime_state = QT_STATE_PLAY;

   298

	}

   299

	DEBUG(driver, 3, "qtmidi: playing '%s'", filename);

   300

}

   301

   302

   303

/**

   304

 * Stops playing the current song, if the player is active.

   305

 */

   306

static void StopSong(void)

   307

{

   308

	if (!_quicktime_started) return;

   309

   310

	switch (_quicktime_state) {

   311

		case QT_STATE_IDLE:

   312

			/* XXX Fall-through -- no break needed. */

   313

		case QT_STATE_STOP:

   314

			DEBUG(driver, 3, "qtmidi: stop requested, but already idle");

   315

			/* Do nothing. */

   316

			break;

   317

		case QT_STATE_PLAY:

   318

			StopMovie(_quicktime_movie);

   319

			_quicktime_state = QT_STATE_STOP;

   320

			DEBUG(driver, 3, "qtmidi: player stopped");

   321

	}

   322

}

   323

   324

   325

/**

   326

 * Changes the playing volume of the MIDI player.

   327

 *

   328

 * As QuickTime controls volume in a per-movie basis, the desired volume is

   329

 * stored in #_quicktime_volume, and the volume is set here using the

   330

 * #VOLUME macro, @b and when loading new song in #PlaySong.

   331

 *

   332

 * @param vol The desired volume, range of the value is @c 0-127

   333

 */

   334

static void SetVolume(byte vol)

   335

{

   336

	if (!_quicktime_started) return;

   337

   338

	_quicktime_volume = vol;

   339

   340

	DEBUG(driver, 2, "qtmidi: set volume to %u (%hi)", vol, VOLUME);

   341

	switch (_quicktime_state) {

   342

		case QT_STATE_IDLE:

   343

			/* Do nothing. */

   344

			break;

   345

		case QT_STATE_PLAY:

   346

		case QT_STATE_STOP:

   347

			SetMovieVolume(_quicktime_movie, VOLUME);

   348

	}

   349

}

   350

   351

   352

/**

   353

 * Table of callbacks that implement the QuickTime MIDI player.

   354

 */

   355

const HalMusicDriver _qtime_music_driver = {

   356

	StartDriver,

   357

	StopDriver,

   358

	PlaySong,

   359

	StopSong,

   360

	SongIsPlaying,

   361

	SetVolume,

   362

};