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(int16 *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, int16 *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<int16> _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