2014-08-02 19:14:42 +00:00
|
|
|
/* ScummVM - Graphic Adventure Engine
|
|
|
|
*
|
|
|
|
* ScummVM is the legal property of its developers, whose names
|
|
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
|
|
* file distributed with this source distribution.
|
|
|
|
*
|
|
|
|
* This program 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; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2014-12-17 17:27:47 +00:00
|
|
|
*
|
2014-08-02 19:14:42 +00:00
|
|
|
* This program 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. See the
|
|
|
|
* GNU General Public License for more details.
|
2014-12-17 17:27:47 +00:00
|
|
|
*
|
2014-08-02 19:14:42 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2014-08-02 21:09:28 +00:00
|
|
|
#include "common/algorithm.h"
|
2015-06-30 23:30:12 +00:00
|
|
|
#include "common/config-manager.h"
|
2014-11-30 12:23:16 +00:00
|
|
|
#include "audio/mixer.h"
|
|
|
|
#include "audio/decoders/raw.h"
|
|
|
|
#include "audio/decoders/wave.h"
|
2015-06-30 23:30:12 +00:00
|
|
|
// Miles Audio
|
|
|
|
#include "audio/miles.h"
|
2014-08-02 21:09:28 +00:00
|
|
|
#include "access/access.h"
|
2014-08-02 19:14:42 +00:00
|
|
|
#include "access/sound.h"
|
|
|
|
|
|
|
|
namespace Access {
|
|
|
|
|
2014-12-07 21:28:03 +00:00
|
|
|
SoundManager::SoundManager(AccessEngine *vm, Audio::Mixer *mixer) : _vm(vm), _mixer(mixer) {
|
2014-08-02 21:09:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SoundManager::~SoundManager() {
|
2014-08-29 00:24:25 +00:00
|
|
|
clearSounds();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SoundManager::clearSounds() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "clearSounds()");
|
|
|
|
|
2014-08-30 01:03:11 +00:00
|
|
|
for (uint i = 0; i < _soundTable.size(); ++i)
|
2014-11-08 03:09:09 +00:00
|
|
|
delete _soundTable[i]._res;
|
2014-12-27 14:31:43 +00:00
|
|
|
|
2014-08-29 00:24:25 +00:00
|
|
|
_soundTable.clear();
|
2014-12-27 14:31:43 +00:00
|
|
|
|
|
|
|
if (_mixer->isSoundHandleActive(_effectsHandle))
|
|
|
|
_mixer->stopHandle(_effectsHandle);
|
|
|
|
|
|
|
|
while (_queue.size()) {
|
|
|
|
delete _queue[0];
|
|
|
|
_queue.remove_at(0);
|
|
|
|
}
|
2014-08-04 13:21:39 +00:00
|
|
|
}
|
|
|
|
|
2014-12-27 16:21:04 +00:00
|
|
|
void SoundManager::loadSoundTable(int idx, int fileNum, int subfile, int priority) {
|
2014-12-27 15:55:07 +00:00
|
|
|
debugC(1, kDebugSound, "loadSoundTable(%d, %d, %d)", idx, fileNum, subfile);
|
2014-12-07 21:28:03 +00:00
|
|
|
|
2014-11-30 12:23:16 +00:00
|
|
|
Resource *soundResource;
|
|
|
|
|
2014-11-08 03:09:09 +00:00
|
|
|
if (idx >= (int)_soundTable.size())
|
|
|
|
_soundTable.resize(idx + 1);
|
|
|
|
|
|
|
|
delete _soundTable[idx]._res;
|
2014-11-30 12:23:16 +00:00
|
|
|
soundResource = _vm->_files->loadFile(fileNum, subfile);
|
|
|
|
_soundTable[idx]._res = soundResource;
|
2014-12-27 16:21:04 +00:00
|
|
|
_soundTable[idx]._priority = priority;
|
2014-08-02 21:09:28 +00:00
|
|
|
}
|
|
|
|
|
2014-08-28 02:13:43 +00:00
|
|
|
Resource *SoundManager::loadSound(int fileNum, int subfile) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "loadSound(%d, %d)", fileNum, subfile);
|
2014-08-02 21:09:28 +00:00
|
|
|
return _vm->_files->loadFile(fileNum, subfile);
|
|
|
|
}
|
|
|
|
|
2015-07-09 21:26:44 +00:00
|
|
|
void SoundManager::playSound(int soundIndex, bool loop) {
|
|
|
|
debugC(1, kDebugSound, "playSound(%d, %d)", soundIndex, loop);
|
2014-12-07 21:28:03 +00:00
|
|
|
|
2014-11-08 03:09:09 +00:00
|
|
|
int priority = _soundTable[soundIndex]._priority;
|
2015-07-09 21:26:44 +00:00
|
|
|
playSound(_soundTable[soundIndex]._res, priority, loop);
|
2014-08-04 13:21:39 +00:00
|
|
|
}
|
|
|
|
|
2015-07-09 21:26:44 +00:00
|
|
|
void SoundManager::playSound(Resource *res, int priority, bool loop) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "playSound");
|
|
|
|
|
2014-11-30 12:23:16 +00:00
|
|
|
byte *resourceData = res->data();
|
2014-12-04 13:17:30 +00:00
|
|
|
|
2014-11-30 12:23:16 +00:00
|
|
|
assert(res->_size >= 32);
|
|
|
|
|
2015-07-09 21:26:44 +00:00
|
|
|
Audio::RewindableAudioStream *audioStream;
|
2014-12-08 23:35:02 +00:00
|
|
|
|
2014-11-30 12:23:16 +00:00
|
|
|
if (READ_BE_UINT32(resourceData) == MKTAG('R','I','F','F')) {
|
|
|
|
// CD version uses WAVE-files
|
|
|
|
Common::SeekableReadStream *waveStream = new Common::MemoryReadStream(resourceData, res->_size, DisposeAfterUse::NO);
|
|
|
|
audioStream = Audio::makeWAVStream(waveStream, DisposeAfterUse::YES);
|
|
|
|
} else if (READ_BE_UINT32(resourceData) == MKTAG('S', 'T', 'E', 'V')) {
|
|
|
|
// sound files have a fixed header of 32 bytes in total
|
|
|
|
// header content:
|
|
|
|
// "STEVE" - fixed header
|
|
|
|
// byte - sample rate
|
2014-12-12 22:22:41 +00:00
|
|
|
// 01h mapped internally to 3Ch
|
|
|
|
// 02h mapped internally to 78h
|
2014-11-30 12:23:16 +00:00
|
|
|
// 03h mapped internally to B5h
|
|
|
|
// 04h mapped internally to F1h
|
|
|
|
// byte - unknown
|
|
|
|
// word - actual sample size (should be resource-size - 32)
|
|
|
|
byte internalSampleRate = resourceData[5];
|
|
|
|
int sampleSize = READ_LE_UINT16(resourceData + 7);
|
2014-12-04 13:17:30 +00:00
|
|
|
|
2014-11-30 12:23:16 +00:00
|
|
|
assert( (sampleSize + 32) == res->_size);
|
|
|
|
|
|
|
|
int sampleRate = 0;
|
|
|
|
switch (internalSampleRate) {
|
2014-12-12 22:22:41 +00:00
|
|
|
case 1: // NEG(3Ch) -> C4h time constant
|
|
|
|
sampleRate = 16666;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2: // NEG(78h) -> 88h time constant
|
|
|
|
sampleRate = 8334;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3: // NEG(B5h) -> 4Bh time constant
|
|
|
|
sampleRate = 5525;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4: // NEG(F1h) -> 0Fh time constant
|
|
|
|
sampleRate = 4150;
|
|
|
|
break;
|
|
|
|
|
2014-11-30 12:23:16 +00:00
|
|
|
default:
|
|
|
|
error("Unexpected internal Sample Rate %d", internalSampleRate);
|
|
|
|
return;
|
|
|
|
}
|
2014-12-04 13:17:30 +00:00
|
|
|
|
2015-07-09 21:26:44 +00:00
|
|
|
audioStream = Audio::makeRawStream(resourceData + 32, sampleSize, sampleRate, 0, DisposeAfterUse::NO);
|
2014-11-30 12:23:16 +00:00
|
|
|
} else
|
|
|
|
error("Unknown format");
|
2014-12-04 13:17:30 +00:00
|
|
|
|
2015-07-09 21:26:44 +00:00
|
|
|
if (loop) {
|
|
|
|
_queue.push_back(new Audio::LoopingAudioStream(audioStream, 0, DisposeAfterUse::NO));
|
|
|
|
} else {
|
|
|
|
_queue.push_back(audioStream);
|
|
|
|
}
|
|
|
|
|
2014-12-27 14:31:43 +00:00
|
|
|
if (!_mixer->isSoundHandleActive(_effectsHandle))
|
|
|
|
_mixer->playStream(Audio::Mixer::kSFXSoundType, &_effectsHandle,
|
|
|
|
_queue[0], -1, _mixer->kMaxChannelVolume, 0,
|
2014-11-30 12:23:16 +00:00
|
|
|
DisposeAfterUse::NO);
|
2014-12-27 14:31:43 +00:00
|
|
|
}
|
2014-11-30 12:23:16 +00:00
|
|
|
|
2014-12-27 14:31:43 +00:00
|
|
|
void SoundManager::checkSoundQueue() {
|
|
|
|
debugC(5, kDebugSound, "checkSoundQueue");
|
|
|
|
|
|
|
|
if (_queue.empty() || _mixer->isSoundHandleActive(_effectsHandle))
|
|
|
|
return;
|
|
|
|
|
2015-07-09 08:53:08 +00:00
|
|
|
delete _queue[0];
|
2014-12-27 14:31:43 +00:00
|
|
|
_queue.remove_at(0);
|
2014-11-30 12:23:16 +00:00
|
|
|
|
2015-07-09 08:53:08 +00:00
|
|
|
if (_queue.size() && _queue[0])
|
2014-12-27 14:31:43 +00:00
|
|
|
_mixer->playStream(Audio::Mixer::kSFXSoundType, &_effectsHandle,
|
|
|
|
_queue[0], -1, _mixer->kMaxChannelVolume, 0,
|
2015-07-09 08:53:08 +00:00
|
|
|
DisposeAfterUse::NO);
|
2014-08-04 13:21:39 +00:00
|
|
|
}
|
2014-08-02 19:14:42 +00:00
|
|
|
|
2014-12-27 15:05:23 +00:00
|
|
|
bool SoundManager::isSFXPlaying() {
|
|
|
|
return _mixer->isSoundHandleActive(_effectsHandle);
|
2014-08-04 13:21:39 +00:00
|
|
|
}
|
2014-08-02 19:14:42 +00:00
|
|
|
|
2014-08-08 00:31:42 +00:00
|
|
|
void SoundManager::loadSounds(Common::Array<RoomInfo::SoundIdent> &sounds) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "loadSounds");
|
|
|
|
|
2014-08-29 00:24:25 +00:00
|
|
|
clearSounds();
|
|
|
|
|
|
|
|
for (uint i = 0; i < sounds.size(); ++i) {
|
2014-11-08 03:09:09 +00:00
|
|
|
Resource *sound = loadSound(sounds[i]._fileNum, sounds[i]._subfile);
|
|
|
|
_soundTable.push_back(SoundEntry(sound, sounds[i]._priority));
|
2014-08-29 00:24:25 +00:00
|
|
|
}
|
2014-08-07 02:43:40 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
void SoundManager::stopSound() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(3, kDebugSound, "stopSound");
|
|
|
|
|
2015-07-09 08:53:08 +00:00
|
|
|
_mixer->stopHandle(_effectsHandle);
|
2014-12-01 06:49:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SoundManager::freeSounds() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(3, kDebugSound, "freeSounds");
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
stopSound();
|
|
|
|
clearSounds();
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************************/
|
|
|
|
|
2014-12-12 21:33:46 +00:00
|
|
|
MusicManager::MusicManager(AccessEngine *vm) : _vm(vm) {
|
2014-12-01 06:49:26 +00:00
|
|
|
_music = nullptr;
|
|
|
|
_tempMusic = nullptr;
|
2014-12-01 13:07:09 +00:00
|
|
|
_isLooping = false;
|
2015-06-30 23:30:12 +00:00
|
|
|
_driver = nullptr;
|
2015-01-01 14:35:20 +00:00
|
|
|
_byte1F781 = false;
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2015-06-30 23:30:12 +00:00
|
|
|
MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MT32);
|
|
|
|
MusicType musicType = MidiDriver::getMusicType(dev);
|
|
|
|
|
|
|
|
// Amazon Guardians of Eden uses MIDPAK inside MIDIDRV.AP
|
|
|
|
// AdLib patches are inside MIDIDRV.AP too, 2nd resource file
|
2015-07-03 08:20:13 +00:00
|
|
|
//
|
|
|
|
// Amazon Guardians of Eden (demo) seems to use another type of driver, possibly written by Access themselves
|
|
|
|
// Martian Memorandum uses this other type of driver as well, which means it makes sense to reverse engineer it.
|
|
|
|
//
|
2015-06-30 23:30:12 +00:00
|
|
|
switch (musicType) {
|
|
|
|
case MT_ADLIB: {
|
2015-07-14 05:25:22 +00:00
|
|
|
if (_vm->getGameID() == GType_Amazon) {
|
|
|
|
Resource *midiDrvResource = _vm->_files->loadFile(92, 1);
|
|
|
|
Common::MemoryReadStream *adLibInstrumentStream = new Common::MemoryReadStream(midiDrvResource->data(), midiDrvResource->_size);
|
2015-06-30 23:30:12 +00:00
|
|
|
|
2015-07-14 05:25:22 +00:00
|
|
|
_driver = Audio::MidiDriver_Miles_AdLib_create("", "", adLibInstrumentStream);
|
2015-06-30 23:30:12 +00:00
|
|
|
|
2015-07-14 05:25:22 +00:00
|
|
|
delete midiDrvResource;
|
|
|
|
delete adLibInstrumentStream;
|
|
|
|
} else {
|
|
|
|
MidiPlayer::createDriver();
|
|
|
|
}
|
2015-06-30 23:30:12 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MT_MT32:
|
|
|
|
_driver = Audio::MidiDriver_Miles_MT32_create("");
|
|
|
|
_nativeMT32 = true;
|
|
|
|
break;
|
|
|
|
case MT_GM:
|
|
|
|
if (ConfMan.getBool("native_mt32")) {
|
|
|
|
_driver = Audio::MidiDriver_Miles_MT32_create("");
|
|
|
|
_nativeMT32 = true;
|
|
|
|
}
|
|
|
|
break;
|
2015-07-03 13:56:52 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
2015-06-30 23:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
2014-12-01 13:07:09 +00:00
|
|
|
MidiPlayer::createDriver();
|
|
|
|
MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
|
2015-06-30 23:30:12 +00:00
|
|
|
#endif
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2015-06-30 23:37:12 +00:00
|
|
|
if (_driver) {
|
|
|
|
int retValue = _driver->open();
|
|
|
|
if (retValue == 0) {
|
|
|
|
if (_nativeMT32)
|
|
|
|
_driver->sendMT32Reset();
|
|
|
|
else
|
|
|
|
_driver->sendGMReset();
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2015-06-30 23:37:12 +00:00
|
|
|
_driver->setTimerCallback(this, &timerCallback);
|
|
|
|
}
|
2014-12-01 13:07:09 +00:00
|
|
|
}
|
2014-12-01 06:49:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MusicManager::~MusicManager() {
|
|
|
|
delete _music;
|
|
|
|
delete _tempMusic;
|
2014-08-07 02:43:40 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 13:07:09 +00:00
|
|
|
void MusicManager::send(uint32 b) {
|
2015-06-30 23:30:12 +00:00
|
|
|
// Pass data directly to driver
|
|
|
|
_driver->send(b);
|
|
|
|
#if 0
|
2014-12-01 13:07:09 +00:00
|
|
|
if ((b & 0xF0) == 0xC0 && !_nativeMT32) {
|
|
|
|
b = (b & 0xFFFF00FF) | MidiDriver::_mt32ToGm[(b >> 8) & 0xFF] << 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
Audio::MidiPlayer::send(b);
|
2015-06-30 23:30:12 +00:00
|
|
|
#endif
|
2014-12-01 13:07:09 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
void MusicManager::midiPlay() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "midiPlay");
|
|
|
|
|
2015-06-30 23:37:12 +00:00
|
|
|
if (!_driver)
|
|
|
|
return;
|
|
|
|
|
2014-12-01 13:07:09 +00:00
|
|
|
if (_music->_size < 4) {
|
|
|
|
error("midiPlay() wrong music resource size");
|
|
|
|
}
|
|
|
|
|
|
|
|
stop();
|
|
|
|
|
2014-12-02 22:59:36 +00:00
|
|
|
if (READ_BE_UINT32(_music->data()) != MKTAG('F', 'O', 'R', 'M')) {
|
|
|
|
warning("midiPlay() Unexpected signature");
|
|
|
|
_isPlaying = false;
|
|
|
|
} else {
|
|
|
|
_parser = MidiParser::createParser_XMIDI();
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2014-12-02 22:59:36 +00:00
|
|
|
if (!_parser->loadMusic(_music->data(), _music->_size))
|
|
|
|
error("midiPlay() wrong music resource");
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2014-12-02 22:59:36 +00:00
|
|
|
_parser->setTrack(0);
|
|
|
|
_parser->setMidiDriver(this);
|
|
|
|
_parser->setTimerRate(_driver->getBaseTempo());
|
|
|
|
_parser->property(MidiParser::mpCenterPitchWheelOnUnload, 1);
|
|
|
|
_parser->property(MidiParser::mpSendSustainOffOnNotesOff, 1);
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2014-12-02 22:59:36 +00:00
|
|
|
// Handle music looping
|
|
|
|
_parser->property(MidiParser::mpAutoLoop, _isLooping);
|
2014-12-01 13:07:09 +00:00
|
|
|
|
2014-12-02 22:59:36 +00:00
|
|
|
setVolume(127);
|
|
|
|
_isPlaying = true;
|
|
|
|
}
|
2014-11-20 12:28:31 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
bool MusicManager::checkMidiDone() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "checkMidiDone");
|
2014-12-01 13:07:09 +00:00
|
|
|
return (!_isPlaying);
|
2014-08-06 02:17:30 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
void MusicManager::midiRepeat() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "midiRepeat");
|
|
|
|
|
2015-06-30 23:37:12 +00:00
|
|
|
if (!_driver)
|
|
|
|
return;
|
2014-12-01 13:07:09 +00:00
|
|
|
if (!_parser)
|
|
|
|
return;
|
|
|
|
|
|
|
|
_isLooping = true;
|
|
|
|
_parser->property(MidiParser::mpAutoLoop, _isLooping);
|
|
|
|
if (!_isPlaying)
|
|
|
|
_parser->setTrack(0);
|
2014-08-06 12:28:20 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
void MusicManager::stopSong() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "stopSong");
|
|
|
|
|
2015-06-30 23:37:12 +00:00
|
|
|
if (!_driver)
|
|
|
|
return;
|
|
|
|
|
2014-12-01 13:07:09 +00:00
|
|
|
stop();
|
2014-11-02 13:42:16 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 07:46:32 +00:00
|
|
|
void MusicManager::loadMusic(int fileNum, int subfile) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "loadMusic(%d, %d)", fileNum, subfile);
|
|
|
|
|
2014-12-01 07:46:32 +00:00
|
|
|
_music = _vm->_files->loadFile(fileNum, subfile);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MusicManager::loadMusic(FileIdent file) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "loadMusic(%d, %d)", file._fileNum, file._subfile);
|
|
|
|
|
2014-12-01 07:46:32 +00:00
|
|
|
_music = _vm->_files->loadFile(file);
|
2014-08-06 12:28:20 +00:00
|
|
|
}
|
2014-08-06 02:17:30 +00:00
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
void MusicManager::newMusic(int musicId, int mode) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(1, kDebugSound, "newMusic(%d, %d)", musicId, mode);
|
|
|
|
|
2015-06-30 23:37:12 +00:00
|
|
|
if (!_driver)
|
|
|
|
return;
|
|
|
|
|
2014-11-02 11:00:50 +00:00
|
|
|
if (mode == 1) {
|
|
|
|
stopSong();
|
|
|
|
freeMusic();
|
|
|
|
_music = _tempMusic;
|
|
|
|
_tempMusic = nullptr;
|
2014-12-01 13:07:09 +00:00
|
|
|
_isLooping = true;
|
2014-11-02 11:00:50 +00:00
|
|
|
} else {
|
2014-12-01 13:07:09 +00:00
|
|
|
_isLooping = (mode == 2);
|
2014-11-02 11:00:50 +00:00
|
|
|
_tempMusic = _music;
|
|
|
|
stopSong();
|
2014-12-01 07:46:32 +00:00
|
|
|
loadMusic(97, musicId);
|
2014-11-02 11:00:50 +00:00
|
|
|
}
|
2014-12-01 13:07:09 +00:00
|
|
|
|
|
|
|
if (_music)
|
|
|
|
midiPlay();
|
2014-08-30 21:17:19 +00:00
|
|
|
}
|
|
|
|
|
2014-12-01 06:49:26 +00:00
|
|
|
void MusicManager::freeMusic() {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(3, kDebugSound, "freeMusic");
|
|
|
|
|
2014-08-28 02:22:33 +00:00
|
|
|
delete _music;
|
2014-08-07 02:43:40 +00:00
|
|
|
_music = nullptr;
|
|
|
|
}
|
|
|
|
|
2014-12-01 13:07:09 +00:00
|
|
|
void MusicManager::setLoop(bool loop) {
|
2014-12-07 21:28:03 +00:00
|
|
|
debugC(3, kDebugSound, "setLoop");
|
|
|
|
|
2014-12-01 13:07:09 +00:00
|
|
|
_isLooping = loop;
|
|
|
|
if (_parser)
|
|
|
|
_parser->property(MidiParser::mpAutoLoop, _isLooping);
|
|
|
|
}
|
2014-08-02 19:14:42 +00:00
|
|
|
} // End of namespace Access
|