1

/* $Id$ */

     2

     3

/**

     4

 * @file qtmidi.cpp

     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 "qtmidi.h"

    31

    32

/*

    33

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

    34

 * stuff already defined in QuickTime headers.

    35

 */

    36

#define  OTTD_Random OSX_OTTD_Random

    37

#undef   OTTD_Random

    38

#undef   WindowClass

    39

#undef   SL_ERROR

    40

#undef   bool

    41

    42

#include <assert.h>

    43

#include <unistd.h>

    44

#include <fcntl.h>

    45

    46

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

    47

#include "../debug.h"

    48

    49

static FMusicDriver_QtMidi iFMusicDriver_QtMidi;

    50

    51

    52

enum {

    53

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

    54

};

    55

    56

    57

/**

    58

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

    59

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

    60

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

    61

 *

    62

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

    63

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

    64

 *              stored.

    65

 * @return Wether the conversion was successful.

    66

 */

    67

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

    68

{

    69

	FSRef ref;

    70

	assert(spec != NULL);

    71

	assert(path != NULL);

    72

    73

	return

    74

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

    75

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

    76

}

    77

    78

    79

/**

    80

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

    81

 * already set.

    82

 *

    83

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

    84

 */

    85

static void SetMIDITypeIfNeeded(const FSSpec *spec)

    86

{

    87

	FSRef ref;

    88

	FSCatalogInfo catalogInfo;

    89

    90

	assert(spec);

    91

    92

	if (noErr != FSpMakeFSRef(spec, &ref)) return;

    93

	if (noErr != FSGetCatalogInfo(&ref, kFSCatInfoNodeFlags | kFSCatInfoFinderInfo, &catalogInfo, NULL, NULL, NULL)) return;

    94

	if (!(catalogInfo.nodeFlags & kFSNodeIsDirectoryMask)) {

    95

		FileInfo * const info = (FileInfo *) catalogInfo.finderInfo;

    96

		if (info->fileType != midiType && !(info->finderFlags & kIsAlias)) {

    97

			OSErr e;

    98

			info->fileType = midiType;

    99

			e = FSSetCatalogInfo(&ref, kFSCatInfoFinderInfo, &catalogInfo);

   100

			if (e == noErr) {

   101

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

   102

			} else {

   103

				DEBUG(driver, 0, "qtmidi: changing filetype to 'Midi' failed - error %d", e);

   104

			}

   105

		}

   106

	}

   107

}

   108

   109

   110

/**

   111

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

   112

 *

   113

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

   114

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

   115

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

   116

 */

   117

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

   118

{

   119

	int fd;

   120

	int ret;

   121

	char magic[4];

   122

	FSSpec fsspec;

   123

	short refnum = 0;

   124

	short resid  = 0;

   125

   126

	assert(path != NULL);

   127

	assert(moov != NULL);

   128

   129

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

   130

   131

	/*

   132

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

   133

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

   134

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

   135

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

   136

	 */

   137

	fd = open(path, O_RDONLY, 0);

   138

	if (fd == -1) return false;

   139

	ret = read(fd, magic, 4);

   140

	close(fd);

   141

	if (ret < 4) return false;

   142

   143

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

   144

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

   145

		return false;

   146

   147

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

   148

	SetMIDITypeIfNeeded(&fsspec);

   149

   150

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

   151

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

   152

   153

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

   154

				newMovieActive | newMovieDontAskUnresolvedDataRefs, NULL)) {

   155

		CloseMovieFile(refnum);

   156

		return false;

   157

	}

   158

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

   159

   160

	CloseMovieFile(refnum);

   161

	return true;

   162

}

   163

   164

   165

/**

   166

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

   167

 * initialized.

   168

 */

   169

static bool _quicktime_started = false;

   170

   171

   172

/**

   173

 * Initialize QuickTime if needed. This function sets the

   174

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

   175

 * and it was initialized properly.

   176

 */

   177

static void InitQuickTimeIfNeeded()

   178

{

   179

	OSStatus dummy;

   180

   181

	if (_quicktime_started) return;

   182

   183

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

   184

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

   185

	_quicktime_started =

   186

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

   187

		(noErr == EnterMovies());

   188

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

   189

}

   190

   191

   192

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

   193

enum {

   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

/**

   212

 * Initialized the MIDI player, including QuickTime initialization.

   213

 *

   214

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

   215

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

   216

 * #InitQuickTimeIfNeeded.

   217

 */

   218

const char *MusicDriver_QtMidi::Start(const char * const *parm)

   219

{

   220

	InitQuickTimeIfNeeded();

   221

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

   222

}

   223

   224

   225

/**

   226

 * Checks wether the player is active.

   227

 *

   228

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

   229

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

   230

 */

   231

bool MusicDriver_QtMidi::IsSongPlaying()

   232

{

   233

	if (!_quicktime_started) return true;

   234

   235

	switch (_quicktime_state) {

   236

		case QT_STATE_IDLE:

   237

		case QT_STATE_STOP:

   238

			/* Do nothing. */

   239

			break;

   240

		case QT_STATE_PLAY:

   241

			MoviesTask(_quicktime_movie, 0);

   242

			/* Check wether movie ended. */

   243

			if (IsMovieDone(_quicktime_movie) ||

   244

					(GetMovieTime(_quicktime_movie, NULL) >=

   245

					 GetMovieDuration(_quicktime_movie)))

   246

				_quicktime_state = QT_STATE_STOP;

   247

	}

   248

   249

	return _quicktime_state == QT_STATE_PLAY;

   250

}

   251

   252

   253

/**

   254

 * Stops the MIDI player.

   255

 *

   256

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

   257

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

   258

 */

   259

void MusicDriver_QtMidi::Stop()

   260

{

   261

	if (!_quicktime_started) return;

   262

   263

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

   264

	switch (_quicktime_state) {

   265

		case QT_STATE_IDLE:

   266

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

   267

			/* Do nothing. */

   268

			break;

   269

		case QT_STATE_PLAY:

   270

			StopSong();

   271

		case QT_STATE_STOP:

   272

			DisposeMovie(_quicktime_movie);

   273

	}

   274

   275

	ExitMovies();

   276

	_quicktime_started = false;

   277

}

   278

   279

   280

/**

   281

 * Starts playing a new song.

   282

 *

   283

 * @param filename Path to a MIDI file.

   284

 */

   285

void MusicDriver_QtMidi::PlaySong(const char *filename)

   286

{

   287

	if (!_quicktime_started) return;

   288

   289

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

   290

	switch (_quicktime_state) {

   291

		case QT_STATE_PLAY:

   292

			StopSong();

   293

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

   294

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

   295

		case QT_STATE_STOP:

   296

			DisposeMovie(_quicktime_movie);

   297

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

   298

			_quicktime_state = QT_STATE_IDLE;

   299

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

   300

		case QT_STATE_IDLE:

   301

			LoadMovieForMIDIFile(filename, &_quicktime_movie);

   302

			SetMovieVolume(_quicktime_movie, VOLUME);

   303

			StartMovie(_quicktime_movie);

   304

			_quicktime_state = QT_STATE_PLAY;

   305

	}

   306

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

   307

}

   308

   309

   310

/**

   311

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

   312

 */

   313

void MusicDriver_QtMidi::StopSong()

   314

{

   315

	if (!_quicktime_started) return;

   316

   317

	switch (_quicktime_state) {

   318

		case QT_STATE_IDLE:

   319

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

   320

		case QT_STATE_STOP:

   321

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

   322

			/* Do nothing. */

   323

			break;

   324

		case QT_STATE_PLAY:

   325

			StopMovie(_quicktime_movie);

   326

			_quicktime_state = QT_STATE_STOP;

   327

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

   328

	}

   329

}

   330

   331

   332

/**

   333

 * Changes the playing volume of the MIDI player.

   334

 *

   335

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

   336

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

   337

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

   338

 *

   339

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

   340

 */

   341

void MusicDriver_QtMidi::SetVolume(byte vol)

   342

{

   343

	if (!_quicktime_started) return;

   344

   345

	_quicktime_volume = vol;

   346

   347

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

   348

	switch (_quicktime_state) {

   349

		case QT_STATE_IDLE:

   350

			/* Do nothing. */

   351

			break;

   352

		case QT_STATE_PLAY:

   353

		case QT_STATE_STOP:

   354

			SetMovieVolume(_quicktime_movie, VOLUME);

   355

	}

   356

}

   357