sound_manager.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 TITANIC_SOUND_MANAGER_H
#define TITANIC_SOUND_MANAGER_H
 
#include "titanic/core/list.h"
#include "titanic/support/simple_file.h"
#include "titanic/sound/audio_buffer.h"
#include "titanic/sound/proximity.h"
#include "titanic/sound/qmixer.h"
#include "titanic/sound/wave_file.h"
#include "titanic/true_talk/dialogue_file.h"
 
namespace Titanic {
 
enum VolumeMode {
    VOL_NORMAL = -1, VOL_QUIET = -2, VOL_VERY_QUIET = -3, VOL_MUTE = -4
};
 
class CSoundManager {
protected:
    uint _handleCtr;
    // Old volume levels, deprecated in favor of setting the volumes
    // directly in the ScummVM mixer
    double _musicPercent;
    double _speechPercent;
    double _masterPercent;
    double _parrotPercent;
public:
    CSoundManager();
    virtual ~CSoundManager() {}
 
    virtual CWaveFile *loadSound(const CString &name) { return nullptr; }
 
    virtual CWaveFile *loadSpeech(CDialogueFile *dialogueFile, int speechId) { return 0; }
 
    virtual CWaveFile *loadMusic(const CString &name) { return nullptr; }
 
    virtual CWaveFile *loadMusic(CAudioBuffer *buffer, DisposeAfterUse::Flag disposeAfterUse) { return nullptr; }
 
    virtual int playSound(CWaveFile &waveFile, CProximity &prox) = 0;
 
    virtual void stopSound(int handle) = 0;
 
    virtual void stopChannel(int channel) = 0;
 
    virtual void proc9(int handle) {}
 
    virtual void stopAllChannels() = 0;
 
    virtual void setVolume(int handle, uint volume, uint seconds) = 0;
 
    virtual void setVectorPosition(int handle, double x, double y, double z, uint panRate) {}
 
    virtual void setPolarPosition(int handle, double range, double azimuth, double elevation, uint panRate) {}
 
    virtual bool isActive(int handle) = 0;
 
    virtual bool isActive(const CWaveFile *waveFile) { return false; }
 
    virtual void waveMixPump() = 0;
 
    virtual uint getLatency() const { return 0; }
 
    virtual void setMusicPercent(double percent) = 0;
 
    virtual void setSpeechPercent(double percent) = 0;
 
    virtual void setMasterPercent(double percent) = 0;
 
    virtual void setParrotPercent(double percent) = 0;
 
    virtual void preLoad() { stopAllChannels(); }
 
    void load(SimpleFile *file) {}
 
    virtual void postLoad() {}
 
    virtual void preSave() {}
 
    void save(SimpleFile *file) const {}
 
    virtual void postSave() {}
 
    virtual void setListenerPosition(double posX, double posY, double posZ,
        double directionX, double directionY, double directionZ, bool stopSounds) {}
 
    double getMusicVolume() const { return _musicPercent; }
 
    double getSpeechVolume() const { return _speechPercent; }
 
    double getParrotVolume() const { return _parrotPercent; }
 
    uint getModeVolume(VolumeMode mode);
};
 
class QSoundManagerSound : public ListItem {
public:
    CWaveFile *_waveFile;
    int _iChannel;
    CEndTalkerFn _endFn;
    TTtalker *_talker;
public:
    QSoundManagerSound() : ListItem(), _waveFile(nullptr),
        _iChannel(0), _endFn(nullptr), _talker(nullptr) {}
    QSoundManagerSound(CWaveFile *waveFile, int iChannel, CEndTalkerFn endFn, TTtalker *talker) :
        ListItem(), _waveFile(waveFile), _iChannel(iChannel), _endFn(endFn), _talker(talker) {}
};
 
class QSoundManagerSounds : public List<QSoundManagerSound> {
public:
    void add(CWaveFile *waveFile, int iChannel, CEndTalkerFn endFn, TTtalker *talker);
 
    void flushChannel(int iChannel);
 
    void flushChannel(CWaveFile *waveFile, int iChannel);
 
    bool contains(const CWaveFile *waveFile) const;
};
 
class QSoundManager : public CSoundManager, public QMixer {
    struct Slot {
        CWaveFile *_waveFile;
        bool _isTimed;
        uint _ticks;
        int _channel;
        int _handle;
        PositioningMode _positioningMode;
 
        Slot() : _waveFile(0), _isTimed(0), _ticks(0), _channel(-1),
            _handle(0), _positioningMode(POSMODE_NONE) {}
        void clear();
    };
private:
    QSoundManagerSounds _sounds;
    Common::Array<Slot> _slots;
    uint _channelsVolume[16];
    int _channelsMode[16];
private:
    void updateVolume(int channel, uint panRate);
 
    void updateVolumes();
 
    static void soundFinished(int iChannel, CWaveFile *waveFile, void *soundManager);
 
    int findFreeSlot();
 
    void setChannelVolume(int iChannel, uint volume, uint mode);
 
    int resetChannel(int iChannel);
public:
    int _field18;
    int _field1C;
 
public:
    QSoundManager(Audio::Mixer *mixer);
    ~QSoundManager() override;
 
    CWaveFile *loadSound(const CString &name) override;
 
    CWaveFile *loadSpeech(CDialogueFile *dialogueFile, int speechId) override;
 
    CWaveFile *loadMusic(const CString &name) override;
 
    CWaveFile *loadMusic(CAudioBuffer *buffer, DisposeAfterUse::Flag disposeAfterUse) override;
 
    int playSound(CWaveFile &waveFile, CProximity &prox) override;
 
    void stopSound(int handle) override;
 
    void stopChannel(int channel) override;
 
    virtual void setCanFree(int handle);
 
    void stopAllChannels() override;
 
    void setVolume(int handle, uint volume, uint seconds) override;
 
    void setVectorPosition(int handle, double x, double y, double z, uint panRate) override;
 
    void setPolarPosition(int handle, double range, double azimuth, double elevation, uint panRate) override;
 
    bool isActive(int handle) override;
 
    bool isActive(const CWaveFile *waveFile) override;
 
    void waveMixPump() override;
 
    uint getLatency() const override;
 
    void setMusicPercent(double percent) override;
 
    void setSpeechPercent(double percent) override;
 
    void setMasterPercent(double percent) override;
 
    void setParrotPercent(double percent) override;
 
    void setListenerPosition(double posX, double posY, double posZ,
        double directionX, double directionY, double directionZ, bool stopSounds) override;
 
    virtual int playWave(CWaveFile *waveFile, int iChannel, uint flags, CProximity &prox);
 
    void soundFreed(Audio::SoundHandle &handle);
};
 
} // End of namespace Titanic
 
#endif /* TITANIC_QSOUND_MANAGER_H */