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

#define MAC_OS_X_VERSION_MIN_REQUIRED    MAC_OS_X_VERSION_10_3

    23

#include <AvailabilityMacros.h>

    24

    25

/*

    26

 * OpenTTD includes.

    27

 */

    28

#define  WindowClass OSX_WindowClass

    29

#include <QuickTime/QuickTime.h>

    30

#undef   WindowClass

    31

    32

#include "../stdafx.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

static FMusicDriver_QtMidi iFMusicDriver_QtMidi;

    53

    54

    55

enum {

    56

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

    57

};

    58

    59

    60

/**

    61

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

    62

 * already set.

    63

 *

    64

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

    65

 */

    66

static void SetMIDITypeIfNeeded(const FSRef *ref)

    67

{

    68

	FSCatalogInfo catalogInfo;

    69

    70

	assert(ref);

    71

    72

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

    73

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

    74

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

    75

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

    76

			OSErr e;

    77

			info->fileType = midiType;

    78

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

    79

			if (e == noErr) {

    80

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

    81

			} else {

    82

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

    83

			}

    84

		}

    85

	}

    86

}

    87

    88

    89

/**

    90

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

    91

 *

    92

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

    93

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

    94

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

    95

 */

    96

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

    97

{

    98

	int fd;

    99

	int ret;

   100

	char magic[4];

   101

	FSRef fsref;

   102

	FSSpec fsspec;

   103

	short refnum = 0;

   104

	short resid  = 0;

   105

   106

	assert(path != NULL);

   107

	assert(moov != NULL);

   108

   109

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

   110

   111

	/*

   112

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

   113

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

   114

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

   115

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

   116

	 */

   117

	fd = open(path, O_RDONLY, 0);

   118

	if (fd == -1) return false;

   119

	ret = read(fd, magic, 4);

   120

	close(fd);

   121

	if (ret < 4) return false;

   122

   123

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

   124

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

   125

		return false;

   126

   127

	if (noErr != FSPathMakeRef((const UInt8 *) path, &fsref, NULL)) return false;

   128

	SetMIDITypeIfNeeded(&fsref);

   129

   130

	if (noErr != FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, NULL, &fsspec, NULL)) return false;

   131

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

   132

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

   133

   134

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

   135

				newMovieActive | newMovieDontAskUnresolvedDataRefs, NULL)) {

   136

		CloseMovieFile(refnum);

   137

		return false;

   138

	}

   139

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

   140

   141

	CloseMovieFile(refnum);

   142

	return true;

   143

}

   144

   145

   146

/**

   147

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

   148

 * initialized.

   149

 */

   150

static bool _quicktime_started = false;

   151

   152

   153

/**

   154

 * Initialize QuickTime if needed. This function sets the

   155

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

   156

 * and it was initialized properly.

   157

 */

   158

static void InitQuickTimeIfNeeded()

   159

{

   160

	OSStatus dummy;

   161

   162

	if (_quicktime_started) return;

   163

   164

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

   165

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

   166

	_quicktime_started =

   167

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

   168

		(noErr == EnterMovies());

   169

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

   170

}

   171

   172

   173

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

   174

enum {

   175

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

   176

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

   177

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

   178

};

   179

   180

   181

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

   182

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

   183

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

   184

   185

   186

/**

   187

 * Maps OpenTTD volume to QuickTime notion of volume.

   188

 */

   189

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

   190

   191

   192

/**

   193

 * Initialized the MIDI player, including QuickTime initialization.

   194

 *

   195

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

   196

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

   197

 * #InitQuickTimeIfNeeded.

   198

 */

   199

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

   200

{

   201

	InitQuickTimeIfNeeded();

   202

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

   203

}

   204

   205

   206

/**

   207

 * Checks wether the player is active.

   208

 *

   209

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

   210

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

   211

 */

   212

bool MusicDriver_QtMidi::IsSongPlaying()

   213

{

   214

	if (!_quicktime_started) return true;

   215

   216

	switch (_quicktime_state) {

   217

		case QT_STATE_IDLE:

   218

		case QT_STATE_STOP:

   219

			/* Do nothing. */

   220

			break;

   221

		case QT_STATE_PLAY:

   222

			MoviesTask(_quicktime_movie, 0);

   223

			/* Check wether movie ended. */

   224

			if (IsMovieDone(_quicktime_movie) ||

   225

					(GetMovieTime(_quicktime_movie, NULL) >=

   226

					 GetMovieDuration(_quicktime_movie)))

   227

				_quicktime_state = QT_STATE_STOP;

   228

	}

   229

   230

	return _quicktime_state == QT_STATE_PLAY;

   231

}

   232

   233

   234

/**

   235

 * Stops the MIDI player.

   236

 *

   237

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

   238

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

   239

 */

   240

void MusicDriver_QtMidi::Stop()

   241

{

   242

	if (!_quicktime_started) return;

   243

   244

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

   245

	switch (_quicktime_state) {

   246

		case QT_STATE_IDLE:

   247

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

   248

			/* Do nothing. */

   249

			break;

   250

		case QT_STATE_PLAY:

   251

			StopSong();

   252

		case QT_STATE_STOP:

   253

			DisposeMovie(_quicktime_movie);

   254

	}

   255

   256

	ExitMovies();

   257

	_quicktime_started = false;

   258

}

   259

   260

   261

/**

   262

 * Starts playing a new song.

   263

 *

   264

 * @param filename Path to a MIDI file.

   265

 */

   266

void MusicDriver_QtMidi::PlaySong(const char *filename)

   267

{

   268

	if (!_quicktime_started) return;

   269

   270

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

   271

	switch (_quicktime_state) {

   272

		case QT_STATE_PLAY:

   273

			StopSong();

   274

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

   275

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

   276

		case QT_STATE_STOP:

   277

			DisposeMovie(_quicktime_movie);

   278

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

   279

			_quicktime_state = QT_STATE_IDLE;

   280

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

   281

		case QT_STATE_IDLE:

   282

			LoadMovieForMIDIFile(filename, &_quicktime_movie);

   283

			SetMovieVolume(_quicktime_movie, VOLUME);

   284

			StartMovie(_quicktime_movie);

   285

			_quicktime_state = QT_STATE_PLAY;

   286

	}

   287

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

   288

}

   289

   290

   291

/**

   292

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

   293

 */

   294

void MusicDriver_QtMidi::StopSong()

   295

{

   296

	if (!_quicktime_started) return;

   297

   298

	switch (_quicktime_state) {

   299

		case QT_STATE_IDLE:

   300

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

   301

		case QT_STATE_STOP:

   302

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

   303

			/* Do nothing. */

   304

			break;

   305

		case QT_STATE_PLAY:

   306

			StopMovie(_quicktime_movie);

   307

			_quicktime_state = QT_STATE_STOP;

   308

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

   309

	}

   310

}

   311

   312

   313

/**

   314

 * Changes the playing volume of the MIDI player.

   315

 *

   316

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

   317

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

   318

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

   319

 *

   320

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

   321

 */

   322

void MusicDriver_QtMidi::SetVolume(byte vol)

   323

{

   324

	if (!_quicktime_started) return;

   325

   326

	_quicktime_volume = vol;

   327

   328

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

   329

	switch (_quicktime_state) {

   330

		case QT_STATE_IDLE:

   331

			/* Do nothing. */

   332

			break;

   333

		case QT_STATE_PLAY:

   334

		case QT_STATE_STOP:

   335

			SetMovieVolume(_quicktime_movie, VOLUME);

   336

	}

   337

}

   338