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