Ref T730, adjusted audio device info/info list,

so it can be used with QAudioDeviceInfo

src/blackmisc/audio/audiodeviceinfo.cpp

@@ -26,11 +26,43 @@ namespace BlackMisc
             m_deviceName(name), m_hostName(QHostInfo::localHostName())
         { }
 
+        QAudioDeviceInfo CAudioDeviceInfo::toAudioDeviceInfo() const
+        {
+            QList<QAudioDeviceInfo> devices;
+            switch (this->getType())
+            {
+            case InputDevice:  devices = QAudioDeviceInfo::availableDevices(QAudio::AudioInput); break;
+            case OutputDevice: devices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput); break;
+            default:
+                devices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
+                devices += QAudioDeviceInfo::availableDevices(QAudio::AudioInput);
+                break;
+            }
+
+            for (const QAudioDeviceInfo &d : as_const(devices))
+            {
+                if (d.deviceName() == this->getName()) { return d; }
+            }
+
+            return QAudioDeviceInfo();
+        }
+
+        CAudioDeviceInfo::DeviceType CAudioDeviceInfo::fromQtMode(QAudio::Mode m)
+        {
+            switch (m)
+            {
+            case QAudio::AudioInput: return InputDevice;
+            case QAudio::AudioOutput: return OutputDevice;
+            default: break;
+            }
+            return Unknown;
+        }
+
         QString CAudioDeviceInfo::convertToQString(bool i18n) const
         {
-            Q_UNUSED(i18n);
+            Q_UNUSED(i18n)
             if (m_hostName.isEmpty()) { return m_deviceName; }
             return m_deviceName % u" [" % this->getHostName() % u']';
         }
-    } // Voice
+    } // ns
-} // BlackMisc
+} // ns

src/blackmisc/audio/audiodeviceinfo.h

@@ -11,10 +11,11 @@
 #ifndef BLACKMISC_AUDIO_AUDIODEVICE_H
 #define BLACKMISC_AUDIO_AUDIODEVICE_H
 
-#include "blackmisc/blackmiscexport.h"
 #include "blackmisc/metaclass.h"
 #include "blackmisc/valueobject.h"
+#include "blackmisc/blackmiscexport.h"
 
+#include <QAudioDeviceInfo>
 #include <QMetaType>
 #include <QString>
 
@@ -59,7 +60,13 @@ namespace BlackMisc
             DeviceType getType() const { return m_type; }
 
             //! Valid audio device object?
-            bool isValid() const { return m_deviceIndex >= -1 && !m_deviceName.isEmpty(); }
+            bool isValid() const { return m_deviceIndex != Unknown && !m_deviceName.isEmpty(); }
+
+            //! To QAudioDeviceInfo
+            QAudioDeviceInfo toAudioDeviceInfo() const;
+
+            //! Convert the Qt type
+            static DeviceType fromQtMode(QAudio::Mode m);
 
             //! Device index for default device
             static int defaultDeviceIndex() {return -1;}
@@ -83,10 +90,10 @@ namespace BlackMisc
             QString convertToQString(bool i18n = false) const;
 
         private:
-            DeviceType m_type;    //!< Device type, @see CAudioDeviceInfo::DeviceType
+            DeviceType m_type = Unknown; //!< Device type, @see CAudioDeviceInfo::DeviceType
-            int m_deviceIndex;    //!< deviceIndex is the number is the reference for the VVL. The device is selected by this index. The managing class needs to take care, that indexes are valid.
+            int m_deviceIndex = -1;      //!< deviceIndex is the number is the reference for the VVL. The device is selected by this index. The managing class needs to take care, that indexes are valid.
-            QString m_deviceName; //!< Device name
+            QString m_deviceName;        //!< Device name
-            QString m_hostName;   //!< We use a DBus based system. Hence an audio device can reside on a differen computers, this here is its name
+            QString m_hostName;          //!< We use a DBus based system. Hence an audio device can reside on a differen computers, this here is its name
 
             BLACK_METACLASS(
                 CAudioDeviceInfo,
@@ -100,5 +107,6 @@ namespace BlackMisc
 } // namespace
 
 Q_DECLARE_METATYPE(BlackMisc::Audio::CAudioDeviceInfo)
+Q_DECLARE_METATYPE(BlackMisc::Audio::CAudioDeviceInfo::DeviceType)
 
 #endif // guard

src/blackmisc/audio/audiodeviceinfolist.cpp

@@ -11,6 +11,8 @@
 #include "blackmisc/range.h"
 
 #include <QString>
+#include <QAudioDeviceInfo>
+#include <QHostInfo>
 #include <algorithm>
 #include <tuple>
 
@@ -18,7 +20,6 @@ namespace BlackMisc
 {
     namespace Audio
     {
-
         CAudioDeviceInfoList::CAudioDeviceInfoList() { }
 
         CAudioDeviceInfoList::CAudioDeviceInfoList(const CSequence &other) :
@@ -35,6 +36,23 @@ namespace BlackMisc
             return this->findBy(&CAudioDeviceInfo::getType, CAudioDeviceInfo::InputDevice);
         }
 
+        CAudioDeviceInfo CAudioDeviceInfoList::findByName(const QString &name, bool strict) const
+        {
+            for (const CAudioDeviceInfo &d : *this)
+            {
+                if (strict)
+                {
+                    if (d.getName() == name) { return d; }
+                }
+                else
+                {
+                    if (d.getName().startsWith(name, Qt::CaseInsensitive)) { return d; }
+                    if (name.startsWith(d.getName(), Qt::CaseInsensitive)) { return d; }
+                }
+            }
+            return CAudioDeviceInfo();
+        }
+
         CAudioDeviceInfo CAudioDeviceInfoList::findByDeviceIndex(int deviceIndex)
         {
             return this->findBy(&CAudioDeviceInfo::getIndex, deviceIndex).frontOrDefault();
@@ -42,10 +60,85 @@ namespace BlackMisc
 
         int CAudioDeviceInfoList::count(CAudioDeviceInfo::DeviceType type) const
         {
-            return std::count_if(this->begin(), this->end(), [type](const CAudioDeviceInfo &device)
+            return static_cast<int>(std::count_if(this->begin(), this->end(), [type](const CAudioDeviceInfo & device)
             {
                 return device.getType() == type;
-            });
+            }));
+        }
+
+        QStringList CAudioDeviceInfoList::getDeviceNames() const
+        {
+            QStringList names;
+            for (const CAudioDeviceInfo &d : *this)
+            {
+                names << d.getName();
+            }
+            return names;
+        }
+
+        CAudioDeviceInfoList CAudioDeviceInfoList::allQtInputDevices()
+        {
+            const QList<QAudioDeviceInfo> inputDevices = QAudioDeviceInfo::availableDevices(QAudio::AudioInput);
+            CAudioDeviceInfoList devices;
+
+            int index = 100;
+            for (const QAudioDeviceInfo &inputDevice : inputDevices)
+            {
+                const CAudioDeviceInfo d(CAudioDeviceInfo::InputDevice, index++, inputDevice.deviceName());
+                devices.push_back(d);
+            }
+            return devices;
+        }
+
+        CAudioDeviceInfoList CAudioDeviceInfoList::allQtOutputDevices()
+        {
+            const QList<QAudioDeviceInfo> outputDevices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
+            CAudioDeviceInfoList devices;
+
+            int index = 200;
+            for (const QAudioDeviceInfo &outputDevice : outputDevices)
+            {
+                const CAudioDeviceInfo d(CAudioDeviceInfo::OutputDevice, index++, outputDevice.deviceName());
+                devices.push_back(d);
+            }
+            return devices;
+        }
+
+        CAudioDeviceInfoList CAudioDeviceInfoList::allQtDevices()
+        {
+            CAudioDeviceInfoList i = allQtInputDevices();
+            i.push_back(allQtOutputDevices());
+            return i;
+        }
+
+        CAudioDeviceInfo CAudioDeviceInfoList::fromQtInputDevice(const QAudioDeviceInfo &device)
+        {
+            const CAudioDeviceInfoList dl = CAudioDeviceInfoList::allQtInputDevices();
+            for (const CAudioDeviceInfo &d : dl)
+            {
+                if (d.getName() == device.deviceName()) { return d; }
+            }
+            return CAudioDeviceInfo();
+        }
+
+        CAudioDeviceInfo CAudioDeviceInfoList::fromQtOutputDevice(const QAudioDeviceInfo &device)
+        {
+            const CAudioDeviceInfoList dl = CAudioDeviceInfoList::allQtOutputDevices();
+            for (const CAudioDeviceInfo &d : dl)
+            {
+                if (d.getName() == device.deviceName()) { return d; }
+            }
+            return CAudioDeviceInfo();
+        }
+
+        CAudioDeviceInfo CAudioDeviceInfoList::qtDefaultInputDevice()
+        {
+            return fromQtInputDevice(QAudioDeviceInfo::defaultInputDevice());
+        }
+
+        CAudioDeviceInfo CAudioDeviceInfoList::qtDefaultOutputDevice()
+        {
+            return fromQtOutputDevice(QAudioDeviceInfo::defaultOutputDevice());
         }
 
     } // namespace

src/blackmisc/audio/audiodeviceinfolist.h

@@ -18,6 +18,7 @@
 #include "blackmisc/variant.h"
 
 #include <QMetaType>
+#include <QStringList>
 
 namespace BlackMisc
 {
@@ -26,7 +27,7 @@ namespace BlackMisc
         //! Value object encapsulating a list of audio devices.
         class BLACKMISC_EXPORT CAudioDeviceInfoList :
             public CSequence<CAudioDeviceInfo>,
-            public BlackMisc::Mixin::MetaType<CAudioDeviceInfoList>
+            public Mixin::MetaType<CAudioDeviceInfoList>
         {
         public:
             BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CAudioDeviceInfoList)
@@ -44,13 +45,28 @@ namespace BlackMisc
             //! Get output devices in that list
             CAudioDeviceInfoList getInputDevices() const;
 
+            //! Find by name
+            CAudioDeviceInfo findByName(const QString &name, bool strict = false) const;
+
             //! Find device by its index
             CAudioDeviceInfo findByDeviceIndex(int deviceIndex);
 
             //! Count (as of type)
             int count(CAudioDeviceInfo::DeviceType type) const;
-        };
 
+            //! All names
+            QStringList getDeviceNames() const;
+
+            //! List based on the Qt devices @{
+            static CAudioDeviceInfoList allQtInputDevices();
+            static CAudioDeviceInfoList allQtOutputDevices();
+            static CAudioDeviceInfoList allQtDevices();
+            static CAudioDeviceInfo fromQtInputDevice(const QAudioDeviceInfo &device);
+            static CAudioDeviceInfo fromQtOutputDevice(const QAudioDeviceInfo &device);
+            static CAudioDeviceInfo qtDefaultInputDevice();
+            static CAudioDeviceInfo qtDefaultOutputDevice();
+            //! @}
+        };
     } //namespace
 } // namespace