src/music/qtmidi.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /**
  11  * @file qtmidi.cpp
  12  * @brief MIDI music player for MacOS X using QuickTime.
  13  *
  14  * This music player should work in all MacOS X releases starting from 10.0,
  15  * as QuickTime is an integral part of the system since the old days of the
  16  * Motorola 68k-based Macintoshes. The only extra dependency apart from
  17  * QuickTime itself is Carbon, which is included since 10.0 as well.
  18  *
  19  * QuickTime gets fooled with the MIDI files from Transport Tycoon Deluxe
  20  * because of the @c .gm suffix. To force QuickTime to load the MIDI files
  21  * without the need of dealing with the individual QuickTime components
  22  * needed to play music (data source, MIDI parser, note allocators,
  23  * synthesizers and the like) some Carbon functions are used to set the file
  24  * type as seen by QuickTime, using @c FSpSetFInfo() (which modifies the
  25  * file's resource fork).
  26  */
  27
  28
  29 #ifndef NO_QUICKTIME
  30
  31 #include "../stdafx.h"
  32 #include "qtmidi.h"
  33 #include "../debug.h"
  34
  35 #define Rect  OTTDRect
  36 #define Point OTTDPoint
  37 #include <QuickTime/QuickTime.h>
  38 #undef Rect
  39 #undef Point
  40
  41 #include "../safeguards.h"
  42
  43 static FMusicDriver_QtMidi iFMusicDriver_QtMidi;
  44
  45
  46 static const uint MIDI_TYPE = 'Midi'; ///< OSType code for MIDI songs.
  47
  48
  49 /**
  50  * Sets the @c OSType of a given file to @c 'Midi', but only if it's not
  51  * already set.
  52  *
  53  * @param *ref A @c FSSpec structure referencing a file.
  54  */
  55 static void SetMIDITypeIfNeeded(const FSRef *ref)
  56 {
  57         FSCatalogInfo catalogInfo;
  58
  59         assert(ref);
  60
  61         if (noErr != FSGetCatalogInfo(ref, kFSCatInfoNodeFlags | kFSCatInfoFinderInfo, &catalogInfo, NULL, NULL, NULL)) return;
  62         if (!(catalogInfo.nodeFlags & kFSNodeIsDirectoryMask)) {
  63                 FileInfo * const info = (FileInfo *) catalogInfo.finderInfo;
  64                 if (info->fileType != MIDI_TYPE && !(info->finderFlags & kIsAlias)) {
  65                         OSErr e;
  66                         info->fileType = MIDI_TYPE;
  67                         e = FSSetCatalogInfo(ref, kFSCatInfoFinderInfo, &catalogInfo);
  68                         if (e == noErr) {
  69                                 DEBUG(driver, 3, "qtmidi: changed filetype to 'Midi'");
  70                         } else {
  71                                 DEBUG(driver, 0, "qtmidi: changing filetype to 'Midi' failed - error %d", e);
  72                         }
  73                 }
  74         }
  75 }
  76
  77
  78 /**
  79  * Loads a MIDI file and returns it as a QuickTime Movie structure.
  80  *
  81  * @param *path String with the path of an existing MIDI file.
  82  * @param *moov Pointer to a @c Movie where the result will be stored.
  83  * @return Whether the file was loaded and the @c Movie successfully created.
  84  */
  85 static bool LoadMovieForMIDIFile(const char *path, Movie *moov)
  86 {
  87         int fd;
  88         int ret;
  89         char magic[4];
  90         FSRef fsref;
  91         FSSpec fsspec;
  92         short refnum = 0;
  93         short resid  = 0;
  94
  95         assert(path != NULL);
  96         assert(moov != NULL);
  97
  98         DEBUG(driver, 2, "qtmidi: start loading '%s'...", path);
  99
 100         /*
 101          * XXX Manual check for MIDI header ('MThd'), as I don't know how to make
 102          * QuickTime load MIDI files without a .mid suffix without knowing it's
 103          * a MIDI file and setting the OSType of the file to the 'Midi' value.
 104          * Perhaps ugly, but it seems that it does the Right Thing(tm).
 105          */
 106         fd = open(path, O_RDONLY, 0);
 107         if (fd == -1) return false;
 108         ret = read(fd, magic, 4);
 109         close(fd);
 110         if (ret < 4) return false;
 111
 112         DEBUG(driver, 3, "qtmidi: header is '%.4s'", magic);
 113         if (magic[0] != 'M' || magic[1] != 'T' || magic[2] != 'h' || magic[3] != 'd') {
 114                 return false;
 115         }
 116
 117         if (noErr != FSPathMakeRef((const UInt8 *) path, &fsref, NULL)) return false;
 118         SetMIDITypeIfNeeded(&fsref);
 119
 120         if (noErr != FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, NULL, &fsspec, NULL)) return false;
 121         if (OpenMovieFile(&fsspec, &refnum, fsRdPerm) != noErr) return false;
 122         DEBUG(driver, 3, "qtmidi: '%s' successfully opened", path);
 123
 124         if (noErr != NewMovieFromFile(moov, refnum, &resid, NULL,
 125                                 newMovieActive | newMovieDontAskUnresolvedDataRefs, NULL)) {
 126                 CloseMovieFile(refnum);
 127                 return false;
 128         }
 129         DEBUG(driver, 3, "qtmidi: movie container created");
 130
 131         CloseMovieFile(refnum);
 132         return true;
 133 }
 134
 135
 136 /**
 137  * Flag which has the @c true value when QuickTime is available and
 138  * initialized.
 139  */
 140 static bool _quicktime_started = false;
 141
 142
 143 /**
 144  * Initialize QuickTime if needed. This function sets the
 145  * #_quicktime_started flag to @c true if QuickTime is present in the system
 146  * and it was initialized properly.
 147  */
 148 static void InitQuickTimeIfNeeded()
 149 {
 150         OSStatus dummy;
 151
 152         if (_quicktime_started) return;
 153
 154         DEBUG(driver, 2, "qtmidi: initializing Quicktime");
 155         /* Be polite: check wether QuickTime is available and initialize it. */
 156         _quicktime_started =
 157                 (noErr == Gestalt(gestaltQuickTime, &dummy)) &&
 158                 (noErr == EnterMovies());
 159         if (!_quicktime_started) DEBUG(driver, 0, "qtmidi: Quicktime initialization failed!");
 160 }
 161
 162
 163 /** Possible states of the QuickTime music driver. */
 164 enum QTStates {
 165         QT_STATE_IDLE, ///< No file loaded.
 166         QT_STATE_PLAY, ///< File loaded, playing.
 167         QT_STATE_STOP, ///< File loaded, stopped.
 168 };
 169
 170
 171 static Movie _quicktime_movie;                  ///< Current QuickTime @c Movie.
 172 static byte  _quicktime_volume = 127;           ///< Current volume.
 173 static int   _quicktime_state  = QT_STATE_IDLE; ///< Current player state.
 174
 175
 176 /**
 177  * Maps OpenTTD volume to QuickTime notion of volume.
 178  */
 179 #define VOLUME  ((short)((0x00FF & _quicktime_volume) << 1))
 180
 181
 182 /**
 183  * Initialized the MIDI player, including QuickTime initialization.
 184  *
 185  * @todo Give better error messages by inspecting error codes returned by
 186  * @c Gestalt() and @c EnterMovies(). Needs changes in
 187  * #InitQuickTimeIfNeeded.
 188  */
 189 const char *MusicDriver_QtMidi::Start(const char * const *parm)
 190 {
 191         InitQuickTimeIfNeeded();
 192         return (_quicktime_started) ? NULL : "can't initialize QuickTime";
 193 }
 194
 195
 196 /**
 197  * Checks whether the player is active.
 198  *
 199  * This function is called at regular intervals from OpenTTD's main loop, so
 200  * we call @c MoviesTask() from here to let QuickTime do its work.
 201  */
 202 bool MusicDriver_QtMidi::IsSongPlaying()
 203 {
 204         if (!_quicktime_started) return true;
 205
 206         switch (_quicktime_state) {
 207                 case QT_STATE_IDLE:
 208                 case QT_STATE_STOP:
 209                         /* Do nothing. */
 210                         break;
 211
 212                 case QT_STATE_PLAY:
 213                         MoviesTask(_quicktime_movie, 0);
 214                         /* Check wether movie ended. */
 215                         if (IsMovieDone(_quicktime_movie) ||
 216                                         (GetMovieTime(_quicktime_movie, NULL) >=
 217                                          GetMovieDuration(_quicktime_movie))) {
 218                                 _quicktime_state = QT_STATE_STOP;
 219                         }
 220         }
 221
 222         return _quicktime_state == QT_STATE_PLAY;
 223 }
 224
 225
 226 /**
 227  * Stops the MIDI player.
 228  *
 229  * Stops playing and frees any used resources before returning. As it
 230  * deinitilizes QuickTime, the #_quicktime_started flag is set to @c false.
 231  */
 232 void MusicDriver_QtMidi::Stop()
 233 {
 234         if (!_quicktime_started) return;
 235
 236         DEBUG(driver, 2, "qtmidi: stopping driver...");
 237         switch (_quicktime_state) {
 238                 case QT_STATE_IDLE:
 239                         DEBUG(driver, 3, "qtmidi: stopping not needed, already idle");
 240                         /* Do nothing. */
 241                         break;
 242
 243                 case QT_STATE_PLAY:
 244                         StopSong();
 245                         /* FALL THROUGH */
 246
 247                 case QT_STATE_STOP:
 248                         DisposeMovie(_quicktime_movie);
 249         }
 250
 251         ExitMovies();
 252         _quicktime_started = false;
 253 }
 254
 255
 256 /**
 257  * Starts playing a new song.
 258  *
 259  * @param filename Path to a MIDI file.
 260  */
 261 void MusicDriver_QtMidi::PlaySong(const char *filename)
 262 {
 263         if (!_quicktime_started) return;
 264
 265         DEBUG(driver, 2, "qtmidi: trying to play '%s'", filename);
 266         switch (_quicktime_state) {
 267                 case QT_STATE_PLAY:
 268                         StopSong();
 269                         DEBUG(driver, 3, "qtmidi: previous tune stopped");
 270                         /* FALL THROUGH */
 271
 272                 case QT_STATE_STOP:
 273                         DisposeMovie(_quicktime_movie);
 274                         DEBUG(driver, 3, "qtmidi: previous tune disposed");
 275                         _quicktime_state = QT_STATE_IDLE;
 276                         /* FALL THROUGH */
 277
 278                 case QT_STATE_IDLE:
 279                         LoadMovieForMIDIFile(filename, &_quicktime_movie);
 280                         SetMovieVolume(_quicktime_movie, VOLUME);
 281                         StartMovie(_quicktime_movie);
 282                         _quicktime_state = QT_STATE_PLAY;
 283         }
 284         DEBUG(driver, 3, "qtmidi: playing '%s'", filename);
 285 }
 286
 287
 288 /**
 289  * Stops playing the current song, if the player is active.
 290  */
 291 void MusicDriver_QtMidi::StopSong()
 292 {
 293         if (!_quicktime_started) return;
 294
 295         switch (_quicktime_state) {
 296                 case QT_STATE_IDLE:
 297                         /* FALL THROUGH */
 298
 299                 case QT_STATE_STOP:
 300                         DEBUG(driver, 3, "qtmidi: stop requested, but already idle");
 301                         /* Do nothing. */
 302                         break;
 303
 304                 case QT_STATE_PLAY:
 305                         StopMovie(_quicktime_movie);
 306                         _quicktime_state = QT_STATE_STOP;
 307                         DEBUG(driver, 3, "qtmidi: player stopped");
 308         }
 309 }
 310
 311
 312 /**
 313  * Changes the playing volume of the MIDI player.
 314  *
 315  * As QuickTime controls volume in a per-movie basis, the desired volume is
 316  * stored in #_quicktime_volume, and the volume is set here using the
 317  * #VOLUME macro, @b and when loading new song in #PlaySong.
 318  *
 319  * @param vol The desired volume, range of the value is @c 0-127
 320  */
 321 void MusicDriver_QtMidi::SetVolume(byte vol)
 322 {
 323         if (!_quicktime_started) return;
 324
 325         _quicktime_volume = vol;
 326
 327         DEBUG(driver, 2, "qtmidi: set volume to %u (%hi)", vol, VOLUME);
 328         switch (_quicktime_state) {
 329                 case QT_STATE_IDLE:
 330                         /* Do nothing. */
 331                         break;
 332
 333                 case QT_STATE_PLAY:
 334                 case QT_STATE_STOP:
 335                         SetMovieVolume(_quicktime_movie, VOLUME);
 336         }
 337 }
 338
 339 #endif /* NO_QUICKTIME */