scummvm/engines/groovie/music.cpp

/* 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 3 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "audio/mididrv.h"
#include "audio/mixer.h"

#include "groovie/music.h"
#include "groovie/groovie.h"
#include "groovie/resource.h"
#include "groovie/logic/tlcgame.h"

#include "backends/audiocd/audiocd.h"
#include "common/config-manager.h"
#include "common/debug.h"
#include "common/file.h"
#include "common/macresman.h"
#include "common/memstream.h"
#include "common/textconsole.h"
#include "audio/audiostream.h"
#include "audio/midiparser.h"
#include "audio/miles.h"
#include "audio/decoders/mp3.h"
#include "audio/decoders/quicktime.h"

namespace Groovie {

// MusicPlayer

MusicPlayer::MusicPlayer(GroovieEngine *vm) :
	_vm(vm), _isPlaying(false), _backgroundFileRef(0), _gameVolume(100),
	_prevCDtrack(0), _backgroundDelay(0), _fadingStartTime(0), _fadingStartVolume(0),
	_fadingEndVolume(0), _fadingDuration(0), _midiInit(false), _userVolume(0) {
}

MusicPlayer::~MusicPlayer() {
	g_system->getAudioCDManager()->stop();
}

void MusicPlayer::playSong(uint32 fileref) {
	Common::StackLock lock(_mutex);

	if (_isPlaying)
		unload();

	// Set the volumes
	_fadingEndVolume = 100;
	_gameVolume = 100;
	updateVolume();

	// Play the referenced file once
	play(fileref, false);
}

void MusicPlayer::setBackgroundSong(uint32 fileref) {
	Common::StackLock lock(_mutex);

	debugC(1, kDebugMIDI, "Groovie::Music: Changing the background song: %04X", fileref);
	_backgroundFileRef = fileref;
}

void MusicPlayer::frameTick() {
	if (_backgroundDelay > 0) {
		_backgroundDelay--;
		if (_backgroundDelay == 0)
			playSong(_backgroundFileRef);
	}
}

void MusicPlayer::setBackgroundDelay(uint16 delay) {
	_backgroundDelay = delay;
}

void MusicPlayer::playCD(uint8 track) {
	int startms = 0;

	// Stop the MIDI playback
	unload();

	debugC(1, kDebugMIDI, "Groovie::Music: Playing CD track %d", track);

	if (track == 3) {
		// This is the credits song, start at 23:20
		startms = 1400000;
		// TODO: If we want to play it directly from the CD, we should decrement
		// the song number (it's track 2 on the 2nd CD)
	} else if ((track == 98) && (_prevCDtrack == 3)) {
		// Track 98 is used as a hack to stop the credits song
		g_system->getAudioCDManager()->stop();
		stopCreditsIOS();
		return;
	}

	// Save the playing track in order to be able to stop the credits song
	_prevCDtrack = track;

	// Wait until the CD stops playing the current song
	// It was in the original interpreter, but it introduces a big delay
	// in the middle of the introduction, so it's disabled right now
	/*
	g_system->getAudioCDManager()->updateCD();
	while (g_system->getAudioCDManager()->isPlaying()) {
		// Wait a bit and try again
		_vm->_system->delayMillis(100);
		g_system->getAudioCDManager()->updateCD();
	}
	*/

	// Play the track starting at the requested offset (1000ms = 75 frames)
	g_system->getAudioCDManager()->play(track - 1, 1, startms * 75 / 1000, 0);

	// If the audio is not playing from the CD, play the "fallback" MIDI.
	// The Mac version has no CD tracks, so it will always use the MIDI.
	if (!g_system->getAudioCDManager()->isPlaying()) {
		if (track == 2) {
			// Intro MIDI fallback
			if (_vm->getPlatform() == Common::kPlatformMacintosh)
				playSong(70);
			else
				playSong((19 << 10) | 36); // XMI.GJD, file 36
		} else if (track == 3) {
			// TODO: Credits MIDI fallback
			if (_vm->getPlatform() == Common::kPlatformIOS)
				playCreditsIOS();
		}
	}
}

void MusicPlayer::startBackground() {
	debugC(3, kDebugMIDI, "Groovie::Music: startBackground()");
	if (!_isPlaying && _backgroundFileRef) {
		debugC(3, kDebugMIDI, "Groovie::Music: Starting the background song (0x%4X)", _backgroundFileRef);
		play(_backgroundFileRef, true);
	}
}

void MusicPlayer::setUserVolume(uint16 volume) {
	Common::StackLock lock(_mutex);

	// Save the new user volume
	_userVolume = volume;
	if (_userVolume > 0x100)
		_userVolume = 0x100;

	// Apply it
	updateVolume();
}

void MusicPlayer::setGameVolume(uint16 volume, uint16 time) {
	Common::StackLock lock(_mutex);

	debugC(1, kDebugMIDI, "Groovie::Music: Setting game volume from %d to %d in %dms", _gameVolume, volume, time);

	// Save the start parameters of the fade
	_fadingStartTime = _vm->_system->getMillis();
	_fadingStartVolume = _gameVolume;
	_fadingDuration = time;

	// Save the new game volume
	_fadingEndVolume = volume;
	if (_fadingEndVolume > 100)
		_fadingEndVolume = 100;
}

bool MusicPlayer::play(uint32 fileref, bool loop) {
	// Unload the previous song
	unload();

	// Set the new state
	_isPlaying = true;

	// Load the new file
	return load(fileref, loop);
}

void MusicPlayer::stop() {
	_backgroundFileRef = 0;
	setBackgroundDelay(0);
	unload();
}

void MusicPlayer::applyFading() {
	debugC(6, kDebugMIDI, "Groovie::Music: applyFading() _fadingStartTime = %d, _fadingDuration = %d, _fadingStartVolume = %d, _fadingEndVolume = %d", _fadingStartTime, _fadingDuration, _fadingStartVolume, _fadingEndVolume);
	Common::StackLock lock(_mutex);

	// Calculate the passed time
	uint32 time = _vm->_system->getMillis() - _fadingStartTime;
	debugC(6, kDebugMIDI, "Groovie::Music: time = %d, _gameVolume = %d", time, _gameVolume);
	if (time >= _fadingDuration) {
		// Set the end volume
		_gameVolume = _fadingEndVolume;
	} else {
		// Calculate the interpolated volume for the current time
		_gameVolume = (_fadingStartVolume * (_fadingDuration - time) +
			_fadingEndVolume * time) / _fadingDuration;
	}
	if (_gameVolume == _fadingEndVolume) {
		// If we were fading to 0, stop the playback and restore the volume
		if (_fadingEndVolume == 0) {
			debugC(1, kDebugMIDI, "Groovie::Music: Faded to zero: end of song. _fadingEndVolume set to 100");
			// WORKAROUND The original interpreter would keep playing a track
			// at volume 0 after it has faded out. When a new track was
			// started, it would restore the volume first and a short part of
			// the old track would be heard before the new track would start.
			// To prevent this, playback is actually stopped after fading out,
			// but _isPlaying remains true. This keeps the original
			// interpreter behavior of not starting the background music, but
			// it prevents the issue when starting playback of a new track.
			unload(false);
		}
	}

	// Apply it
	updateVolume();
}

void MusicPlayer::onTimer(void *refCon) {
	debugC(9, kDebugMIDI, "Groovie::Music: onTimer()");
	MusicPlayer *music = (MusicPlayer *)refCon;
	Common::StackLock lock(music->_mutex);

	// Apply the game volume fading
	if (music->_gameVolume != music->_fadingEndVolume) {
		// Apply the next step of the fading
		music->applyFading();
	}

	// If the game is accepting user input, start the background music if necessary
	if (music->_vm->isWaitingForInput())
		music->startBackground();

	// Handle internal timed events
	music->onTimerInternal();
}

void MusicPlayer::unload(bool updateState) {
	debugC(1, kDebugMIDI, "Groovie::Music: Stopping the playback");

	if (updateState)
		// Set the new state
		_isPlaying = false;
}

void MusicPlayer::playCreditsIOS() {
	Audio::AudioStream *stream = Audio::SeekableAudioStream::openStreamFile("7th_Guest_Dolls_from_Hell_OC_ReMix");

	if (!stream) {
		warning("Could not find '7th_Guest_Dolls_from_Hell_OC_ReMix' audio file");
		return;
	}

	_vm->_system->getMixer()->playStream(Audio::Mixer::kMusicSoundType, &_handleCreditsIOS, stream);
}

void MusicPlayer::stopCreditsIOS() {
	_vm->_system->getMixer()->stopHandle(_handleCreditsIOS);
}

// MusicPlayerMidi

MusicPlayerMidi::MusicPlayerMidi(GroovieEngine *vm) :
	MusicPlayer(vm), _midiParser(nullptr), _data(nullptr), _driver(nullptr) {
	// Initialize the channel volumes
	for (int i = 0; i < 0x10; i++) {
		_chanVolumes[i] = 0x7F;
	}
}

MusicPlayerMidi::~MusicPlayerMidi() {
	// Stop the callback
	if (_driver)
		_driver->setTimerCallback(nullptr, nullptr);

	Common::StackLock lock(_mutex);

	// Unload the parser
	unload();
	delete _midiParser;

	// Unload the MIDI Driver
	if (_driver) {
		_driver->close();
		delete _driver;
	}
}

void MusicPlayerMidi::send(uint32 b) {
	if ((b & 0xFFF0) == 0x07B0) { // Volume change
		// Save the specific channel volume
		byte chan = b & 0xF;
		_chanVolumes[chan] = (b >> 16) & 0x7F;

		// Send the updated value
		updateChanVolume(chan);

		return;
	}
	if (_driver)
		_driver->send(b);
}

void MusicPlayerMidi::sysEx(const byte *msg, uint16 length) {
	if (_driver)
		_driver->sysEx(msg, length);
}

uint16 MusicPlayerMidi::sysExNoDelay(const byte *msg, uint16 length) {
	return _driver ? _driver->sysExNoDelay(msg, length) : 0;
}

void MusicPlayerMidi::metaEvent(byte type, byte *data, uint16 length) {
	switch (type) {
	case 0x2F:
		// End of Track, play the background song
		endTrack();
		break;
	default:
		if (_driver)
			_driver->metaEvent(type, data, length);
		break;
	}
}

void MusicPlayerMidi::pause(bool pause) {
	if (_midiParser) {
		if (pause) {
			_midiParser->pausePlaying();
		} else {
			_midiParser->resumePlaying();
		}
	}
}

void MusicPlayerMidi::updateChanVolume(byte channel) {
	// Generate a MIDI Control change message for the volume
	uint32 b = 0x7B0;

	// Specify the channel
	b |= (channel & 0xF);

	// Scale by the user and game volumes
	uint32 val = (_chanVolumes[channel] * _userVolume * _gameVolume) / 0x100 / 100;
	val &= 0x7F;

	// Send it to the driver
	if (_driver)
		_driver->send(b | (val << 16));
}

void MusicPlayerMidi::endTrack() {
	debugC(3, kDebugMIDI, "Groovie::Music: endTrack()");
	unload();
}

void MusicPlayerMidi::onTimerInternal() {
	// TODO: We really only need to call this while music is playing.
	if (_midiParser)
		_midiParser->onTimer();
}

void MusicPlayerMidi::updateVolume() {
	// Apply it to all the channels
	for (int i = 0; i < 0x10; i++) {
		updateChanVolume(i);
	}
}

void MusicPlayerMidi::unload(bool updateState) {
	MusicPlayer::unload(updateState);

	// Unload the parser data
	if (_midiParser)
		_midiParser->unloadMusic();

	// Unload the data
	delete[] _data;
	_data = nullptr;
}

bool MusicPlayerMidi::loadParser(Common::SeekableReadStream *stream, bool loop) {
	if (!_midiParser)
		return false;

	// Read the whole file to memory
	int length = stream->size();
	_data = new byte[length];
	stream->read(_data, length);
	delete stream;

	// Set the looping option
	_midiParser->property(MidiParser::mpAutoLoop, loop);

	// Start parsing the data
	if (!_midiParser->loadMusic(_data, length)) {
		error("Groovie::Music: Couldn't parse the data");
		return false;
	}

	// Activate the timer source
	if (_driver)
		_driver->setTimerCallback(this, &onTimer);

	return true;
}


// MusicPlayerXMI

MusicPlayerXMI::MusicPlayerXMI(GroovieEngine *vm, const Common::String &gtlName) :
		MusicPlayerMidi(vm), _multisourceDriver(nullptr), _milesXmidiTimbres(nullptr) {

	// Create the driver
	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
	MusicType musicType = MidiDriver::getMusicType(dev);
	if (musicType == MT_GM && ConfMan.getBool("native_mt32"))
		musicType = MT_MT32;
	_driver = nullptr;

	_musicType = 0;

	// 7th Guest uses FAT.AD/FAT.OPL/FAT.MT
	// 11th Hour uses SAMPLE.AD/SAMPLE.OPL/SAMPLE.MT
	switch (musicType) {
	case MT_ADLIB:
		_driver = _multisourceDriver = Audio::MidiDriver_Miles_AdLib_create(Common::Path(gtlName + ".AD"), Common::Path(gtlName + ".OPL"));
		break;
	case MT_MT32:
		Audio::MidiDriver_Miles_Midi *milesDriver;
		milesDriver = Audio::MidiDriver_Miles_MIDI_create(musicType, Common::Path(gtlName + ".MT"));
		_milesXmidiTimbres = milesDriver;
		_driver = _multisourceDriver = milesDriver;
		break;
	case MT_GM:
		_driver = _multisourceDriver = Audio::MidiDriver_Miles_MIDI_create(musicType, "");
		break;
	case MT_NULL:
		_driver = _multisourceDriver = new MidiDriver_NULL_Multisource();
		break;
	default:
		break;
	}
	_musicType = musicType;

	assert(_driver);

	// Create the parser
	_midiParser = MidiParser::createParser_XMIDI(nullptr, nullptr, 0);

	_multisourceDriver->property(MidiDriver::PROP_USER_VOLUME_SCALING, true);
	_multisourceDriver->property(MidiDriver::PROP_MILES_VERSION,
		_vm->getEngineVersion() == kGroovieT7G ? Audio::MILES_VERSION_2 : Audio::MILES_VERSION_3);
	if (_vm->getEngineVersion() == kGroovieT7G && musicType == MT_GM)
		// The 7th Guest GM init sets drumkit to 0x30 (Orchestra) and relies on
		// this remaining set; tracks don't set this at start. Some tracks
		// temporarily change the drumkit; if playback is stopped at the wrong
		// time this will cause the changed drumkit to remain in effect.
		// Set a default drumkit value to make sure it is set correctly at the
		// start of each track.
		_multisourceDriver->setControllerDefault(MidiDriver_Multisource::CONTROLLER_DEFAULT_DRUMKIT, 0x30);
	if (_vm->getEngineVersion() == kGroovieT11H)
		// Some The 11th Hour tracks use modulation, but not all tracks reset
		// it at start. Set a default value to make sure it is reset at the
		// start of each track.
		_multisourceDriver->setControllerDefault(MidiDriver_Multisource::CONTROLLER_DEFAULT_MODULATION, 0);

	int result = _driver->open();
	if (result > 0 && result != MidiDriver::MERR_ALREADY_OPEN)
		error("Opening MidiDriver failed with error code %i", result);

	_multisourceDriver->setSourceNeutralVolume(0, 100);

	// Set the parser's driver
	_midiParser->setMidiDriver(this);

	// Set the timer rate
	_midiParser->setTimerRate(_driver->getBaseTempo());
}

MusicPlayerXMI::~MusicPlayerXMI() {
	_midiParser->stopPlaying();
}

void MusicPlayerXMI::send(int8 source, uint32 b) {
	_multisourceDriver->send(source, b);
}

void MusicPlayerXMI::metaEvent(int8 source, byte type, byte *data, uint16 length) {
	if (type == 0x2F) // End Of Track
		MusicPlayerMidi::endTrack();
	_multisourceDriver->metaEvent(source, type, data, length);
}

void MusicPlayerXMI::stopAllNotes(bool stopSustainedNotes) {
	if (_driver)
		_driver->stopAllNotes(stopSustainedNotes);
}

bool MusicPlayerXMI::isReady(int8 source) {
	return _driver ? _driver->isReady(source) : false;
}

void MusicPlayerXMI::updateVolume() {
	_multisourceDriver->setSourceVolume(0, _gameVolume);
}

void MusicPlayerXMI::setUserVolume(uint16 volume) {
	_multisourceDriver->syncSoundSettings();
}

bool MusicPlayerXMI::load(uint32 fileref, bool loop) {
	debugC(1, kDebugMIDI, "Groovie::Music: Starting the playback of song: %04X", fileref);

	// Open the song resource
	Common::SeekableReadStream *file = _vm->_resMan->open(fileref);
	if (!file) {
		error("Groovie::Music: Couldn't find resource 0x%04X", fileref);
		return false;
	}

	return loadParser(file, loop);
}

void MusicPlayerXMI::unload(bool updateState) {
	MusicPlayerMidi::unload(updateState);
	_multisourceDriver->deinitSource(0);
}

// MusicPlayerMac_t7g

MusicPlayerMac_t7g::MusicPlayerMac_t7g(GroovieEngine *vm) : MusicPlayerMidi(vm) {
	// Create the parser
	_midiParser = MidiParser::createParser_SMF();

	// Create the driver
	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
	_driver = MidiDriver::createMidi(dev);
	assert(_driver);

	_driver->open();	// TODO: Handle return value != 0 (indicating an error)

	// Set the parser's driver
	_midiParser->setMidiDriver(this);

	// Set the timer rate
	_midiParser->setTimerRate(_driver->getBaseTempo());

	// Sanity check
	assert(_vm->_macResFork);
}

bool MusicPlayerMac_t7g::load(uint32 fileref, bool loop) {
	debugC(1, kDebugMIDI, "Groovie::Music: Starting the playback of song: %04X", fileref);

	// First try for compressed MIDI
	Common::SeekableReadStream *file = _vm->_macResFork->getResource(MKTAG('c','m','i','d'), fileref & 0x3FF);

	if (file) {
		// Found the resource, decompress it
		Common::SeekableReadStream *tmp = decompressMidi(file);
		delete file;
		file = tmp;
	} else {
		// Otherwise, it's uncompressed
		file = _vm->_macResFork->getResource(MKTAG('M','i','d','i'), fileref & 0x3FF);
		if (!file)
			error("Groovie::Music: Couldn't find resource 0x%04X", fileref);
	}

	return loadParser(file, loop);
}

Common::SeekableReadStream *MusicPlayerMac_t7g::decompressMidi(Common::SeekableReadStream *stream) {
	// Initialize an output buffer of the given size
	uint32 size = stream->readUint32BE();
	byte *output = (byte *)malloc(size);

	byte *current = output;
	uint32 decompBytes = 0;
	while ((decompBytes < size) && !stream->eos()) {
		// 8 flags
		byte flags = stream->readByte();

		for (byte i = 0; (i < 8) && !stream->eos(); i++) {
			if (flags & 1) {
				// 1: Next byte is a literal
				*(current++) = stream->readByte();
				if (stream->eos())
					continue;
				decompBytes++;
			} else {
				// 0: It's a reference to part of the history
				uint16 args = stream->readUint16BE();
				if (stream->eos())
					continue;

				// Length = 4bit unsigned (3 minimal)
				uint8 length = (args >> 12) + 3;

				// Offset = 12bit signed (all values are negative)
				int16 offset = (args & 0xFFF) | 0xF000;

				// Copy from the past decompressed bytes
				decompBytes += length;
				while (length > 0) {
					*(current) = *(current + offset);
					current++;
					length--;
				}
			}
			flags = flags >> 1;
		}
	}

	// Return the output buffer wrapped in a MemoryReadStream
	return new Common::MemoryReadStream(output, size, DisposeAfterUse::YES);
}

// MusicPlayerMac_v2

MusicPlayerMac_v2::MusicPlayerMac_v2(GroovieEngine *vm) : MusicPlayerMidi(vm) {
	// Create the parser
	_midiParser = MidiParser::createParser_QT();

	// Create the driver
	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
	_driver = MidiDriver::createMidi(dev);
	assert(_driver);

	_driver->open();	// TODO: Handle return value != 0 (indicating an error)

	// Set the parser's driver
	_midiParser->setMidiDriver(this);

	// Set the timer rate
	_midiParser->setTimerRate(_driver->getBaseTempo());
}

bool MusicPlayerMac_v2::load(uint32 fileref, bool loop) {
	debugC(1, kDebugMIDI, "Groovie::Music: Starting the playback of song: %04X", fileref);

	// Find correct filename
	ResInfo info;
	_vm->_resMan->getResInfo(fileref, info);
	uint len = info.filename.size();
	if (len < 4)
		return false;	// This shouldn't actually occur

	// Remove the extension and add ".mov"
	info.filename.deleteLastChar();
	info.filename.deleteLastChar();
	info.filename.deleteLastChar();
	info.filename += "mov";

	Common::SeekableReadStream *file = SearchMan.createReadStreamForMember(Common::Path(info.filename));

	if (!file) {
		warning("Could not find file '%s'", info.filename.c_str());
		return false;
	}

	return loadParser(file, loop);
}

MusicPlayerIOS::MusicPlayerIOS(GroovieEngine *vm) : MusicPlayer(vm) {
	vm->getTimerManager()->installTimerProc(&onTimer, 50 * 1000, this, "groovieMusic");
}

MusicPlayerIOS::~MusicPlayerIOS() {
	_vm->getTimerManager()->removeTimerProc(&onTimer);
}

void MusicPlayerIOS::updateVolume() {
	// Just set the mixer volume for the music sound type
	_vm->_system->getMixer()->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, _userVolume * _gameVolume / 100);
}

void MusicPlayerIOS::unload(bool updateState) {
	MusicPlayer::unload(updateState);

	_vm->_system->getMixer()->stopHandle(_handle);
}

bool MusicPlayerIOS::load(uint32 fileref, bool loop) {
	// Find correct filename
	ResInfo info;
	_vm->_resMan->getResInfo(fileref, info);
	uint len = info.filename.size();
	if (len < 4)
		return false;	// This shouldn't actually occur
	/*
	19462 door
	19463 ??
	19464 ??
	19465 puzzle?
	19466 cake
	19467 maze
	19468 ambient  (but not 69, amb b.  odd)
	19470 puzzle
	19471
	19473
	19475 coffins or blood pump
	19476 blood pump or coffins
	19493
	19499 chapel
	19509 downstair ambient
	19510 bedroom 'skip 3 and 5' puzzle (should loop from partway?)
	19514
	19515 bathroom drain teeth
	*/
	if ((fileref >= 19462 && fileref <= 19468) ||
		fileref == 19470 || fileref == 19471 ||
		fileref == 19473 || fileref == 19475 ||
		fileref == 19476 || fileref == 19493 ||
		fileref == 19499 || fileref == 19509 ||
		fileref == 19510 || fileref == 19514 ||
		fileref == 19515)
		loop = true; // XMIs for these refs self-loop

	// iOS port provides alternative intro sequence music
	if (info.filename == "gu39.xmi") {
		info.filename = "intro";
	} else if (info.filename == "gu32.xmi") {
		info.filename = "foyer";
	} else {
		// Remove the extension
		info.filename.deleteLastChar();
		info.filename.deleteLastChar();
		info.filename.deleteLastChar();
		info.filename.deleteLastChar();
	}

	if (info.filename == "ini_sc") {
		// This is an initialization MIDI file, which is not
		// needed for digital tracks
		return false;
	}

	// Create the audio stream
	Audio::SeekableAudioStream *seekStream = Audio::SeekableAudioStream::openStreamFile(Common::Path(info.filename));

	if (!seekStream) {
		warning("Could not play audio file '%s'", info.filename.c_str());
		return false;
	}

	Audio::AudioStream *audStream = seekStream;

	// Loop if requested
	if (loop)
		audStream = Audio::makeLoopingAudioStream(seekStream, 0);

	// MIDI player handles volume reset on load, IOS player doesn't - force update here
	updateVolume();

	// Play!
	_vm->_system->getMixer()->playStream(Audio::Mixer::kMusicSoundType, &_handle, audStream);
	return true;
}


MusicPlayerTlc::MusicPlayerTlc(GroovieEngine *vm) : MusicPlayer(vm) {
	_file = nullptr;
	vm->getTimerManager()->installTimerProc(&onTimer, 50 * 1000, this, "groovieMusic");
}

MusicPlayerTlc::~MusicPlayerTlc() {
	_vm->getTimerManager()->removeTimerProc(&onTimer);
}

void MusicPlayerTlc::updateVolume() {
	// Just set the mixer volume for the music sound type
	_vm->_system->getMixer()->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, _userVolume * _gameVolume / 100);
}

void MusicPlayerTlc::unload(bool updateState) {
	MusicPlayer::unload(updateState);

	_vm->_system->getMixer()->stopHandle(_handle);
	if (_file) {
		delete _file;
	}
	_file = nullptr;
}

Common::String MusicPlayerTlc::getFilename(uint32 fileref) {
#ifdef ENABLE_GROOVIE2
	return TlcGame::getTlcMusicFilename(fileref);
#else
	return "";
#endif
}

bool MusicPlayerTlc::load(uint32 fileref, bool loop) {
	unload();
	_file = new Common::File();

	Common::String filename = getFilename(fileref);

	// Apple platforms use m4a files instead of mpg
	if (_vm->getPlatform() == Common::kPlatformUnknown)
		filename += ".m4a";
	else
		filename += ".mpg";

	// Create the audio stream from fileref
	_file->open(Common::Path(filename));
	Audio::SeekableAudioStream *seekStream = nullptr;
	if (_file->isOpen()) {
		if (filename.hasSuffix(".m4a"))
			seekStream = Audio::makeQuickTimeStream(_file, DisposeAfterUse::NO);
#ifdef USE_MAD
		else
			seekStream = Audio::makeMP3Stream(_file, DisposeAfterUse::NO);
#endif
	} else {
		delete _file;
		_file = nullptr;
	}

	if (!seekStream) {
		warning("Could not play audio file '%s'", filename.c_str());
		return false;
	}

	Audio::AudioStream *audStream = seekStream;

	// TODO: Loop if requested
	if (!loop)
		warning("TODO: MusicPlayerTlc::load with loop == false");

	if (loop || 1)
		audStream = Audio::makeLoopingAudioStream(seekStream, 0);

	// MIDI player handles volume reset on load, IOS player doesn't - force update here
	updateVolume();

	// Play!
	_vm->_system->getMixer()->playStream(Audio::Mixer::kMusicSoundType, &_handle, audStream);
	return true;
}

// This a list of files for background music. This list is hardcoded in the Clandestiny player.
const char *kClanMusicFiles[] = {
	"mbf_arb1", "mbf_arm1", "mbf_bal1", "mbf_c2p2", "act18mus", "act15mus", "act21mus",
	"act05mus", "act04mus", "act23mus", "act17mus", "act03mus", "act06mus", "act19mus",
	"act07mus", "mbf_mne1", "act24mus", "act24mus", "act14mus", "act20mus", "act15mus",
	"act13mus", "act08mus", "mbf_uph1", "mbf_uph1", "act19mus", "mbf_bol1", "mbf_cbk1",
	"mbf_glf1", "mbf_bro1", "mbf_c1r1", "mbf_c1r1", "mbf_c1r1", "mbf_c1r1", "mbf_c2r1",
	"mbf_c2r1", "mbf_c2r1", "mbf_c2r1", "mbf_c3r1", "mbf_c3r1", "mbf_c3r1", "mbf_c4r1",
	"mbf_c4r1", "mbf_c1p2", "mbf_c3p3", "mbf_c1p3", "mbf_bro1", "mbf_c1p1", "act17mus",
	"mbf_c2p2", "mbf_c2p1", "act10mus", "mbf_c1p1", "mbf_mne1", "mbf_c3p3", "act17mus",
	"mbf_c3p2", "mbf_c3p1", "act25mus", "mbf_c4p2", "mbf_c4p1"
};

Common::String MusicPlayerClan::getFilename(uint32 fileref) {
	return kClanMusicFiles[fileref];
}

} // End of Groovie namespace