sound/mididrv.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  *
  24  */
  25
  26 #include "engines/engine.h"
  27 #include "common/config-manager.h"
  28 #include "common/str.h"
  29 #include "common/system.h"
  30 #include "common/util.h"
  31 #include "sound/mididrv.h"
  32
  33 /** Internal list of all available 'midi' drivers. */
  34 static const MidiDriverDescription s_musicDrivers[] = {
  35
  36         // The flags for the "auto" & "null" drivers indicate that they are anything
  37         // you want it to be.
  38         {"auto", "<default>", MD_AUTO, MDT_MIDI | MDT_PCSPK | MDT_ADLIB | MDT_TOWNS},
  39         {"null", "No music", MD_NULL, MDT_MIDI | MDT_PCSPK | MDT_ADLIB | MDT_TOWNS},
  40
  41 #if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
  42         {"windows", "Windows MIDI", MD_WINDOWS, MDT_MIDI},
  43 #endif
  44
  45 #if defined(UNIX) && defined(USE_ALSA)
  46         {"alsa", "ALSA", MD_ALSA, MDT_MIDI},
  47 #endif
  48
  49 #if defined(__MINT__)
  50         {"stmidi", "Atari ST MIDI", MD_STMIDI, MDT_MIDI},
  51 #endif
  52
  53 #if defined(UNIX) && !defined(__BEOS__) && !defined(MACOSX) && !defined(__MAEMO__) && !defined(__MINT__)
  54         {"seq", "SEQ", MD_SEQ, MDT_MIDI},
  55 #endif
  56
  57 #if defined(IRIX)
  58         {"dmedia", "DMedia", MD_DMEDIA, MDT_MIDI},
  59 #endif
  60
  61 #if defined(__amigaos4__)
  62         {"camd", "CAMD", MD_CAMD, MDT_MIDI},
  63 #endif
  64
  65 #if defined(MACOSX)
  66         {"core", "CoreAudio", MD_COREAUDIO, MDT_MIDI},
  67 //      {"coreaudio", "CoreAudio", MD_COREAUDIO, MDT_MIDI},
  68         {"coremidi", "CoreMIDI", MD_COREMIDI, MDT_MIDI},
  69         {"qt", "QuickTime", MD_QTMUSIC, MDT_MIDI},
  70 #endif
  71
  72 #if defined(PALMOS_MODE)
  73 #       if defined(COMPILE_CLIE)
  74         {"ypa1", "Yamaha Pa1", MD_YPA1, MDT_MIDI},
  75 #       elif defined(COMPILE_ZODIAC) && (!defined(ENABLE_SCUMM) || !defined(PALMOS_ARM))
  76         {"zodiac", "Tapwave Zodiac", MD_ZODIAC, MDT_MIDI},
  77 #       endif
  78 #endif
  79
  80 #ifdef USE_FLUIDSYNTH
  81         {"fluidsynth", "FluidSynth", MD_FLUIDSYNTH, MDT_MIDI},
  82 #endif
  83 #ifdef USE_MT32EMU
  84         {"mt32", "MT-32", MD_MT32, MDT_MIDI},
  85 #endif
  86
  87         // The flags for the "adlib" driver indicates that it can do adlib and MIDI.
  88         {"adlib", "AdLib", MD_ADLIB, MDT_ADLIB},
  89         {"pcspk", "PC Speaker", MD_PCSPK, MDT_PCSPK},
  90         {"pcjr", "IBM PCjr", MD_PCJR, MDT_PCSPK},
  91         {"cms", "Creative Music System", MD_CMS, MDT_CMS},
  92         {"towns", "FM Towns", MD_TOWNS, MDT_TOWNS},
  93 #if defined(UNIX)
  94         {"timidity", "TiMidity", MD_TIMIDITY, MDT_MIDI},
  95 #endif
  96
  97         {0, 0, MD_NULL, MDT_NONE}
  98 };
  99
 100 const byte MidiDriver::_mt32ToGm[128] = {
 101 //        0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
 102           0,   1,   0,   2,   4,   4,   5,   3,  16,  17,  18,  16,  16,  19,  20,  21, // 0x
 103           6,   6,   6,   7,   7,   7,   8, 112,  62,  62,  63,  63,  38,  38,  39,  39, // 1x
 104          88,  95,  52,  98,  97,  99,  14,  54, 102,  96,  53, 102,  81, 100,  14,  80, // 2x
 105          48,  48,  49,  45,  41,  40,  42,  42,  43,  46,  45,  24,  25,  28,  27, 104, // 3x
 106          32,  32,  34,  33,  36,  37,  35,  35,  79,  73,  72,  72,  74,  75,  64,  65, // 4x
 107          66,  67,  71,  71,  68,  69,  70,  22,  56,  59,  57,  57,  60,  60,  58,  61, // 5x
 108          61,  11,  11,  98,  14,   9,  14,  13,  12, 107, 107,  77,  78,  78,  76,  76, // 6x
 109          47, 117, 127, 118, 118, 116, 115, 119, 115, 112,  55, 124, 123,   0,  14, 117  // 7x
 110 };
 111
 112 const byte MidiDriver::_gmToMt32[128] = {
 113 //        0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
 114           5,   1,   2,   7,   3,   5,  16,  21,  22, 101, 101,  97, 104, 103, 102,  20, // 0x
 115           8,   9,  11,  12,  14,  15,  87,  15,  59,  60,  61,  62,  67,  44,  79,  23, // 1x
 116          64,  67,  66,  70,  68,  69,  28,  31,  52,  54,  55,  56,  49,  51,  57, 112, // 2x
 117          48,  50,  45,  26,  34,  35,  45, 122,  89,  90,  94,  81,  92,  95,  24,  25, // 3x
 118          80,  78,  79,  78,  84,  85,  86,  82,  74,  72,  76,  77, 110, 107, 108,  76, // 4x
 119          47,  44, 111,  45,  44,  34,  44,  30,  32,  33,  88,  34,  35,  35,  38,  33, // 5x
 120          41,  36, 100,  37,  40,  34,  43,  40,  63,  21,  99, 105, 103,  86,  55,  84, // 6x
 121         101, 103, 100, 120, 117, 113,  99, 128, 128, 128, 128, 124, 123, 128, 128, 128, // 7x
 122 };
 123
 124 const MidiDriverDescription *MidiDriver::getAvailableMidiDrivers() {
 125         return s_musicDrivers;
 126 }
 127
 128 const MidiDriverDescription *MidiDriver::findMusicDriver(const Common::String &str) {
 129         if (str.empty())
 130                 return 0;
 131
 132         const char *s = str.c_str();
 133         int len = 0;
 134         const MidiDriverDescription *md = s_musicDrivers;
 135
 136         // Scan for string end or a colon
 137         while (s[len] != 0 && s[len] != ':')
 138                 len++;
 139
 140         while (md->name) {
 141                 // Compare the string passed to us with the current table entry.
 142                 // We ignore any characters following an (optional) colon ':'
 143                 // contained in str.
 144                 if (!scumm_strnicmp(md->name, s, len)) {
 145                         return md;
 146                 }
 147                 md++;
 148         }
 149
 150         return 0;
 151 }
 152
 153 static MidiDriverType getDefaultMIDIDriver() {
 154 #if defined(WIN32) && !defined(_WIN32_WCE) &&  !defined(__SYMBIAN32__)
 155         return MD_WINDOWS;
 156 #elif defined(MACOSX)
 157         return MD_COREAUDIO;
 158 #elif defined(PALMOS_MODE)
 159   #if defined(COMPILE_CLIE)
 160         return MD_YPA1;
 161   #elif defined(COMPILE_ZODIAC)
 162         return MD_ZODIAC;
 163   #else
 164         return MD_NULL;
 165   #endif
 166 #else
 167         return MD_NULL;
 168 #endif
 169 }
 170
 171 MidiDriverType MidiDriver::parseMusicDriver(const Common::String &str) {
 172         const MidiDriverDescription *md = findMusicDriver(str);
 173         if (md)
 174                 return md->id;
 175         return MD_AUTO;
 176 }
 177
 178 MidiDriverType MidiDriver::detectMusicDriver(int flags) {
 179         MidiDriverType musicDriver;
 180
 181         // Query the selected music driver (defaults to MD_AUTO).
 182         const MidiDriverDescription *md = findMusicDriver(ConfMan.get("music_driver"));
 183
 184         // Check whether the selected music driver is compatible with the
 185         // given flags.
 186         if (!md || !(md->flags & flags))
 187                 musicDriver = MD_AUTO;
 188         else
 189                 musicDriver = md->id;
 190
 191         // If the selected driver is MD_AUTO, we try to determine
 192         // a suitable and "optimal" music driver.
 193         if (musicDriver == MD_AUTO) {
 194
 195                 if (flags & MDT_PREFER_MIDI) {
 196                         // A MIDI music driver is preferred. Of course this implies
 197                         // that MIDI is actually listed in flags, so we verify that.
 198                         assert(flags & MDT_MIDI);
 199
 200                         // Query the default MIDI driver. It's possible that there
 201                         // is none, in which case we revert to AUTO mode.
 202                         musicDriver = getDefaultMIDIDriver();
 203                         if (musicDriver == MD_NULL)
 204                                 musicDriver = MD_AUTO;
 205                 }
 206
 207                 if (musicDriver == MD_AUTO) {
 208                         // MIDI is not preferred, or no default MIDI device is available.
 209                         // In this case we first try the alternate drivers before checking
 210                         // for a 'real' MIDI driver.
 211
 212                         if (flags & MDT_TOWNS)
 213                                 musicDriver = MD_TOWNS;
 214                         else if (flags & MDT_ADLIB)
 215                                 musicDriver = MD_ADLIB;
 216                         else if (flags & MDT_PCSPK)
 217                                 musicDriver = MD_PCJR;
 218                         else if (flags & MDT_MIDI)
 219                                 musicDriver = getDefaultMIDIDriver();
 220                         else
 221                                 musicDriver = MD_NULL;
 222                 }
 223         }
 224
 225         return musicDriver;
 226 }
 227
 228 MidiDriver *MidiDriver::createMidi(int midiDriver) {
 229         switch (midiDriver) {
 230         case MD_NULL:      return MidiDriver_NULL_create(g_system->getMixer());
 231
 232         case MD_ADLIB:     return MidiDriver_ADLIB_create(g_system->getMixer());
 233
 234         case MD_TOWNS:     return MidiDriver_YM2612_create(g_system->getMixer());
 235
 236         // Right now PC Speaker and PCjr are handled
 237         // outside the MidiDriver architecture, so
 238         // don't create anything for now.
 239         case MD_PCSPK:
 240         case MD_CMS:
 241         case MD_PCJR:      return NULL;
 242
 243 #ifdef USE_FLUIDSYNTH
 244         case MD_FLUIDSYNTH:     return MidiDriver_FluidSynth_create(g_system->getMixer());
 245 #endif
 246
 247 #ifdef USE_MT32EMU
 248         case MD_MT32:      return MidiDriver_MT32_create(g_system->getMixer());
 249 #endif
 250
 251 #if defined(PALMOS_MODE)
 252 #if defined(COMPILE_CLIE)
 253         case MD_YPA1:      return MidiDriver_YamahaPa1_create(g_system->getMixer());
 254 #elif defined(COMPILE_ZODIAC) && (!defined(ENABLE_SCUMM) || !defined(PALMOS_ARM))
 255         case MD_ZODIAC:    return MidiDriver_Zodiac_create(g_system->getMixer());
 256 #endif
 257 #endif
 258
 259 #if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
 260         case MD_WINDOWS:   return MidiDriver_WIN_create(g_system->getMixer());
 261 #endif
 262 #if defined(__MINT__)
 263         case MD_STMIDI:    return MidiDriver_STMIDI_create(g_system->getMixer());
 264 #endif
 265 #if defined(UNIX) && !defined(__BEOS__) && !defined(MACOSX) && !defined(__MAEMO__) && !defined(__MINT__)
 266         case MD_SEQ:       return MidiDriver_SEQ_create(g_system->getMixer());
 267 #endif
 268 #if defined(UNIX)
 269         case MD_TIMIDITY:  return MidiDriver_TIMIDITY_create(g_system->getMixer());
 270 #endif
 271 #if defined(IRIX)
 272         case MD_DMEDIA:    return MidiDriver_DMEDIA_create(g_system->getMixer());
 273 #endif
 274 #if defined(MACOSX)
 275         case MD_QTMUSIC:   return MidiDriver_QT_create(g_system->getMixer());
 276         case MD_COREAUDIO: return MidiDriver_CORE_create(g_system->getMixer());
 277         case MD_COREMIDI:  return MidiDriver_CoreMIDI_create(g_system->getMixer());
 278 #endif
 279 #if defined(UNIX) && defined(USE_ALSA)
 280         case MD_ALSA:      return MidiDriver_ALSA_create(g_system->getMixer());
 281 #endif
 282 #if defined(__amigaos4__)
 283         case MD_CAMD:      return MidiDriver_CAMD_create(g_system->getMixer());
 284 #endif
 285         }
 286
 287         error("Invalid midi driver selected");
 288         return NULL;
 289 }