overte/libraries/audio/src/AudioInjector.h

//
//  AudioInjector.h
//  libraries/audio/src
//
//  Created by Stephen Birarda on 1/2/2014.
//  Copyright 2014 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//

#ifndef hifi_AudioInjector_h
#define hifi_AudioInjector_h

#include <memory>

#include <QtCore/QElapsedTimer>
#include <QtCore/QObject>
#include <QtCore/QSharedPointer>
#include <QtCore/QThread>

#include <shared/ReadWriteLockable.h>

#include <glm/glm.hpp>
#include <glm/gtx/quaternion.hpp>

#include <NLPacket.h>

#include "AudioInjectorLocalBuffer.h"
#include "AudioInjectorOptions.h"
#include "AudioHRTF.h"
#include "AudioFOA.h"
#include "Sound.h"

class AbstractAudioInterface;
class AudioInjectorManager;
class AudioInjector;
using AudioInjectorPointer = QSharedPointer<AudioInjector>;


enum class AudioInjectorState : uint8_t {
    NotFinished = 0,
    Finished = 1,
    PendingDelete = 2,
    LocalInjectionFinished = 4,
    NetworkInjectionFinished = 8
};

AudioInjectorState operator& (AudioInjectorState lhs, AudioInjectorState rhs);
AudioInjectorState& operator|= (AudioInjectorState& lhs, AudioInjectorState rhs);

// In order to make scripting cleaner for the AudioInjector, the script now holds on to the AudioInjector object
// until it dies.
class AudioInjector : public QObject, public QEnableSharedFromThis<AudioInjector>, public ReadWriteLockable {
    Q_OBJECT
public:
    AudioInjector(SharedSoundPointer sound, const AudioInjectorOptions& injectorOptions);
    AudioInjector(AudioDataPointer audioData, const AudioInjectorOptions& injectorOptions);
    ~AudioInjector();

    bool isFinished() const { return (stateHas(AudioInjectorState::Finished)); }

    int getCurrentSendOffset() const { return _currentSendOffset; }
    void setCurrentSendOffset(int currentSendOffset) { _currentSendOffset = currentSendOffset; }

    QSharedPointer<AudioInjectorLocalBuffer> getLocalBuffer() const { return _localBuffer; }
    AudioHRTF& getLocalHRTF() { return _localHRTF; }
    AudioFOA& getLocalFOA() { return _localFOA; }

    float getLoudness() const { return resultWithReadLock<float>([&] { return _loudness; }); }
    bool isPlaying() const { return !stateHas(AudioInjectorState::Finished); }

    bool isLocalOnly() const { return resultWithReadLock<bool>([&] { return _options.localOnly; }); }
    float getVolume() const { return resultWithReadLock<float>([&] { return _options.volume; }); }
    bool isPositionSet() const { return resultWithReadLock<bool>([&] { return _options.positionSet; }); }
    glm::vec3 getPosition() const { return resultWithReadLock<glm::vec3>([&] { return _options.position; }); }
    glm::quat getOrientation() const { return resultWithReadLock<glm::quat>([&] { return _options.orientation; }); }
    bool isStereo() const { return resultWithReadLock<bool>([&] { return _options.stereo; }); }
    bool isAmbisonic() const { return resultWithReadLock<bool>([&] { return _options.ambisonic; }); }

    AudioInjectorOptions getOptions() const { return resultWithReadLock<AudioInjectorOptions>([&] { return _options; }); }
    void setOptions(const AudioInjectorOptions& options);

    bool stateHas(AudioInjectorState state) const ;
    static void setLocalAudioInterface(AbstractAudioInterface* audioInterface) { _localAudioInterface = audioInterface; }

    void restart();
    void finish();

    void finishNetworkInjection();

public slots:
    void finishLocalInjection();

signals:
    void finished();
    void restarting();

private:
    int64_t injectNextFrame();
    bool inject(bool(AudioInjectorManager::*injection)(const AudioInjectorPointer&));
    bool injectLocally();
    void sendStopInjectorPacket();

    static AbstractAudioInterface* _localAudioInterface;

    const SharedSoundPointer _sound;
    AudioDataPointer _audioData;
    AudioInjectorOptions _options;
    AudioInjectorState _state { AudioInjectorState::NotFinished };
    bool _hasSentFirstFrame { false };
    float _loudness { 0.0f };
    int _currentSendOffset { 0 };
    std::unique_ptr<NLPacket> _currentPacket { nullptr };
    QSharedPointer<AudioInjectorLocalBuffer> _localBuffer { nullptr };

    int64_t _nextFrame { 0 };
    std::unique_ptr<QElapsedTimer> _frameTimer { nullptr };
    quint16 _outgoingSequenceNumber { 0 };

    // when the injector is local, we need this
    AudioHRTF _localHRTF;
    AudioFOA _localFOA;

    QUuid _streamID { QUuid::createUuid() };

    friend class AudioInjectorManager;
};

Q_DECLARE_METATYPE(AudioInjectorPointer)

#endif // hifi_AudioInjector_h