1

/*

     2

 * qtmidi.c - MIDI Player for OpenTTD using QuickTime (MacOS X).

     3

 */

     4

     5

/**

     6

 * @file qtmidi.c

     7

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

     8

 *

     9

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

    10

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

    11

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

    12

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

    13

 *

    14

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

    15

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

    16

 * without the need of dealing with the individual QuickTime components

    17

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

    18

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

    19

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

    20

 * file's resource fork).

    21

 */

    22

    23

    24

/*

    25

 * OpenTTD includes.

    26

 */

    27

#define  WindowClass OSX_WindowClass

    28

#include <QuickTime/QuickTime.h>

    29

#undef   WindowClass

    30

    31

#include "../stdafx.h"

    32

#include "../openttd.h"

    33

#include "qtmidi.h"

    34

    35

/*

    36

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

    37

 * stuff already defined in QuickTime headers.

    38

 */

    39

#define  OTTD_Random OSX_OTTD_Random

    40

#undef   OTTD_Random

    41

#undef   WindowClass

    42

#undef   SL_ERROR

    43

#undef   bool

    44

    45

#include <assert.h>

    46

#include <unistd.h>

    47

#include <fcntl.h>

    48

    49

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

    50

#include "../debug.h"

    51

    52

    53

enum {

    54

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

    55

};

    56

    57

    58

/**

    59

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

    60

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

    61

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

    62

 *

    63

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

    64

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

    65

 *              stored.

    66

 * @return Wether the conversion was successful.

    67

 */

    68

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

    69

{

    70

	FSRef ref;

    71

	assert(spec);

    72

	assert(path);

    73

    74

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

    75

		return false;

    76

    77

	return (noErr ==

    78

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

    79

}

    80

    81

    82

/**

    83

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

    84

 * already set.

    85

 *

    86

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

    87

 */

    88

static void SetMIDITypeIfNeeded(const FSSpec *spec)

    89

{

    90

	FInfo info;

    91

	assert(spec);

    92

    93

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

    94

    95

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

    96

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

    97

		info.fdType = midiType;

    98

		FSpSetFInfo(spec, &info);

    99

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

   100

	}

   101

}

   102

   103

   104

/**

   105

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

   106

 *

   107

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

   108

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

   109

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

   110

 */

   111

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

   112

{

   113

	int fd;

   114

	int ret;

   115

	char magic[4];

   116

	FSSpec fsspec;

   117

	short refnum = 0;

   118

	short resid  = 0;

   119

   120

	assert(path);

   121

	assert(moov);

   122

   123

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

   124

   125

	/*

   126

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

   127

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

   128

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

   129

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

   130

	 */

   131

	if ((fd = open(path, O_RDONLY, 0)) == -1)

   132

		return false;

   133

	ret = read(fd, magic, 4);

   134

	close(fd);

   135

	if (ret < 4) return false;

   136

   137

	DEBUG(driver, 3) ("qtmidi: header is '%c%c%c%c'",

   138

			magic[0], magic[1], magic[2], magic[3]);

   139

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

   140

		return false;

   141

   142

	if (!PathToFSSpec(path, &fsspec))

   143

		return false;

   144

	SetMIDITypeIfNeeded(&fsspec);

   145

   146

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

   147

		return false;

   148

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

   149

   150

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

   151

				newMovieActive | newMovieDontAskUnresolvedDataRefs, NULL))

   152

	{

   153

		CloseMovieFile(refnum);

   154

		return false;

   155

	}

   156

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

   157

   158

	CloseMovieFile(refnum);

   159

	return true;

   160

}

   161

   162

   163

/**

   164

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

   165

 * initialized.

   166

 */

   167

static bool _quicktime_started = false;

   168

   169

   170

/**

   171

 * Initialize QuickTime if needed. This function sets the

   172

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

   173

 * and it was initialized properly.

   174

 */

   175

static void InitQuickTimeIfNeeded(void)

   176

{

   177

	OSStatus dummy;

   178

   179

	if (_quicktime_started) return;

   180

   181

	DEBUG(driver, 2) ("qtmidi: trying to initialize Quicktime");

   182

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

   183

	_quicktime_started =

   184

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

   185

		(noErr == EnterMovies());

   186

	DEBUG(driver, 1) ("qtmidi: Quicktime was %s initialized",

   187

			_quicktime_started ? "successfully" : "NOT");

   188

}

   189

   190

   191

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

   192

enum

   193

{

   194

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

   195

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

   196

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

   197

};

   198

   199

   200

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

   201

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

   202

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

   203

   204

   205

/**

   206

 * Maps OpenTTD volume to QuickTime notion of volume.

   207

 */

   208

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

   209

   210

   211

static void StopSong(void);

   212

   213

   214

/**

   215

 * Initialized the MIDI player, including QuickTime initialization.

   216

 *

   217

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

   218

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

   219

 * #InitQuickTimeIfNeeded.

   220

 */

   221

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

   222

{

   223

	InitQuickTimeIfNeeded();

   224

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

   225

}

   226

   227

   228

/**

   229

 * Checks wether the player is active.

   230

 *

   231

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

   232

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

   233

 */

   234

static bool SongIsPlaying(void)

   235

{

   236

	if (!_quicktime_started) return true;

   237

   238

	switch (_quicktime_state) {

   239

		case QT_STATE_IDLE:

   240

		case QT_STATE_STOP:

   241

			/* Do nothing. */

   242

			break;

   243

		case QT_STATE_PLAY:

   244

			MoviesTask(_quicktime_movie, 0);

   245

			/* Check wether movie ended. */

   246

			if (IsMovieDone(_quicktime_movie) ||

   247

					(GetMovieTime(_quicktime_movie, NULL) >=

   248

					 GetMovieDuration(_quicktime_movie)))

   249

				_quicktime_state = QT_STATE_STOP;

   250

	}

   251

   252

	return (_quicktime_state == QT_STATE_PLAY);

   253

}

   254

   255

   256

/**

   257

 * Stops the MIDI player.

   258

 *

   259

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

   260

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

   261

 */

   262

static void StopDriver(void)

   263

{

   264

	if (!_quicktime_started) return;

   265

   266

	DEBUG(driver, 2) ("qtmidi: trying to stop driver...");

   267

	switch (_quicktime_state) {

   268

		case QT_STATE_IDLE:

   269

			DEBUG(driver, 3) ("qtmidi: nothing to do (already idle)");

   270

			/* Do nothing. */

   271

			break;

   272

		case QT_STATE_PLAY:

   273

			StopSong();

   274

		case QT_STATE_STOP:

   275

			DisposeMovie(_quicktime_movie);

   276

	}

   277

   278

	ExitMovies();

   279

	_quicktime_started = false;

   280

	DEBUG(driver, 1) ("qtmidi: driver successfully stopped");

   281

}

   282

   283

   284

/**

   285

 * Starts playing a new song.

   286

 *

   287

 * @param filename Path to a MIDI file.

   288

 */

   289

static void PlaySong(const char *filename)

   290

{

   291

	if (!_quicktime_started) return;

   292

   293

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

   294

	switch (_quicktime_state) {

   295

		case QT_STATE_PLAY:

   296

			StopSong();

   297

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

   298

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

   299

		case QT_STATE_STOP:

   300

			DisposeMovie(_quicktime_movie);

   301

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

   302

			_quicktime_state = QT_STATE_IDLE;

   303

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

   304

		case QT_STATE_IDLE:

   305

			LoadMovieForMIDIFile(filename, &_quicktime_movie);

   306

			SetMovieVolume(_quicktime_movie, VOLUME);

   307

			StartMovie(_quicktime_movie);

   308

			_quicktime_state = QT_STATE_PLAY;

   309

	}

   310

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

   311

}

   312

   313

   314

/**

   315

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

   316

 */

   317

static void StopSong(void)

   318

{

   319

	if (!_quicktime_started) return;

   320

   321

	switch (_quicktime_state) {

   322

		case QT_STATE_IDLE:

   323

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

   324

		case QT_STATE_STOP:

   325

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

   326

			/* Do nothing. */

   327

			break;

   328

		case QT_STATE_PLAY:

   329

			StopMovie(_quicktime_movie);

   330

			_quicktime_state = QT_STATE_STOP;

   331

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

   332

	}

   333

}

   334

   335

   336

/**

   337

 * Changes the playing volume of the MIDI player.

   338

 *

   339

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

   340

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

   341

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

   342

 *

   343

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

   344

 */

   345

static void SetVolume(byte vol)

   346

{

   347

	if (!_quicktime_started) return;

   348

   349

	_quicktime_volume = vol;

   350

   351

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

   352

	switch (_quicktime_state) {

   353

		case QT_STATE_IDLE:

   354

			/* Do nothing. */

   355

			break;

   356

		case QT_STATE_PLAY:

   357

		case QT_STATE_STOP:

   358

			SetMovieVolume(_quicktime_movie, VOLUME);

   359

	}

   360

}

   361

   362

   363

/**

   364

 * Table of callbacks that implement the QuickTime MIDI player.

   365

 */

   366

const HalMusicDriver _qtime_music_driver = {

   367

	StartDriver,

   368

	StopDriver,

   369

	PlaySong,

   370

	StopSong,

   371

	SongIsPlaying,

   372

	SetVolume,

   373

};