audio32.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 SCI_SOUND_AUDIO32_H
#define SCI_SOUND_AUDIO32_H

#include "audio/audiostream.h"     // for AudioStream, SeekableAudioStream (...
#include "audio/mixer.h"           // for Mixer, SoundHandle
#include "audio/rate.h"            // for Audio::st_volume_t, RateConverter
#include "common/array.h"          // for Array
#include "common/mutex.h"          // for StackLock, Mutex
#include "common/scummsys.h"       // for int16, uint8, uint32, uint16
#include "sci/resource/resource.h" // for ResourceId
#include "sci/engine/state.h"      // for EngineState
#include "sci/engine/vm_types.h"   // for reg_t, NULL_REG
#include "sci/video/robot_decoder.h" // for RobotAudioStream

namespace Sci {
class Console;

bool detectSolAudio(Common::SeekableReadStream &stream);
bool detectWaveAudio(Common::SeekableReadStream &stream);

#pragma mark AudioChannel

struct AudioChannel {
    ResourceId id;

    Resource *resource;

    Common::ScopedPtr<Audio::AudioStream> stream;

    Common::ScopedPtr<Audio::RateConverter> converter;

    uint32 duration;

    uint32 startedAtTick;

    uint32 pausedAtTick;

    uint32 fadeStartTick;

    int fadeStartVolume;

    uint32 fadeDuration;

    int fadeTargetVolume;

    bool stopChannelOnFade;

    bool robot;

    reg_t soundNode;

    int volume;

    int pan;

    AudioChannel &operator=(AudioChannel &other) {
        id = other.id;
        resource = other.resource;
        stream.reset(other.stream.release());
        converter.reset(other.converter.release());
        duration = other.duration;
        startedAtTick = other.startedAtTick;
        pausedAtTick = other.pausedAtTick;
        fadeStartTick = other.fadeStartTick;
        fadeStartVolume = other.fadeStartVolume;
        fadeDuration = other.fadeDuration;
        fadeTargetVolume = other.fadeTargetVolume;
        stopChannelOnFade = other.stopChannelOnFade;
        robot = other.robot;
        soundNode = other.soundNode;
        volume = other.volume;
        pan = other.pan;
        return *this;
    }
};

#pragma mark -

enum AudioChannelIndex {
    kRobotChannel = -3,
    kNoExistingChannel = -2,
    kAllChannels = -1
};

class Audio32 : public Audio::AudioStream, public Common::Serializable {
public:
    Audio32(ResourceManager *resMan);
    ~Audio32() override;

    void saveLoadWithSerializer(Common::Serializer &s) override;

    enum {
        kMaxVolume = 127,

        kMonitorAudioFlagSci3 = 0x80
    };

private:
    ResourceManager *_resMan;
    Audio::Mixer *_mixer;
    Audio::SoundHandle _handle;
    Common::Mutex _mutex;

#pragma mark -
#pragma mark AudioStream implementation
public:
    int readBuffer(Audio::st_sample_t *buffer, const int numSamples) override;
    bool isStereo() const override { return true; }
    int getRate() const override { return _mixer->getOutputRate(); }
    bool endOfData() const override { return _numActiveChannels == 0; }
    bool endOfStream() const override { return false; }

private:
    int16 getNumChannelsToMix() const;

    bool channelShouldMix(const AudioChannel &channel) const;

    int writeAudioInternal(Audio::AudioStream &sourceStream, Audio::RateConverter &converter, Audio::st_sample_t *targetBuffer, const int numSamples, const Audio::st_volume_t leftVolume, const Audio::st_volume_t rightVolume);

#pragma mark -
#pragma mark Channel management
public:
    inline uint8 getNumActiveChannels() const {
        Common::StackLock lock(_mutex);
        return _numActiveChannels;
    }

    uint8 getNumUnlockedChannels() const;

    int16 findChannelByArgs(EngineState *s, int argc, const reg_t *argv, const int startIndex, const reg_t soundNode) const;

    int16 findChannelById(const ResourceId resourceId, const reg_t soundNode = NULL_REG) const;

    void lockResource(const ResourceId resourceId, const bool lock);

private:
    typedef Common::Array<ResourceId> LockList;
    typedef Common::Array<Resource *> UnlockList;

    Common::Array<AudioChannel> _channels;

    uint8 _numActiveChannels;

    bool _inAudioThread;

    UnlockList _resourcesToUnlock;

    LockList _lockedResourceIds;

    inline AudioChannel &getChannel(const int16 channelIndex) {
        Common::StackLock lock(_mutex);
        assert(channelIndex >= 0 && channelIndex < _numActiveChannels);
        return _channels[channelIndex];
    }

    inline const AudioChannel &getChannel(const int16 channelIndex) const {
        Common::StackLock lock(_mutex);
        assert(channelIndex >= 0 && channelIndex < _numActiveChannels);
        return _channels[channelIndex];
    }

    void freeUnusedChannels();

    void freeChannel(const int16 channelIndex);

    void unlockResources();

#pragma mark -
#pragma mark Script compatibility
public:
    inline uint16 getSampleRate() const {
        return _globalSampleRate;
    }

    void setSampleRate(uint16 rate);

    inline uint8 getBitDepth() const {
        return _globalBitDepth;
    }

    void setBitDepth(uint8 depth);

    inline uint8 getNumOutputChannels() const {
        return _globalNumOutputChannels;
    }

    void setNumOutputChannels(int16 numChannels);

    inline uint8 getPreload() const {
        return _preload;
    }

    inline void setPreload(uint8 preload) {
        _preload = preload;
    }

private:
    uint16 _globalSampleRate;

    uint16 _maxAllowedSampleRate;

    uint8 _globalBitDepth;

    uint8 _maxAllowedBitDepth;

    uint8 _globalNumOutputChannels;

    uint8 _maxAllowedOutputChannels;

    uint8 _preload;

#pragma mark -
#pragma mark Robot
public:
    bool playRobotAudio(const RobotAudioStream::RobotAudioPacket &packet);
    bool queryRobotAudio(RobotAudioStream::StreamState &outStatus) const;
    bool finishRobotAudio();
    bool stopRobotAudio();

private:
    int16 findRobotChannel() const;

    bool _robotAudioPaused;

#pragma mark -
#pragma mark Playback
public:
    uint16 play(int16 channelIndex, const ResourceId resourceId, const bool autoPlay, const bool loop, const int16 volume, const reg_t soundNode, const bool monitor);

    bool resume(const int16 channelIndex);
    bool resume(const ResourceId resourceId, const reg_t soundNode = NULL_REG) {
        Common::StackLock lock(_mutex);
        return resume(findChannelById(resourceId, soundNode));
    }

    bool pause(const int16 channelIndex);
    bool pause(const ResourceId resourceId, const reg_t soundNode = NULL_REG) {
        Common::StackLock lock(_mutex);
        return pause(findChannelById(resourceId, soundNode));
    }

    int16 stop(const int16 channelIndex);
    int16 stop(const ResourceId resourceId, const reg_t soundNode = NULL_REG) {
        Common::StackLock lock(_mutex);
        return stop(findChannelById(resourceId, soundNode));
    }

    uint16 restart(const ResourceId resourceId, const bool autoPlay, const bool loop, const int16 volume, const reg_t soundNode, const bool monitor);

    int16 getPosition(const int16 channelIndex) const;
    int16 getPosition(const ResourceId resourceId, const reg_t soundNode = NULL_REG) {
        Common::StackLock lock(_mutex);
        return getPosition(findChannelById(resourceId, soundNode));
    }

    void setLoop(const int16 channelIndex, const bool loop);
    void setLoop(const ResourceId resourceId, const reg_t soundNode, const bool loop) {
        Common::StackLock lock(_mutex);
        setLoop(findChannelById(resourceId, soundNode), loop);
    }

    void setPan(const int16 channelIndex, const int16 pan) {
        Common::StackLock lock(_mutex);
        getChannel(channelIndex).pan = pan;
    }

private:
    uint32 _pausedAtTick;

    uint32 _startedAtTick;

#pragma mark -
#pragma mark Effects
public:
    int16 getVolume(const int16 channelIndex) const;
    int16 getVolume(const ResourceId resourceId, const reg_t soundNode) const {
        Common::StackLock lock(_mutex);
        return getVolume(findChannelById(resourceId, soundNode));
    }

    void setVolume(const int16 channelIndex, int16 volume);
    void setVolume(const ResourceId resourceId, const reg_t soundNode, const int16 volume) {
        Common::StackLock lock(_mutex);
        setVolume(findChannelById(resourceId, soundNode), volume);
    }

    void setMasterVolume(const int16 volume) {
        _mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, volume * Audio::Mixer::kMaxChannelVolume / kMaxVolume);
    }

    bool fadeChannel(const int16 channelIndex, const int16 targetVolume, const int16 speed, const int16 steps, const bool stopAfterFade);
    bool fadeChannel(const ResourceId resourceId, const reg_t soundNode, const int16 targetVolume, const int16 speed, const int16 steps, const bool stopAfterFade) {
        Common::StackLock lock(_mutex);
        return fadeChannel(findChannelById(resourceId, soundNode), targetVolume, speed, steps, stopAfterFade);
    }

    inline bool getAttenuatedMixing() const {
        return _attenuatedMixing;
    }

    void setAttenuatedMixing(bool attenuated) {
        Common::StackLock lock(_mutex);
        _attenuatedMixing = attenuated;
    }

private:
    bool _attenuatedMixing;

    bool _useModifiedAttenuation;

    bool processFade(const int16 channelIndex);

#pragma mark -
#pragma mark Signal monitoring
public:
    bool hasSignal() const;

private:
    int16 _monitoredChannelIndex;

    Common::Array<Audio::st_sample_t> _monitoredBuffer;

    int _numMonitoredSamples;

#pragma mark -
#pragma mark Kernel
public:
    reg_t kernelPlay(const bool autoPlay, EngineState *s, const int argc, const reg_t *const argv);
    reg_t kernelStop(EngineState *s, const int argc, const reg_t *const argv);
    reg_t kernelPause(EngineState *s, const int argc, const reg_t *const argv);
    reg_t kernelResume(EngineState *s, const int argc, const reg_t *const argv);
    reg_t kernelPosition(EngineState *s, const int argc, const reg_t *const argv);
    reg_t kernelVolume(EngineState *s, const int argc, const reg_t *const argv);
    reg_t kernelMixing(const int argc, const reg_t *const argv);
    reg_t kernelFade(EngineState *s, const int argc, const reg_t *const argv);
    void kernelLoop(EngineState *s, const int argc, const reg_t *const argv);
    void kernelPan(EngineState *s, const int argc, const reg_t *const argv);
    void kernelPanOff(EngineState *s, const int argc, const reg_t *const argv);

#pragma mark -
#pragma mark Debugging
public:
    void printAudioList(Console *con) const;
};

} // End of namespace Sci

#endif // SCI_SOUND_AUDIO32_H