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

#include "../stdafx.h"

    28

#include "../openttd.h"

    29

#include "qtmidi.h"

    30

    31

/*

    32

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

    33

 * stuff already defined in QuickTime headers.

    34

 */

    35

#define  bool        OSX_bool

    36

#define  Rect        OSX_Rect

    37

#define  Point       OSX_Point

    38

#define  SL_ERROR    OSX_SL_ERROR

    39

#define  WindowClass OSX_WindowClass

    40

#define  OTTD_Random OSX_OTTD_Random

    41

#include <CoreServices/CoreServices.h>

    42

#include <QuickTime/QuickTime.h>

    43

#undef   OTTD_Random

    44

#undef   WindowClass

    45

#undef   SL_ERROR

    46

#undef   Point

    47

#undef   Rect

    48

#undef   bool

    49

    50

#include <assert.h>

    51

#include <unistd.h>

    52

#include <fcntl.h>

    53

    54

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

    55

#include "../debug.h"

    56

    57

    58

enum {

    59

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

    60

};

    61

    62

    63

/**

    64

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

    65

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

    66

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

    67

 *

    68

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

    69

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

    70

 *              stored.

    71

 * @return Wether the conversion was successful.

    72

 */

    73

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

    74

{

    75

	FSRef ref;

    76

	assert(spec);

    77

	assert(path);

    78

    79

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

    80

		return false;

    81

    82

	return (noErr ==

    83

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

    84

}

    85

    86

    87

/**

    88

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

    89

 * already set.

    90

 *

    91

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

    92

 */

    93

static void SetMIDITypeIfNeeded(const FSSpec *spec)

    94

{

    95

	FInfo info;

    96

	assert(spec);

    97

    98

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

    99

   100

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

   101

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

   102

		info.fdType = midiType;

   103

		FSpSetFInfo(spec, &info);

   104

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

   105

	}

   106

}

   107

   108

   109

/**

   110

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

   111

 *

   112

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

   113

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

   114

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

   115

 */

   116

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

   117

{

   118

	int fd;

   119

	int ret;

   120

	char magic[4];

   121

	FSSpec fsspec;

   122

	short refnum = 0;

   123

	short resid  = 0;

   124

   125

	assert(path);

   126

	assert(moov);

   127

   128

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

   129

   130

	/*

   131

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

   132

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

   133

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

   134

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

   135

	 */

   136

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

   137

		return false;

   138

	ret = read(fd, magic, 4);

   139

	close(fd);

   140

	if (ret < 4) return false;

   141

   142

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

   143

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

   144

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

   145

		return false;

   146

   147

	if (!PathToFSSpec(path, &fsspec))

   148

		return false;

   149

	SetMIDITypeIfNeeded(&fsspec);

   150

   151

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

   152

		return false;

   153

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

   154

   155

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

   156

				newMovieActive | newMovieDontAskUnresolvedDataRefs, NULL))

   157

	{

   158

		CloseMovieFile(refnum);

   159

		return false;

   160

	}

   161

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

   162

   163

	CloseMovieFile(refnum);

   164

	return true;

   165

}

   166

   167

   168

/**

   169

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

   170

 * initialized.

   171

 */

   172

static bool _quicktime_started = false;

   173

   174

   175

/**

   176

 * Initialize QuickTime if needed. This function sets the

   177

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

   178

 * and it was initialized properly.

   179

 */

   180

static void InitQuickTimeIfNeeded(void)

   181

{

   182

	OSStatus dummy;

   183

   184

	if (_quicktime_started) return;

   185

   186

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

   187

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

   188

	_quicktime_started =

   189

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

   190

		(noErr == EnterMovies());

   191

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

   192

			_quicktime_started ? "successfully" : "NOT");

   193

}

   194

   195

   196

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

   197

enum

   198

{

   199

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

   200

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

   201

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

   202

};

   203

   204

   205

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

   206

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

   207

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

   208

   209

   210

/**

   211

 * Maps OpenTTD volume to QuickTime notion of volume.

   212

 */

   213

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

   214

   215

   216

static void StopSong(void);

   217

   218

   219

/**

   220

 * Initialized the MIDI player, including QuickTime initialization.

   221

 *

   222

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

   223

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

   224

 * #InitQuickTimeIfNeeded.

   225

 */

   226

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

   227

{

   228

	InitQuickTimeIfNeeded();

   229

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

   230

}

   231

   232

   233

/**

   234

 * Checks wether the player is active.

   235

 *

   236

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

   237

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

   238

 */

   239

static bool SongIsPlaying(void)

   240

{

   241

	if (!_quicktime_started) return true;

   242

   243

	switch (_quicktime_state) {

   244

		case QT_STATE_IDLE:

   245

		case QT_STATE_STOP:

   246

			/* Do nothing. */

   247

			break;

   248

		case QT_STATE_PLAY:

   249

			MoviesTask(_quicktime_movie, 0);

   250

			/* Check wether movie ended. */

   251

			if (IsMovieDone(_quicktime_movie) ||

   252

					(GetMovieTime(_quicktime_movie, NULL) >=

   253

					 GetMovieDuration(_quicktime_movie)))

   254

				_quicktime_state = QT_STATE_STOP;

   255

	}

   256

   257

	return (_quicktime_state == QT_STATE_PLAY);

   258

}

   259

   260

   261

/**

   262

 * Stops the MIDI player.

   263

 *

   264

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

   265

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

   266

 */

   267

static void StopDriver(void)

   268

{

   269

	if (!_quicktime_started) return;

   270

   271

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

   272

	switch (_quicktime_state) {

   273

		case QT_STATE_IDLE:

   274

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

   275

			/* Do nothing. */

   276

			break;

   277

		case QT_STATE_PLAY:

   278

			StopSong();

   279

		case QT_STATE_STOP:

   280

			DisposeMovie(_quicktime_movie);

   281

	}

   282

   283

	ExitMovies();

   284

	_quicktime_started = false;

   285

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

   286

}

   287

   288

   289

/**

   290

 * Starts playing a new song.

   291

 *

   292

 * @param filename Path to a MIDI file.

   293

 */

   294

static void PlaySong(const char *filename)

   295

{

   296

	if (!_quicktime_started) return;

   297

   298

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

   299

	switch (_quicktime_state) {

   300

		case QT_STATE_PLAY:

   301

			StopSong();

   302

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

   303

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

   304

		case QT_STATE_STOP:

   305

			DisposeMovie(_quicktime_movie);

   306

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

   307

			_quicktime_state = QT_STATE_IDLE;

   308

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

   309

		case QT_STATE_IDLE:

   310

			LoadMovieForMIDIFile(filename, &_quicktime_movie);

   311

			SetMovieVolume(_quicktime_movie, VOLUME);

   312

			StartMovie(_quicktime_movie);

   313

			_quicktime_state = QT_STATE_PLAY;

   314

	}

   315

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

   316

}

   317

   318

   319

/**

   320

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

   321

 */

   322

static void StopSong(void)

   323

{

   324

	if (!_quicktime_started) return;

   325

   326

	switch (_quicktime_state) {

   327

		case QT_STATE_IDLE:

   328

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

   329

		case QT_STATE_STOP:

   330

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

   331

			/* Do nothing. */

   332

			break;

   333

		case QT_STATE_PLAY:

   334

			StopMovie(_quicktime_movie);

   335

			_quicktime_state = QT_STATE_STOP;

   336

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

   337

	}

   338

}

   339

   340

   341

/**

   342

 * Changes the playing volume of the MIDI player.

   343

 *

   344

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

   345

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

   346

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

   347

 *

   348

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

   349

 */

   350

static void SetVolume(byte vol)

   351

{

   352

	if (!_quicktime_started) return;

   353

   354

	_quicktime_volume = vol;

   355

   356

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

   357

	switch (_quicktime_state) {

   358

		case QT_STATE_IDLE:

   359

			/* Do nothing. */

   360

			break;

   361

		case QT_STATE_PLAY:

   362

		case QT_STATE_STOP:

   363

			SetMovieVolume(_quicktime_movie, VOLUME);

   364

	}

   365

}

   366

   367

   368

/**

   369

 * Table of callbacks that implement the QuickTime MIDI player.

   370

 */

   371

const HalMusicDriver _qtime_music_driver = {

   372

	StartDriver,

   373

	StopDriver,

   374

	PlaySong,

   375

	StopSong,

   376

	SongIsPlaying,

   377

	SetVolume,

   378

};