Implement support for VBR, FEC, and codec feature info

Codec feature info doesn't actually work yet, type needs registering
overte-org · Aug 3, 2023 · d2d1f03 · d2d1f03
1 parent a3c17c2
commit d2d1f03
Show file tree

Hide file tree

Showing 5 changed files with 229 additions and 0 deletions.
diff --git a/libraries/audio-client/src/AudioClient.cpp b/libraries/audio-client/src/AudioClient.cpp
@@ -488,6 +488,95 @@ void AudioClient::setAllowedCodecs(const QStringList &userCodecs) {
     negotiateAudioFormat();
 }
 
+QMap<QString,bool> AudioClient::getEncoderFeatures() {
+    QMap<QString,bool> features;
+
+    if (_encoder) {
+        features.insert("isLossless", _encoder->isLossless());
+        features.insert("hasApplication", _encoder->hasApplication());
+        features.insert("hasComplexity", _encoder->hasComplexity());
+        features.insert("hasBitrate", _encoder->hasBitrate());
+        features.insert("hasFEC", _encoder->hasFEC());
+        features.insert("hasPacketLossPercent", _encoder->hasPacketLossPercent());
+        features.insert("hasBandpass", _encoder->hasBandpass());
+        features.insert("hasSignalType", _encoder->hasSignalType());
+        features.insert("hasVBR", _encoder->hasVBR());
+    }
+
+    return features;
+}
+
+bool AudioClient::getEncoderVBR() {
+    if (_encoder) {
+        return _encoder->getVBR();
+    }
+
+    return false;
+}
+
+void AudioClient::setEncoderVBR(bool enabled) {
+    if (_encoder) {
+        _encoder->setVBR(enabled);
+    }
+}
+
+int AudioClient::getEncoderBitrate() {
+    if (_encoder) {
+        return _encoder->getBitrate();
+    }
+
+    return 0;
+}
+
+void AudioClient::setEncoderBitrate(int bitrate) {
+    if (_encoder) {
+        _encoder->setBitrate(bitrate);
+    }
+}
+
+int AudioClient::getEncoderComplexity() {
+    if (_encoder) {
+        return _encoder->getComplexity();
+    }
+
+    return 0;
+}
+
+void AudioClient::setEncoderComplexity(int complexity) {
+    if (_encoder) {
+        _encoder->setComplexity(complexity);
+    }
+}
+
+bool AudioClient::getEncoderFEC() {
+    if (_encoder) {
+        return _encoder->getFEC();
+    }
+
+    return false;
+}
+
+void AudioClient::setEncoderFEC(bool enabled) {
+    if (_encoder) {
+        _encoder->setFEC(enabled);
+    }
+}
+
+int AudioClient::getEncoderPacketLossPercent() {
+    if (_encoder) {
+        return _encoder->getPacketLossPercent();
+    }
+
+    return 0;
+}
+
+void AudioClient::setEncoderPacketLossPercent(int percent) {
+    if (_encoder) {
+        _encoder->setPacketLossPercent(percent);
+    }
+}
+
+
 HifiAudioDeviceInfo getNamedAudioDeviceForMode(QAudio::Mode mode, const QString& deviceName, const QString& hmdName, bool isHmd=false) {
     HifiAudioDeviceInfo result;
     foreach (HifiAudioDeviceInfo audioDevice, getAvailableDevices(mode,hmdName)) {

diff --git a/libraries/audio-client/src/AudioClient.h b/libraries/audio-client/src/AudioClient.h
@@ -194,6 +194,23 @@ class AudioClient : public AbstractAudioInterface, public Dependency {
     void setAllowedCodecs(const QStringList &codecs) override;
     void setCodecSettings(const std::vector<Encoder::CodecSettings> &settings ) { _codecSettings = settings; }
 
+    QMap<QString,bool> getEncoderFeatures() override;
+
+    bool getEncoderVBR() override;
+    void setEncoderVBR(bool enabled) override;
+
+    int getEncoderBitrate() override;
+    void setEncoderBitrate(int bitrate) override;
+
+    int getEncoderComplexity() override;
+    void setEncoderComplexity(int complexity) override;
+
+    bool getEncoderFEC() override;
+    void setEncoderFEC(bool enabled) override;
+
+    int getEncoderPacketLossPercent() override;
+    void setEncoderPacketLossPercent(int percent) override;
+
 #ifdef Q_OS_WIN
     static QString getWinDeviceName(wchar_t* guid);
 #endif

diff --git a/libraries/audio/src/AbstractAudioInterface.h b/libraries/audio/src/AbstractAudioInterface.h
@@ -60,6 +60,26 @@ public slots:
     virtual void setAllowedCodecs(const QStringList &codec) = 0;
     virtual QStringList getAllowedCodecs() = 0;
 
+    virtual QMap<QString,bool> getEncoderFeatures() = 0;
+
+    virtual bool getEncoderVBR() = 0;
+    virtual void setEncoderVBR(bool enabled) = 0;
+
+    virtual int getEncoderBitrate() = 0;
+    virtual void setEncoderBitrate(int bitrate) = 0;
+
+    virtual int getEncoderComplexity() = 0;
+    virtual void setEncoderComplexity(int complexity) = 0;
+
+    virtual bool getEncoderFEC() = 0;
+    virtual void setEncoderFEC(bool enabled) = 0;
+
+    virtual int getEncoderPacketLossPercent() = 0;
+    virtual void setEncoderPacketLossPercent(int percent) = 0;
+
+
+
+
 signals:
     void isStereoInputChanged(bool isStereo);
 };

diff --git a/libraries/audio/src/AudioScriptingInterface.cpp b/libraries/audio/src/AudioScriptingInterface.cpp
@@ -167,4 +167,84 @@ QStringList AudioScriptingInterface::getAllowedCodecs() {
     }
 
     return codecs;
+}
+
+QMap<QString,bool> AudioScriptingInterface::getEncoderFeatures() {
+    QMap<QString, bool> features;
+
+    if (_localAudioInterface) {
+        features = _localAudioInterface->getEncoderFeatures();
+    }
+
+    return features;
+}
+
+int AudioScriptingInterface::getEncoderBitrate() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderBitrate();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderBitrate(int bitrate) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderBitrate(bitrate);
+    }
+}
+
+int AudioScriptingInterface::getEncoderComplexity() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderComplexity();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderComplexity(int complexity) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderComplexity(complexity);
+    }
+}
+
+bool AudioScriptingInterface::getEncoderVBR() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderVBR();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderVBR(bool enabled) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderVBR(enabled);
+    }
+}
+
+bool AudioScriptingInterface::getEncoderFEC() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderFEC();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderFEC(bool enabled) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderFEC(enabled);
+    }
+}
+
+int AudioScriptingInterface::getEncoderPacketLossPercent() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderPacketLossPercent();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderPacketLossPercent(int percent) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderPacketLossPercent(percent);
+    }
 }
diff --git a/libraries/audio/src/AudioScriptingInterface.h b/libraries/audio/src/AudioScriptingInterface.h
@@ -165,6 +165,29 @@ class AudioScriptingInterface : public QObject, public Dependency {
 
     Q_INVOKABLE QStringList getAllowedCodecs();
 
+    Q_INVOKABLE QMap<QString,bool> getEncoderFeatures();
+
+    Q_INVOKABLE int getEncoderBitrate();
+
+    Q_INVOKABLE void setEncoderBitrate(int bitrate);
+
+    Q_INVOKABLE bool getEncoderVBR();
+
+    Q_INVOKABLE void setEncoderVBR(bool enabled);
+
+    Q_INVOKABLE int getEncoderComplexity();
+
+    Q_INVOKABLE void setEncoderComplexity(int complexity);
+
+    Q_INVOKABLE bool getEncoderFEC();
+
+    Q_INVOKABLE void setEncoderFEC(bool enabled);
+
+    Q_INVOKABLE int getEncoderPacketLossPercent();
+
+    Q_INVOKABLE void setEncoderPacketLossPercent(int percent);
+
+
 
 protected:
     AudioScriptingInterface() = default;