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