refs #320 Audio device handlers

samples/voiceclient/client.cpp

@@ -20,6 +20,8 @@ Client::Client(QObject *parent) :
     m_voice(new BlackCore::CVoiceVatlib())
 {
     m_channelCom1 = m_voice->getVoiceChannel(0);
+    m_inputDevice = m_voice->createInputDevice();
+    m_outputDevice = m_voice->createOutputDevice();
 
     using namespace BlackCore;
     connect(m_channelCom1.data(), &IVoiceChannel::connectionStatusChanged,              this, &Client::connectionStatusChanged);
@@ -42,6 +44,11 @@ Client::Client(QObject *parent) :
     m_commands["disableloopback"]   = std::bind(&Client::disableLoopbackCmd, this, _1);
 }
 
+Client::~Client()
+{
+    if(m_voice) m_voice->deleteLater();
+}
+
 void Client::command(QString line)
 {
     QTextStream stream(&line, QIODevice::ReadOnly);
@@ -120,7 +127,7 @@ void Client::terminateConnectionCmd(QTextStream & /** args **/)
 
 void Client::inputDevicesCmd(QTextStream & /** args **/)
 {
-    for(auto &device : m_voice->audioDevices().getInputDevices())
+    for(const auto &device : m_inputDevice->getInputDevices())
     {
         std::cout << device.getName().toStdString() << std::endl;
     }
@@ -132,7 +139,7 @@ void Client::inputDevicesCmd(QTextStream & /** args **/)
  */
 void Client::outputDevicesCmd(QTextStream & /** args **/)
 {
-    for(auto &device : m_voice->audioDevices().getOutputDevices())
+    for(const auto &device : m_outputDevice->getOutputDevices())
     {
         std::cout << device.getName().toStdString() << std::endl;
     }

samples/voiceclient/client.h

@@ -21,7 +21,7 @@ class Client : public QObject
 
 public:
     Client(QObject *parent = nullptr);
-    ~Client() { if(m_voice) m_voice->deleteLater(); }
+    ~Client();
 
 signals:
     void quit();
@@ -56,6 +56,8 @@ private slots:
 private:
     QMap<QString, std::function<void(QTextStream &)>> m_commands;
     BlackCore::IVoice *m_voice;
+    std::unique_ptr<BlackCore::IAudioInputDevice> m_inputDevice;
+    std::unique_ptr<BlackCore::IAudioOutputDevice> m_outputDevice;
     QPointer<BlackCore::IVoiceChannel> m_channelCom1;
 
 };

src/blackcore/audio_device.h

@@ -0,0 +1,83 @@
+/* Copyright (C) 2014
+ * swift project community / contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKCORE_AUDIODEVICE_H
+#define BLACKCORE_AUDIODEVICE_H
+
+#include "blackmisc/audiodeviceinfo.h"
+#include "blackmisc/audiodeviceinfolist.h"
+#include <QObject>
+
+//! \file
+
+namespace BlackCore
+{
+    //! Audio Input Device
+    //! \todo Settings classes to store hardware settings (hardware device)
+    class IAudioInputDevice : public QObject
+    {
+        Q_OBJECT
+
+    public:
+
+        //! Constructor
+        IAudioInputDevice(QObject *parent = nullptr) : QObject(parent) {}
+
+        //! Destructor
+        virtual ~IAudioInputDevice() {}
+
+        //! Get available input devices
+        virtual const BlackMisc::Audio::CAudioDeviceInfoList &getInputDevices() const = 0;
+
+        //! Default input device
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getDefaultInputDevice() const = 0;
+
+        //! Current input device
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getCurrentInputDevice() const = 0;
+
+        //! Set new input device
+        virtual void setInputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) = 0;
+    };
+
+    //! Audio Output Device
+    class IAudioOutputDevice : public QObject
+    {
+        Q_OBJECT
+
+    public:
+
+        //! Constructor
+        IAudioOutputDevice(QObject *parent = nullptr) : QObject(parent) {}
+
+        //! Destructor
+        virtual ~IAudioOutputDevice() {}
+
+        //! Get available output devices
+        virtual const BlackMisc::Audio::CAudioDeviceInfoList &getOutputDevices() const = 0;
+
+        //! Default output device
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getDefaultOutputDevice() const = 0;
+
+        //! Current output device
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getCurrentOutputDevice() const = 0;
+
+        //! Set new output device
+        virtual void setOutputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) = 0;
+
+        //! Set output volume between 0 ... 300 %
+        virtual void setOutputVolume(int volume) = 0;
+
+        //! Get output volume
+        virtual int getOutputVolume() const = 0;
+    };
+}
+
+#endif // guard

src/blackcore/audio_device_vatlib.cpp

@@ -0,0 +1,131 @@
+/* Copyright (C) 2014
+ * swift project community / contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+#include "audio_device_vatlib.h"
+#include "blackmisc/logmessage.h"
+
+using namespace BlackMisc;
+using namespace BlackMisc::Audio;
+using namespace BlackMisc::Aviation;
+
+namespace BlackCore
+{
+    CAudioInputDeviceVatlib *cbvar_cast_inputDevice(void *cbvar)
+    {
+        return static_cast<CAudioInputDeviceVatlib *>(cbvar);
+    }
+
+    CAudioOutputDeviceVatlib *cbvar_cast_outputDevice(void *cbvar)
+    {
+        return static_cast<CAudioOutputDeviceVatlib *>(cbvar);
+    }
+
+    CAudioInputDeviceVatlib::CAudioInputDeviceVatlib(VatAudioService audioService, QObject *parent)
+        : IAudioInputDevice(parent),
+          m_audioService(audioService)
+    {
+        m_inputCodec.reset(Vat_CreateLocalInputCodec(audioService));
+        Vat_GetInputDeviceInfo(m_inputCodec.data(), onInputHardwareDeviceReceived, this, nullptr);
+        m_currentDevice = getDefaultInputDevice();
+    }
+
+    const BlackMisc::Audio::CAudioDeviceInfoList &CAudioInputDeviceVatlib::getInputDevices() const
+    {
+        return m_devices;
+    }
+
+    const BlackMisc::Audio::CAudioDeviceInfo &CAudioInputDeviceVatlib::getDefaultInputDevice() const
+    {
+        static BlackMisc::Audio::CAudioDeviceInfo info(BlackMisc::Audio::CAudioDeviceInfo::InputDevice, BlackMisc::Audio::CAudioDeviceInfo::defaultDeviceIndex(), "default");
+        return info;
+    }
+
+    const BlackMisc::Audio::CAudioDeviceInfo &CAudioInputDeviceVatlib::getCurrentInputDevice() const
+    {
+        return m_currentDevice;
+    }
+
+    void CAudioInputDeviceVatlib::setInputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device)
+    {
+        Q_ASSERT_X(m_inputCodec, "CAudioInputDeviceVatlib", "VatLocalCodec is invalid!");
+        if (!device.isValid())
+        {
+            CLogMessage(this).warning("Cannot set invalid input device!");
+            return;
+        }
+
+        if (!Vat_SetAudioInputDevice(m_inputCodec.data(), device.getIndex()))
+        {
+            CLogMessage(this).warning("Setting input device failed");
+        }
+        m_currentDevice = device;
+    }
+
+    void CAudioInputDeviceVatlib::onInputHardwareDeviceReceived(int deviceIndex, const char *hardwareName, void *cbVar)
+    {
+        BlackMisc::Audio::CAudioDeviceInfo inputDevice(BlackMisc::Audio::CAudioDeviceInfo::InputDevice, deviceIndex, QString(hardwareName));
+        cbvar_cast_inputDevice(cbVar)->m_devices.push_back(inputDevice);
+    }
+
+    CAudioOutputDeviceVatlib::CAudioOutputDeviceVatlib(VatAudioService audioService, QObject *parent)
+         : IAudioOutputDevice(parent),
+           m_audioService(audioService)
+    {
+        m_outputCodec.reset(Vat_CreateLocalOutputCodec(m_audioService));
+        Vat_GetOutputDeviceInfo(m_outputCodec.data(), onOutputHardwareDeviceReceived, this, nullptr);
+        m_currentDevice = getDefaultOutputDevice();
+    }
+
+    const BlackMisc::Audio::CAudioDeviceInfoList &CAudioOutputDeviceVatlib::getOutputDevices() const
+    {
+        return m_devices;
+    }
+
+    const BlackMisc::Audio::CAudioDeviceInfo &CAudioOutputDeviceVatlib::getDefaultOutputDevice() const
+    {
+        static BlackMisc::Audio::CAudioDeviceInfo info(BlackMisc::Audio::CAudioDeviceInfo::OutputDevice, BlackMisc::Audio::CAudioDeviceInfo::defaultDeviceIndex(), "default");
+        return info;
+    }
+
+    const BlackMisc::Audio::CAudioDeviceInfo &CAudioOutputDeviceVatlib::getCurrentOutputDevice() const
+    {
+        return m_currentDevice;
+    }
+
+    void CAudioOutputDeviceVatlib::setOutputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device)
+    {
+        Q_ASSERT_X(m_outputCodec, "CAudioOutputDeviceVatlib", "VatLocalCodec is invalid!");
+        if (!device.isValid())
+        {
+            CLogMessage(this).warning("Cannot set invalid output device!");
+            return;
+        }
+
+        Vat_SetAudioOutputDevice(m_outputCodec.data(), device.getIndex());
+        this->m_currentDevice = device;
+    }
+
+    void CAudioOutputDeviceVatlib::setOutputVolume(int volume)
+    {
+        Q_ASSERT(m_outputCodec);
+        Vat_SetOutputVolume(m_outputCodec.data(), volume);
+    }
+
+    int CAudioOutputDeviceVatlib::getOutputVolume() const
+    {
+        Q_ASSERT(m_outputCodec);
+        return Vat_GetOutputVolume(m_outputCodec.data());
+    }
+
+    void CAudioOutputDeviceVatlib::onOutputHardwareDeviceReceived(int deviceIndex, const char *hardwareName, void *cbVar)
+    {
+        BlackMisc::Audio::CAudioDeviceInfo outputDevice(BlackMisc::Audio::CAudioDeviceInfo::OutputDevice, deviceIndex, QString(hardwareName));
+        cbvar_cast_outputDevice(cbVar)->m_devices.push_back(outputDevice);
+    }
+}

src/blackcore/audio_device_vatlib.h

@@ -0,0 +1,129 @@
+/* Copyright (C) 2014
+ * swift project community / contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKCORE_AUDIODEVICEVATLIB_H
+#define BLACKCORE_AUDIODEVICEVATLIB_H
+
+#include "audio_device.h"
+#include "blackmisc/audiodeviceinfo.h"
+#include "blackmisc/audiodeviceinfolist.h"
+
+#include "vatlib/vatlib2.h"
+
+#include <QObject>
+
+//! \file
+
+namespace BlackCore
+{
+    //! Audio Input Device
+    class CAudioInputDeviceVatlib : public IAudioInputDevice
+    {
+        Q_OBJECT
+
+    public:
+
+        //! Constructor
+        CAudioInputDeviceVatlib(VatAudioService audioService, QObject *parent = nullptr);
+
+        //! Destructor
+        virtual ~CAudioInputDeviceVatlib() = default;
+
+        //! \copydoc IAudioInputDevice::getOutputDevices
+        virtual const BlackMisc::Audio::CAudioDeviceInfoList &getInputDevices() const override;
+
+        //! \copydoc IAudioInputDevice::getDefaultInputDevice
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getDefaultInputDevice() const override;
+
+        //! \copydoc IAudioInputDevice::getCurrentInputDevice
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getCurrentInputDevice() const override;
+
+        //! \copydoc IAudioInputDevice::setInputDevice
+        virtual void setInputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) override;
+
+        //! Get vatlib input device pointer
+        VatLocalInputCodec getVatLocalInputCodec() { return m_inputCodec.data(); }
+
+    private:
+
+        struct VatLocalInputCodecDeleter
+        {
+            static inline void cleanup(VatProducerConsumer_tag *obj)
+            {
+                if (!obj) Vat_DestroyLocalInputCodec(obj);
+            }
+        };
+
+        static void onInputHardwareDeviceReceived(int deviceIndex, const char *hardwareName, void *cbVar);
+
+        BlackMisc::Audio::CAudioDeviceInfoList m_devices; /*!< in and output devices */
+        BlackMisc::Audio::CAudioDeviceInfo m_currentDevice;
+
+        VatAudioService m_audioService;
+        QScopedPointer<VatProducerConsumer_tag, VatLocalInputCodecDeleter> m_inputCodec;
+    };
+
+    //! Audio Output Device
+    class CAudioOutputDeviceVatlib : public IAudioOutputDevice
+    {
+        Q_OBJECT
+
+    public:
+
+        //! Constructor
+        CAudioOutputDeviceVatlib(VatAudioService audioService, QObject *parent = nullptr);
+
+        //! Destructor
+        virtual ~CAudioOutputDeviceVatlib() = default;
+
+        //! \copydoc IAudioOutputDevice::getOutputDevices
+        virtual const BlackMisc::Audio::CAudioDeviceInfoList &getOutputDevices() const override;
+
+        //! \copydoc IAudioOutputDevice::getDefaultOutputDevice
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getDefaultOutputDevice() const override;
+
+        //! \copydoc IAudioOutputDevice::getCurrentOutputDevice
+        virtual const BlackMisc::Audio::CAudioDeviceInfo &getCurrentOutputDevice() const override;
+
+        //! \copydoc IAudioOutputDevice::setOutputDevice
+        virtual void setOutputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) override;
+
+        //! \copydoc IAudioOutputDevice::setOutputVolume
+        virtual void setOutputVolume(int volume) override;
+
+        //! \copydoc IAudioOutputDevice::getOutputVolume
+        virtual int getOutputVolume() const override;
+
+        //! Get vatlib output device pointer
+        VatLocalOutputCodec getVatLocalOutputCodec() { return m_outputCodec.data(); }
+
+    private:
+
+        struct VatLocalOutputCodecDeleter
+        {
+            static inline void cleanup(VatProducerConsumer_tag *obj)
+            {
+                if (!obj) Vat_DestroyLocalOutputCodec(obj);
+            }
+        };
+
+        static void onOutputHardwareDeviceReceived(int deviceIndex, const char *hardwareName, void *cbVar);
+
+
+        BlackMisc::Audio::CAudioDeviceInfoList m_devices; /*!< in and output devices */
+        BlackMisc::Audio::CAudioDeviceInfo m_currentDevice;
+
+        VatAudioService m_audioService;
+        QScopedPointer<VatProducerConsumer_tag, VatLocalOutputCodecDeleter> m_outputCodec;
+    };
+}
+
+#endif // guard

src/blackcore/context_audio_impl.cpp

@@ -46,6 +46,8 @@ namespace BlackCore
         m_channelCom2 = m_voice->getVoiceChannel(1);
         m_channelCom2->setMyAircraftCallsign(getIContextOwnAircraft()->getOwnAircraft().getCallsign());
         connect(m_channelCom2.data(), &IVoiceChannel::connectionStatusChanged, this, &CContextAudio::ps_com2ConnectionStatusChanged);
+        m_voiceInputDevice = m_voice->createInputDevice();
+        m_voiceOutputDevice = m_voice->createOutputDevice();
 
         // 4. load sounds (init), not possible in own thread
         QTimer::singleShot(10 * 1000, this, SLOT(ps_initNotificationSounds()));
@@ -122,7 +124,9 @@ namespace BlackCore
     {
         Q_ASSERT(this->m_voice);
         CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO;
-        return this->m_voice->audioDevices();
+        CAudioDeviceInfoList devices = this->m_voiceOutputDevice->getOutputDevices();
+        devices = devices.join(this->m_voiceInputDevice->getInputDevices());
+        return devices;
     }
 
     /*
@@ -133,8 +137,8 @@ namespace BlackCore
         Q_ASSERT(this->m_voice);
         CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO;
         CAudioDeviceInfoList devices;
-        devices.push_back(this->m_voice->getCurrentInputDevice());
-        devices.push_back(this->m_voice->getCurrentOutputDevice());
+        devices.push_back(this->m_voiceInputDevice->getCurrentInputDevice());
+        devices.push_back(this->m_voiceOutputDevice->getCurrentOutputDevice());
         return devices;
     }
 
@@ -149,17 +153,17 @@ namespace BlackCore
         bool changed = false;
         if (audioDevice.getType() == CAudioDeviceInfo::InputDevice)
         {
-            if (this->m_voice->getCurrentInputDevice() != audioDevice)
+            if (this->m_voiceInputDevice->getCurrentInputDevice() != audioDevice)
             {
-                this->m_voice->setInputDevice(audioDevice);
+                this->m_voiceInputDevice->setInputDevice(audioDevice);
                 changed = true;
             }
         }
         else
         {
-            if (this->m_voice->getCurrentOutputDevice() != audioDevice)
+            if (this->m_voiceOutputDevice->getCurrentOutputDevice() != audioDevice)
             {
-                this->m_voice->setOutputDevice(audioDevice);
+                this->m_voiceOutputDevice->setOutputDevice(audioDevice);
                 changed = true;
             }
         }
@@ -207,23 +211,13 @@ namespace BlackCore
     {
         if (this->isMuted() == muted) { return; } // avoid roundtrips / unnecessary signals
 
-        m_channelCom1->switchAudioOutput(!muted);
-        m_channelCom2->switchAudioOutput(!muted);
-        m_channelCom1->setRoomOutputVolume(muted ? 0 : VoiceRoomEnabledVolume);
-        m_channelCom2->setRoomOutputVolume(muted ? 0 : VoiceRoomEnabledVolume);
-
-        // adjust volume when unmuted
-        if (!muted)
+        if (muted)
         {
-            bool adjusted = false;
-            qint32 v1 = this->m_channelCom1->getVolume();
-            qint32 v2 = this->m_channelCom2->getVolume();
-            //! \todo rectify int/qint/quint mess
-            int channelV1 = static_cast<int>(this->m_channelCom1->getVolume());
-            int channelV2 = static_cast<int>(this->m_channelCom2->getVolume());
-            if (channelV1 < MinUnmuteVolume) { v1 = MinUnmuteVolume; adjusted = true; }
-            if (channelV2 < MinUnmuteVolume) { v2 = MinUnmuteVolume; adjusted = true; }
-            if (adjusted) { this->setVolumes(v1, v2); }
+            m_voiceOutputDevice->setOutputVolume(0);
+        }
+        else
+        {
+            m_voiceOutputDevice->setOutputVolume(m_outDeviceVolume);
         }
 
         // signal
@@ -235,9 +229,8 @@ namespace BlackCore
      */
     bool CContextAudio::isMuted() const
     {
-        Q_ASSERT(this->m_voice);
         CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO;
-        return m_channelCom1->isMuted() && m_channelCom2->isMuted();
+        return m_voiceOutputDevice->getOutputVolume() == 0;
     }
 
     /*
@@ -333,7 +326,7 @@ namespace BlackCore
     {
         Q_ASSERT(this->m_voice);
         CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO << selcal;
-        CAudioDeviceInfo outputDevice = m_voice->getCurrentOutputDevice();
+        CAudioDeviceInfo outputDevice = m_voiceOutputDevice->getCurrentOutputDevice();
         BlackSound::CSoundGenerator::playSelcal(90, selcal, outputDevice);
     }
 

src/blackcore/context_audio_impl.h

@@ -18,6 +18,7 @@
 #include "dbus_server.h"
 #include "voice.h"
 #include "voice_channel.h"
+#include "audio_device.h"
 #include "input_manager.h"
 #include "blackinput/keyboard.h"
 #include "blackmisc/voiceroomlist.h"
@@ -169,6 +170,9 @@ namespace BlackCore
         CInputManager::RegistrationHandle m_handlePtt;
         QPointer<IVoiceChannel> m_channelCom1;
         QPointer<IVoiceChannel> m_channelCom2;
+        std::unique_ptr<IAudioOutputDevice> m_voiceOutputDevice;
+        int m_outDeviceVolume = 100;
+        std::unique_ptr<IAudioInputDevice> m_voiceInputDevice;
     };
 } // namespace
 

src/blackcore/voice.h

@@ -6,6 +6,7 @@
 #ifndef BLACKCORE_VOICE_H
 #define BLACKCORE_VOICE_H
 
+#include "audio_device.h"
 #include "../blackmisc/avcallsignlist.h"
 #include "../blackmisc/avselcal.h"
 #include "../blackmisc/nwuserlist.h"
@@ -20,7 +21,6 @@
 namespace BlackCore
 {
     class IVoiceChannel;
-
     //! Interface to a connection to a ATC voice server for use in flight simulation.
     class IVoice : public QObject
     {
@@ -37,47 +37,15 @@ namespace BlackCore
         //! Virtual destructor.
         virtual ~IVoice() {}
 
-        /*!
-         * \brief Audio devices
-         * \return
-         */
-        virtual const BlackMisc::Audio::CAudioDeviceInfoList &audioDevices() const = 0;
+        //! Create input device object
+        virtual std::unique_ptr<IAudioInputDevice> createInputDevice() = 0;
 
-        /*!
-         * \brief Default input device
-         * \return
-         */
-        virtual const BlackMisc::Audio::CAudioDeviceInfo defaultAudioInputDevice() const = 0;
-
-        /*!
-         * \brief Default output device
-         * \return
-         */
-        virtual const BlackMisc::Audio::CAudioDeviceInfo defaultAudioOutputDevice() const = 0;
+        //! Create output device object
+        virtual std::unique_ptr<IAudioOutputDevice> createOutputDevice() = 0;
 
         //! Get voice channel object
         virtual IVoiceChannel *getVoiceChannel(qint32 channelIndex) const = 0;
 
-        /*!
-         * \brief Current input device
-         */
-        virtual BlackMisc::Audio::CAudioDeviceInfo getCurrentInputDevice() const = 0;
-
-        /*!
-         * \brief Current output device
-         */
-        virtual BlackMisc::Audio::CAudioDeviceInfo getCurrentOutputDevice() const = 0;
-
-        /*!
-         * \brief Output device to be used
-         */
-        virtual void setOutputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) = 0;
-
-        /*!
-         * \brief Input device to be used
-         */
-        virtual void setInputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) = 0;
-
         /*!
          * \brief Enable audio loopback to route recorded voice from microphone to speakers
          * \param enable (default true)

src/blackcore/voice_vatlib.cpp

@@ -5,6 +5,7 @@
 
 #include "voice_vatlib.h"
 #include "voice_channel_vatlib.h"
+#include "audio_device_vatlib.h"
 #include "blackmisc/logmessage.h"
 #include "blackmisc/blackmiscfreefunctions.h"
 #include <QDebug>
@@ -28,9 +29,6 @@ namespace BlackCore
     {
         Vat_SetVoiceErrorHandler(CVoiceVatlib::voiceErrorHandler);
 
-        this->m_currentInputDevice = this->defaultAudioInputDevice();
-        this->m_currentOutputDevice = this->defaultAudioOutputDevice();
-
         // do processing
         this->startTimer(10);
     }
@@ -40,60 +38,14 @@ namespace BlackCore
      */
     CVoiceVatlib::~CVoiceVatlib() {}
 
-    /*
-     * Devices
-     */
-    const BlackMisc::Audio::CAudioDeviceInfoList &CVoiceVatlib::audioDevices() const
+    std::unique_ptr<IAudioInputDevice> CVoiceVatlib::createInputDevice()
     {
-        return m_devices;
+        return make_unique<CAudioInputDeviceVatlib>(m_audioService.data(), this);
     }
 
-    /*
-     * Default input device
-     */
-    const BlackMisc::Audio::CAudioDeviceInfo CVoiceVatlib::defaultAudioInputDevice() const
-    {
-        // Constructor creates already a default device
-        return BlackMisc::Audio::CAudioDeviceInfo(BlackMisc::Audio::CAudioDeviceInfo::InputDevice, BlackMisc::Audio::CAudioDeviceInfo::defaultDeviceIndex(), "default");
-    }
-
-    /*
-     * Default output device
-     */
-    const BlackMisc::Audio::CAudioDeviceInfo CVoiceVatlib::defaultAudioOutputDevice() const
-    {
-        // Constructor creates already a default device
-        return BlackMisc::Audio::CAudioDeviceInfo(BlackMisc::Audio::CAudioDeviceInfo::OutputDevice, BlackMisc::Audio::CAudioDeviceInfo::defaultDeviceIndex(), "default");
-    }
-
-    /*
-     * Current output device
-     */
-    CAudioDeviceInfo CVoiceVatlib::getCurrentOutputDevice() const
-    {
-        return m_currentOutputDevice;
-    }
-
-    /*
-     * Current input device
-     */
-    CAudioDeviceInfo CVoiceVatlib::getCurrentInputDevice() const
-    {
-        return m_currentInputDevice;
-    }
-
-    /*
-     * Set input device
-     */
-    void CVoiceVatlib::setInputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device)
-    {
-    }
-
-    /*
-     * Set output device
-     */
-    void CVoiceVatlib::setOutputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device)
+    std::unique_ptr<IAudioOutputDevice> CVoiceVatlib::createOutputDevice()
     {
+        return make_unique<CAudioOutputDeviceVatlib>(m_audioService.data(), this);
     }
 
     IVoiceChannel *CVoiceVatlib::getVoiceChannel(qint32 channelIndex) const

src/blackcore/voice_vatlib.h

@@ -41,35 +41,15 @@ namespace BlackCore
         //! \brief Destructor
         virtual ~CVoiceVatlib();
 
-        // Hardware devices
-        // TODO: Vatlib supports multiple output devices. That basically means, you could connect
-        // to different voice rooms and send their audio to different devices, e.g. ATIS to loudspeakers
-        // and ATC to headspeakers. Is not important to implement that now, if ever.
+        //! \copydoc IVoice::createInputDevice()
+        virtual std::unique_ptr<IAudioInputDevice> createInputDevice() override;
 
-        //! \copydoc IVoice::audioDevices()
-        virtual const BlackMisc::Audio::CAudioDeviceInfoList &audioDevices() const override;
-
-        //! \copydoc IVoice::defaultAudioInputDevice()
-        virtual const BlackMisc::Audio::CAudioDeviceInfo defaultAudioInputDevice() const override;
-
-        //! \copydoc IVoice::defaultAudioOutputDevice()
-        virtual const BlackMisc::Audio::CAudioDeviceInfo defaultAudioOutputDevice() const override;
+        //! \copydoc IVoice::createOutputDevice()
+        virtual std::unique_ptr<IAudioOutputDevice> createOutputDevice() override;
 
         //! \copydoc IVoice::getVoiceChannel
         virtual IVoiceChannel *getVoiceChannel(qint32 channelIndex) const override;
 
-        //! \copydoc IVoice::setInputDevice
-        virtual void setInputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) override;
-
-        //! \copydoc IVoice::setOutputDevice
-        virtual void setOutputDevice(const BlackMisc::Audio::CAudioDeviceInfo &device) override;
-
-        //! \copydoc IVoice::getCurrentInputDevice()
-        virtual BlackMisc::Audio::CAudioDeviceInfo getCurrentInputDevice() const override;
-
-        //! \copydoc IVoice::getCurrentOutputDevice()
-        virtual BlackMisc::Audio::CAudioDeviceInfo getCurrentOutputDevice() const override;
-
         //! \copydoc IVoice::enableAudioLoopback
         virtual void enableAudioLoopback(bool enable = true) override;
 
@@ -114,9 +94,6 @@ namespace BlackCore
 
         QScopedPointer<VatAudioService_tag, VatAudioServiceDeleter> m_audioService;
         QScopedPointer<VatUDPAudioPort_tag, VatUDPAudioPortDeleter> m_udpPort;
-        BlackMisc::Audio::CAudioDeviceInfoList m_devices; /*!< in and output devices */
-        BlackMisc::Audio::CAudioDeviceInfo m_currentOutputDevice;
-        BlackMisc::Audio::CAudioDeviceInfo m_currentInputDevice;
         QHash<qint32, IVoiceChannel *> m_hashChannelIndex;
         bool m_isAudioLoopbackEnabled; /*!< A flag whether audio loopback is enabled or not */