scummvm/engines/sword1/sound.h

/* 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/>.
 *
 */

#ifndef SWORD1_SOUND_H
#define SWORD1_SOUND_H

#include "sword1/object.h"
#include "sword1/sworddefs.h"

#include "common/file.h"
#include "common/mutex.h"
#include "common/random.h"
#include "common/timer.h"
#include "common/util.h"

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

namespace Audio {
class Mixer;
}

namespace Sword1 {

#define TOTAL_FX_PER_ROOM   7       // total loop & random fx per room (see fx_list.c)
#define MAX_ROOMS_PER_FX    7       // max no. of rooms in the fx's room,vol list
#define MAX_FXQ_LENGTH      32      // max length of sound queue - ie. max number of fx that can be stored up/playing together

#define FX_SPOT   1
#define FX_LOOP   2
#define FX_RANDOM 3

struct QueueElement {
	uint32 id, delay;
	Audio::SoundHandle handle;

	void reset() {
		id = 0, delay = 0;
		handle = Audio::SoundHandle();
	}
};

struct RoomVol {
	int32 roomNo, leftVol, rightVol;
};

struct SampleId {
	byte cluster;
	byte idStd;
	byte idWinDemo;
};

struct FxDef {
	SampleId sampleId;
	uint32 type, delay;
	RoomVol roomVolList[MAX_ROOMS_PER_FX];
};

class ResMan;
class SwordEngine;

#define MUSIC_UNDERSCORE     50
#define NEG_MOUTH_THRESHOLD -750
#define POS_MOUTH_THRESHOLD  750
#define MAX_FX               4
#define MAX_MUSIC            2
#define S_STATUS_FINISHED    1
#define S_STATUS_RUNNING     0
#define MUSIC_BUFFER_SIZE    0x2000
#define TOTAL_TUNES          270
#define DEFAULT_SAMPLE_RATE  11025

enum CowMode {
	CowWave = 0,
	CowFLAC,
	CowVorbis,
	CowMP3,
	CowDemo,
	CowPSX
};

enum MusCompMode {
	MusWav = 0,
	MusAif,
	MusFLAC,
	MusVorbis,
	MusMP3,
	MusPSX
};

class Sound {
	friend class SwordConsole;
	friend class Control;
public:
	Sound(Audio::Mixer *mixer, SwordEngine *vm, ResMan *pResMan);
	~Sound();

	void newScreen(uint32 screen);
	void closeCowSystem();

	void engine();

	void checkSpeechFileEndianness();
	double endiannessHeuristicValue(int16* data, uint32 dataSize, uint32 &maxSamples);

	void installFadeTimer();
	void uninstallFadeTimer();

	void playSample(int32 fxNo);
	void stopSample(int32 fxNo);
	void setFXVolume(byte targetVolume, int handleIdx);
	void clearAllFx();
	int addToQueue(uint32 fxNo);
	void removeFromQueue(uint32 fxNo);

	void startSpeech(uint16 roomNo, uint16 localNo);
	bool amISpeaking();
	int32 checkSpeechStatus();
	void playSpeech();
	void stopSpeech();

	void streamMusicFile(int32 tuneId, int32 looped);
	void updateMusicStreaming();
	void setCrossFadeIncrement();

	void fadeMusicDown(int32 rate);
	void fadeFxDown(int32 rate);
	void fadeFxUp(int32 rate);

	void pauseSpeech();
	void unpauseSpeech();
	void pauseMusic();
	void unpauseMusic();
	void pauseFx();
	void unpauseFx();

	void getVolumes();
	void setVolumes();
	byte clampVolume(int32 volume);

	Common::Mutex _soundMutex;
	Audio::Mixer *_mixer;

	// Handles for external volume changes (control panel)
	uint32 _volFX[2]     = { 0, 0 };
	uint32 _volSpeech[2] = { 0, 0 };
	uint32 _volMusic[2]  = { 0, 0 };

	// Volume fading variables
	int32 _fxCount = 0;
	int32 _fxFadingFlag = 0;
	int32 _fxFadingRate = 0;
	int32 _fxFadeVolume[2]    = { 0, 0 };
	int32 _musicFadeVolume[2] = { 0, 0 };

	// Sound FX information
	bool _fxSampleBusy[MAX_FX] = { false, false, false, false };

	// Speech data
	byte *_speechSample = nullptr;

private:
	struct WaveHeader {
		uint32 riffTag;
		uint32 riffSize;
		uint32 waveTag;
		uint32 fmtTag;
		uint32 fmtSize;

		// Format subchunk
		uint16 wFormatTag;
		uint16 wChannels;
		uint32 dwSamplesPerSec;
		uint32 dwAvgBytesPerSec;
		uint16 wBlockAlign;
		uint16 wBitsPerSample;
		uint32 dwDataTag;
		uint32 dwDataSize;
	};

	void initCowSystem();

	uint32 getSampleId(int32 fxNo);
	void playFX(int32 fxID, int32 type, uint8 *wavData, uint32 vol[2]);
	void stopFX(int32 fxID);
	int32 checkSampleStatus(int32 id);

	bool expandSpeech(byte *src, byte *dst, uint32 dstSize,
		bool *endiannessCheck = nullptr, uint32 *sizeForEndiannessCheck = nullptr);
	int32 getSpeechSize(byte *compData, uint32 compSize);

	bool prepareMusicStreaming(const Common::Path &filename, int newHandleId, int32 tuneId,
							   uint32 volume, int8 pan, MusCompMode assignedMode);
	void serveSample(Common::File *file, int32 i);
	void reduceMusicVolume();
	void restoreMusicVolume();

	int8 scalePan(int pan); // From 0,127 to -127,127

	Common::File _cowFile;
	uint32       *_cowHeader;
	uint32       _cowHeaderSize;
	uint8        _currentCowFile;
	CowMode      _cowMode;
	Common::RandomSource _rnd;

	QueueElement _fxQueue[MAX_FXQ_LENGTH];
	uint8        _endOfQueue;
	SwordEngine *_vm;
	ResMan *_resMan;

	bool _bigEndianSpeech;
	static const char _musicList[270];
	static const uint16 _roomsFixedFx[TOTAL_ROOMS][TOTAL_FX_PER_ROOM];
	static const FxDef _fxList[312];
	static const char _tuneList[TOTAL_TUNES][8]; // In staticres.cpp

	// Volume fading variables
	bool _crossFadeIncrement = false;

	// Speech variables
	int32 _speechLipsyncCounter = 0;
	int32 _speechSize = 0;
	bool _speechSampleBusy = false;

	// Sound handles
	Audio::SoundHandle _hSampleFX[MAX_FX];
	Audio::SoundHandle _hSampleSpeech;
	Audio::SoundHandle _hSampleMusic[MAX_MUSIC];

	// Music stream information
	bool _musicStreamPlaying[MAX_MUSIC] = { false, false };
	bool _streamLoopingFlag[MAX_MUSIC]  = { false, false };
	int32 _musicStreamFading[MAX_MUSIC] = { 0, 0 };
	MusCompMode _musicStreamFormat[MAX_MUSIC] = { MusWav, MusWav };
	Audio::QueuingAudioStream *_musicOutputStream[MAX_MUSIC] = { nullptr, nullptr };
	Audio::RewindableAudioStream *_compressedMusicStream[MAX_MUSIC] = { nullptr, nullptr };
	Common::File _musicFile[MAX_MUSIC];

	// Sound FX information
	int32 _fxSampleId[MAX_FX] = { 0, 0, 0, 0 };

	// Pause variables
	bool _speechPaused = false;
	bool _fxPaused[MAX_FX] = { false, false, false, false };
	bool _musicPaused[MAX_MUSIC] = { false, false };
};

} // End of namespace Sword1

#endif // SOUND_H