From 48f10e204034a5e00a230609124ff2392cf92a7d Mon Sep 17 00:00:00 2001
From: Andreas Traczyk <andreas.traczyk@savoirfairelinux.com>
Date: Thu, 11 Mar 2021 20:52:47 -0500
Subject: [PATCH] portaudio: refactor host api to get default comm devices
Also adds portaudio api specific device preferences in the config
using strings instead of indices. An empty string will cause the
default communication device to selected.
Change-Id: I64597c2d706acdd6e1422558d7609fc14a7ad818
Gitlab: #463
---
...001-add-get-default-comm-devices-api.patch | 223 +++++++++++++
contrib/src/portaudio/package.json | 5 +-
src/media/audio/portaudio/portaudiolayer.cpp | 312 ++++++++++--------
src/preferences.cpp | 14 +
src/preferences.h | 22 +-
5 files changed, 433 insertions(+), 143 deletions(-)
create mode 100644 contrib/src/portaudio/0001-add-get-default-comm-devices-api.patch
diff --git a/contrib/src/portaudio/0001-add-get-default-comm-devices-api.patch b/contrib/src/portaudio/0001-add-get-default-comm-devices-api.patch
new file mode 100644
index 0000000000..193606f29f
--- /dev/null
+++ b/contrib/src/portaudio/0001-add-get-default-comm-devices-api.patch
@@ -0,0 +1,223 @@
+From 70ea89479fcff70982bb95ea82426320b8fe0845 Mon Sep 17 00:00:00 2001
+From: Andreas Traczyk <andreas.traczyk@savoirfairelinux.com>
+Date: Thu, 11 Mar 2021 19:19:54 -0500
+Subject: [PATCH] add get default comm devices api
+
+---
+ include/portaudio.h | 11 +++++
+ src/common/pa_front.c | 54 +++++++++++++++++++++++++
+ src/hostapi/wasapi/pa_win_wasapi.c | 65 ++++++++++++++++++++++++++++++
+ 3 files changed, 130 insertions(+)
+
+diff --git a/include/portaudio.h b/include/portaudio.h
+index 8a94aaf..0466a54 100644
+--- a/include/portaudio.h
++++ b/include/portaudio.h
+@@ -320,6 +320,13 @@ typedef struct PaHostApiInfo
+ if no default output device is available.
+ */
+ PaDeviceIndex defaultOutputDevice;
++
++ /** The default input/output devices for this host API(if supported).
++ The value will be a device index ranging from 0 to (Pa_GetDeviceCount()-1),
++ or paNoDevice if no default output device is available.
++ */
++ PaDeviceIndex defaultCommInputDevice;
++ PaDeviceIndex defaultCommOutputDevice;
+
+ } PaHostApiInfo;
+
+@@ -449,6 +456,10 @@ PaDeviceIndex Pa_GetDefaultInputDevice( void );
+ PaDeviceIndex Pa_GetDefaultOutputDevice( void );
+
+
++PaDeviceIndex Pa_GetDefaultCommOutputDevice( void );
++PaDeviceIndex Pa_GetDefaultCommInputDevice( void );
++
++
+ /** The type used to represent monotonic time in seconds. PaTime is
+ used for the fields of the PaStreamCallbackTimeInfo argument to the
+ PaStreamCallback and as the result of Pa_GetStreamTime().
+diff --git a/src/common/pa_front.c b/src/common/pa_front.c
+index 188cee9..ea0c3da 100644
+--- a/src/common/pa_front.c
++++ b/src/common/pa_front.c
+@@ -234,6 +234,8 @@ static PaError InitializeHostApis( void )
+ PaUtilHostApiRepresentation* hostApi = hostApis_[hostApisCount_];
+ assert( hostApi->info.defaultInputDevice < hostApi->info.deviceCount );
+ assert( hostApi->info.defaultOutputDevice < hostApi->info.deviceCount );
++ assert( hostApi->info.defaultCommInputDevice < hostApi->info.deviceCount );
++ assert( hostApi->info.defaultCommOutputDevice < hostApi->info.deviceCount );
+
+ /* the first successfully initialized host API with a default input *or*
+ output device is used as the default host API.
+@@ -253,6 +255,12 @@ static PaError InitializeHostApis( void )
+ if( hostApi->info.defaultOutputDevice != paNoDevice )
+ hostApi->info.defaultOutputDevice += baseDeviceIndex;
+
++ if( hostApi->info.defaultCommInputDevice != paNoDevice )
++ hostApi->info.defaultCommInputDevice += baseDeviceIndex;
++
++ if( hostApi->info.defaultCommOutputDevice != paNoDevice )
++ hostApi->info.defaultCommOutputDevice += baseDeviceIndex;
++
+ baseDeviceIndex += hostApi->info.deviceCount;
+ deviceCount_ += hostApi->info.deviceCount;
+
+@@ -746,6 +754,52 @@ PaDeviceIndex Pa_GetDefaultOutputDevice( void )
+ }
+
+
++PaDeviceIndex Pa_GetDefaultCommInputDevice( void )
++{
++ PaHostApiIndex hostApi;
++ PaDeviceIndex result;
++
++ PA_LOGAPI_ENTER( "Pa_GetDefaultCommInputDevice" );
++
++ hostApi = Pa_GetDefaultHostApi();
++ if( hostApi < 0 )
++ {
++ result = paNoDevice;
++ }
++ else
++ {
++ result = hostApis_[hostApi]->info.defaultCommInputDevice;
++ }
++
++ PA_LOGAPI_EXIT_T( "Pa_GetDefaultCommInputDevice", "PaDeviceIndex: %d", result );
++
++ return result;
++}
++
++
++PaDeviceIndex Pa_GetDefaultCommOutputDevice( void )
++{
++ PaHostApiIndex hostApi;
++ PaDeviceIndex result;
++
++ PA_LOGAPI_ENTER( "Pa_GetDefaultCommOutputDevice" );
++
++ hostApi = Pa_GetDefaultHostApi();
++ if( hostApi < 0 )
++ {
++ result = paNoDevice;
++ }
++ else
++ {
++ result = hostApis_[hostApi]->info.defaultCommOutputDevice;
++ }
++
++ PA_LOGAPI_EXIT_T( "Pa_GetDefaultCommOutputDevice", "PaDeviceIndex: %d", result );
++
++ return result;
++}
++
++
+ const PaDeviceInfo* Pa_GetDeviceInfo( PaDeviceIndex device )
+ {
+ int hostSpecificDeviceIndex;
+diff --git a/src/hostapi/wasapi/pa_win_wasapi.c b/src/hostapi/wasapi/pa_win_wasapi.c
+index b12b91f..fb70eff 100644
+--- a/src/hostapi/wasapi/pa_win_wasapi.c
++++ b/src/hostapi/wasapi/pa_win_wasapi.c
+@@ -441,6 +441,9 @@ typedef struct
+ WCHAR defaultRenderer [MAX_STR_LEN];
+ WCHAR defaultCapturer [MAX_STR_LEN];
+
++ WCHAR defaultCommRenderer [MAX_STR_LEN];
++ WCHAR defaultCommCapturer [MAX_STR_LEN];
++
+ PaWasapiDeviceInfo *devInfo;
+
+ // Is true when WOW64 Vista/7 Workaround is needed
+@@ -1463,6 +1466,8 @@ PaError PaWasapi_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiInd
+ (*hostApi)->info.deviceCount = 0;
+ (*hostApi)->info.defaultInputDevice = paNoDevice;
+ (*hostApi)->info.defaultOutputDevice = paNoDevice;
++ (*hostApi)->info.defaultCommInputDevice = paNoDevice;
++ (*hostApi)->info.defaultCommOutputDevice = paNoDevice;
+
+ #ifndef PA_WINRT
+ paWasapi->enumerator = NULL;
+@@ -1524,6 +1529,57 @@ PaError PaWasapi_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiInd
+ }
+ }
+
++ // getting default device ids in the eCommunications "role"
++ {
++ {
++ IMMDevice *defaultCommRenderer = NULL;
++ hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(paWasapi->enumerator, eRender, eCommunications, &defaultCommRenderer);
++ if (hr != S_OK)
++ {
++ if (hr != E_NOTFOUND) {
++ // We need to set the result to a value otherwise we will return paNoError
++ // [IF_FAILED_JUMP(hResult, error);]
++ IF_FAILED_INTERNAL_ERROR_JUMP(hr, result, error);
++ }
++ }
++ else
++ {
++ WCHAR *pszDeviceId = NULL;
++ hr = IMMDevice_GetId(defaultCommRenderer, &pszDeviceId);
++ // We need to set the result to a value otherwise we will return paNoError
++ // [IF_FAILED_JUMP(hResult, error);]
++ IF_FAILED_INTERNAL_ERROR_JUMP(hr, result, error);
++ wcsncpy(paWasapi->defaultCommRenderer, pszDeviceId, MAX_STR_LEN-1);
++ CoTaskMemFree(pszDeviceId);
++ IMMDevice_Release(defaultCommRenderer);
++ }
++ }
++
++ {
++ IMMDevice *defaultCommCapturer = NULL;
++ hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(paWasapi->enumerator, eCapture, eCommunications, &defaultCommCapturer);
++ if (hr != S_OK)
++ {
++ if (hr != E_NOTFOUND) {
++ // We need to set the result to a value otherwise we will return paNoError
++ // [IF_FAILED_JUMP(hResult, error);]
++ IF_FAILED_INTERNAL_ERROR_JUMP(hr, result, error);
++ }
++ }
++ else
++ {
++ WCHAR *pszDeviceId = NULL;
++ hr = IMMDevice_GetId(defaultCommCapturer, &pszDeviceId);
++ // We need to set the result to a value otherwise we will return paNoError
++ // [IF_FAILED_JUMP(hResult, error);]
++ IF_FAILED_INTERNAL_ERROR_JUMP(hr, result, error);
++ wcsncpy(paWasapi->defaultCommCapturer, pszDeviceId, MAX_STR_LEN-1);
++ CoTaskMemFree(pszDeviceId);
++ IMMDevice_Release(defaultCommCapturer);
++ }
++ }
++ }
++
+ hr = IMMDeviceEnumerator_EnumAudioEndpoints(paWasapi->enumerator, eAll, DEVICE_STATE_ACTIVE, &pEndPoints);
+ // We need to set the result to a value otherwise we will return paNoError
+ // [IF_FAILED_JUMP(hResult, error);]
+@@ -1599,6 +1655,14 @@ PaError PaWasapi_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiInd
+ {// we found the default output!
+ (*hostApi)->info.defaultOutputDevice = (*hostApi)->info.deviceCount;
+ }
++ if (lstrcmpW(paWasapi->devInfo[i].szDeviceID, paWasapi->defaultCommCapturer) == 0)
++ {// we found the default input!
++ (*hostApi)->info.defaultCommInputDevice = (*hostApi)->info.deviceCount;
++ }
++ if (lstrcmpW(paWasapi->devInfo[i].szDeviceID, paWasapi->defaultCommRenderer) == 0)
++ {// we found the default output!
++ (*hostApi)->info.defaultCommOutputDevice = (*hostApi)->info.deviceCount;
++ }
+ }
+
+ hr = IMMDevice_GetState(paWasapi->devInfo[i].device, &paWasapi->devInfo[i].state);
+@@ -5736,3 +5800,4 @@ void PaWasapi_FreeMemory(void *ptr)
+ bFirst = FALSE;
+ }
+ #endif
++
+--
+2.17.1
+
diff --git a/contrib/src/portaudio/package.json b/contrib/src/portaudio/package.json
index 254b89fa1b..ff5fdf84ef 100644
--- a/contrib/src/portaudio/package.json
+++ b/contrib/src/portaudio/package.json
@@ -9,5 +9,6 @@
"PA_USE_DS=0",
"PA_USE_WMME=0",
"PA_USE_WDMKS=0"
- ]
-}
\ No newline at end of file
+ ],
+ "patches": ["0001-add-get-default-comm-devices-api.patch"]
+}
diff --git a/src/media/audio/portaudio/portaudiolayer.cpp b/src/media/audio/portaudio/portaudiolayer.cpp
index 7a284ab6c2..d3fbdd5ad3 100644
--- a/src/media/audio/portaudio/portaudiolayer.cpp
+++ b/src/media/audio/portaudio/portaudiolayer.cpp
@@ -50,18 +50,21 @@ struct PortAudioLayer::PortAudioLayerImpl
bool initFullDuplexStream(PortAudioLayer&);
bool apiInitialised_ {false};
- std::vector<std::string> getDeviceByType(AudioDeviceType type) const;
+ std::vector<std::string> getDevicesByType(AudioDeviceType type) const;
int getIndexByType(AudioDeviceType type);
- int getInternalIndexByType(const int index, AudioDeviceType type);
+ std::string getDeviceNameByType(const int index, AudioDeviceType type);
+ PaDeviceIndex getApiIndexByType(AudioDeviceType type);
+ std::string getApiDefaultDeviceName(AudioDeviceType type, bool commDevice) const;
+
+ std::string deviceRecord_ {};
+ std::string devicePlayback_ {};
+ std::string deviceRingtone_ {};
+
+ static constexpr const int defaultIndex_ {0};
- PaDeviceIndex indexIn_;
bool inputInitialized_ {false};
- PaDeviceIndex indexOut_;
- PaDeviceIndex indexRing_;
bool outputInitialized_ {false};
- AudioBuffer playbackBuff_;
-
std::array<PaStream*, static_cast<int>(Direction::End)> streams_;
int paOutputCallback(PortAudioLayer& parent,
@@ -114,42 +117,31 @@ PortAudioLayer::~PortAudioLayer()
std::vector<std::string>
PortAudioLayer::getCaptureDeviceList() const
{
- return pimpl_->getDeviceByType(AudioDeviceType::CAPTURE);
+ return pimpl_->getDevicesByType(AudioDeviceType::CAPTURE);
}
std::vector<std::string>
PortAudioLayer::getPlaybackDeviceList() const
{
- return pimpl_->getDeviceByType(AudioDeviceType::PLAYBACK);
+ return pimpl_->getDevicesByType(AudioDeviceType::PLAYBACK);
}
int
PortAudioLayer::getAudioDeviceIndex(const std::string& name, AudioDeviceType type) const
{
- auto deviceList = pimpl_->getDeviceByType(type);
-
- int numDevices = 0;
- numDevices = deviceList.size();
- if (numDevices < 0) {
- JAMI_ERR("PortAudioLayer error : %s", Pa_GetErrorText(numDevices));
- } else {
- int i = 0;
- for (auto d = deviceList.cbegin(); d != deviceList.cend(); ++d, ++i) {
- if (*d == name) {
- return i;
- }
- }
- }
- return paNoDevice;
+ auto devices = pimpl_->getDevicesByType(type);
+ auto it = std::find_if(devices.cbegin(), devices.cend(), [&name](const auto& deviceName) {
+ return deviceName == name;
+ });
+ return it != devices.end() ? std::distance(devices.cbegin(), it) : -1;
}
std::string
PortAudioLayer::getAudioDeviceName(int index, AudioDeviceType type) const
{
+ (void) index;
(void) type;
- const PaDeviceInfo* deviceInfo;
- deviceInfo = Pa_GetDeviceInfo(index);
- return deviceInfo->name;
+ return {};
}
int
@@ -218,7 +210,7 @@ void
PortAudioLayer::stopStream(AudioDeviceType stream)
{
auto stopPaStream = [](PaStream* stream) -> bool {
- if (!stream)
+ if (!stream || Pa_IsStreamStopped(stream) != paNoError)
return false;
auto err = Pa_StopStream(stream);
if (err != paNoError) {
@@ -287,16 +279,16 @@ PortAudioLayer::stopStream(AudioDeviceType stream)
void
PortAudioLayer::updatePreference(AudioPreference& preference, int index, AudioDeviceType type)
{
- auto internalIndex = pimpl_->getInternalIndexByType(index, type);
+ auto deviceName = pimpl_->getDeviceNameByType(index, type);
switch (type) {
case AudioDeviceType::PLAYBACK:
- preference.setAlsaCardout(internalIndex);
+ preference.setPortAudioDevicePlayback(deviceName);
break;
case AudioDeviceType::CAPTURE:
- preference.setAlsaCardin(internalIndex);
+ preference.setPortAudioDeviceRecord(deviceName);
break;
case AudioDeviceType::RINGTONE:
- preference.setAlsaCardring(internalIndex);
+ preference.setPortAudioDeviceRingtone(deviceName);
break;
default:
break;
@@ -307,10 +299,9 @@ PortAudioLayer::updatePreference(AudioPreference& preference, int index, AudioDe
PortAudioLayer::PortAudioLayerImpl::PortAudioLayerImpl(PortAudioLayer& parent,
const AudioPreference& pref)
- : indexIn_ {pref.getAlsaCardin()}
- , indexOut_ {pref.getAlsaCardout()}
- , indexRing_ {pref.getAlsaCardring()}
- , playbackBuff_ {0, parent.audioFormat_}
+ : deviceRecord_ {pref.getPortAudioDeviceRecord()}
+ , devicePlayback_ {pref.getPortAudioDevicePlayback()}
+ , deviceRingtone_ {pref.getPortAudioDeviceRingtone()}
{
init(parent);
}
@@ -323,91 +314,79 @@ PortAudioLayer::PortAudioLayerImpl::~PortAudioLayerImpl()
void
PortAudioLayer::PortAudioLayerImpl::initInput(PortAudioLayer& parent)
{
- auto numDevices = Pa_GetDeviceCount();
- if (indexIn_ <= paNoDevice || indexIn_ >= numDevices) {
- indexIn_ = Pa_GetDefaultInputDevice();
- }
+ // convert out preference to an api index
+ auto apiIndex = getApiIndexByType(AudioDeviceType::CAPTURE);
- // Pa_GetDefaultInputDevice returned paNoDevice or we already initialized the device
- if (indexIn_ == paNoDevice || inputInitialized_)
+ // Pa_GetDefault[Comm]InputDevice returned paNoDevice or we already initialized the device
+ if (apiIndex == paNoDevice || inputInitialized_)
return;
- if (const auto inputDeviceInfo = Pa_GetDeviceInfo(indexIn_)) {
- if (inputDeviceInfo->maxInputChannels <= 0) {
- indexIn_ = paNoDevice;
- return initInput(parent);
- }
- parent.audioInputFormat_.sample_rate = inputDeviceInfo->defaultSampleRate;
- parent.audioInputFormat_.nb_channels = inputDeviceInfo->maxInputChannels;
- parent.hardwareInputFormatAvailable(parent.audioInputFormat_);
- JAMI_DBG("PortAudioLayer initialized input: %s {%d Hz, %d channels}",
- inputDeviceInfo->name,
- parent.audioInputFormat_.sample_rate,
- parent.audioInputFormat_.nb_channels);
- inputInitialized_ = true;
- } else {
+ const auto inputDeviceInfo = Pa_GetDeviceInfo(apiIndex);
+ if (!inputDeviceInfo) {
+ // this represents complete failure after attempting a fallback to default
JAMI_WARN("PortAudioLayer could not initialize input");
- indexIn_ = paNoDevice;
+ deviceRecord_.clear();
inputInitialized_ = true;
+ return;
+ }
+
+ // if the device index is somehow no longer a device of the correct type, reset the
+ // internal index to paNoDevice and reenter in an attempt to set the default
+ // communications device
+ if (inputDeviceInfo->maxInputChannels <= 0) {
+ JAMI_WARN("PortAudioLayer could not initialize input, falling back to default device");
+ deviceRecord_.clear();
+ return initInput(parent);
}
+
+ // at this point, the device is of the correct type and can be opened
+ parent.audioInputFormat_.sample_rate = inputDeviceInfo->defaultSampleRate;
+ parent.audioInputFormat_.nb_channels = inputDeviceInfo->maxInputChannels;
+ parent.hardwareInputFormatAvailable(parent.audioInputFormat_);
+ JAMI_DBG("PortAudioLayer initialized input: %s {%d Hz, %d channels}",
+ inputDeviceInfo->name,
+ parent.audioInputFormat_.sample_rate,
+ parent.audioInputFormat_.nb_channels);
+ inputInitialized_ = true;
}
void
PortAudioLayer::PortAudioLayerImpl::initOutput(PortAudioLayer& parent)
{
- auto numDevices = Pa_GetDeviceCount();
- if (indexOut_ <= paNoDevice || indexOut_ >= numDevices) {
- indexRing_ = indexOut_ = Pa_GetDefaultOutputDevice();
- } else {
- indexRing_ = indexOut_;
- }
+ // convert out preference to an api index
+ auto apiIndex = getApiIndexByType(AudioDeviceType::PLAYBACK);
- // Pa_GetDefaultOutputDevice returned paNoDevice or we already initialized the device
- if (indexOut_ == paNoDevice || outputInitialized_)
+ // Pa_GetDefault[Comm]OutputDevice returned paNoDevice or we already initialized the device
+ if (apiIndex == paNoDevice || outputInitialized_)
return;
- if (const auto outputDeviceInfo = Pa_GetDeviceInfo(indexOut_)) {
- if (outputDeviceInfo->maxOutputChannels <= 0) {
- indexOut_ = paNoDevice;
- return initOutput(parent);
- }
- parent.audioFormat_.sample_rate = outputDeviceInfo->defaultSampleRate;
- parent.audioFormat_.nb_channels = outputDeviceInfo->maxOutputChannels;
- parent.hardwareFormatAvailable(parent.audioFormat_);
- JAMI_DBG("PortAudioLayer initialized output: %s {%d Hz, %d channels}",
- outputDeviceInfo->name,
- parent.audioFormat_.sample_rate,
- parent.audioFormat_.nb_channels);
- outputInitialized_ = true;
- } else {
+ const auto outputDeviceInfo = Pa_GetDeviceInfo(apiIndex);
+ if (!outputDeviceInfo) {
+ // this represents complete failure after attempting a fallback to default
JAMI_WARN("PortAudioLayer could not initialize output");
- indexOut_ = paNoDevice;
+ devicePlayback_.clear();
outputInitialized_ = true;
+ return;
}
-}
-std::vector<std::string>
-PortAudioLayer::PortAudioLayerImpl::getDeviceByType(AudioDeviceType type) const
-{
- std::vector<std::string> ret;
- int numDevices = 0;
-
- numDevices = Pa_GetDeviceCount();
- if (numDevices < 0)
- JAMI_ERR("PortAudioLayer error : %s", Pa_GetErrorText(numDevices));
- else {
- for (int i = 0; i < numDevices; i++) {
- const auto deviceInfo = Pa_GetDeviceInfo(i);
- if (type == AudioDeviceType::PLAYBACK) {
- if (deviceInfo->maxOutputChannels > 0)
- ret.push_back(deviceInfo->name);
- } else {
- if (deviceInfo->maxInputChannels > 0)
- ret.push_back(deviceInfo->name);
- }
- }
+ // if the device index is somehow no longer a device of the correct type, reset the
+ // internal index to paNoDevice and reenter in an attempt to set the default
+ // communications device
+ if (outputDeviceInfo->maxOutputChannels <= 0) {
+ JAMI_WARN("PortAudioLayer could not initialize output, falling back to default device");
+ devicePlayback_.clear();
+ return initOutput(parent);
}
- return ret;
+
+ // at this point, the device is of the correct type and can be opened
+ parent.audioFormat_.sample_rate = outputDeviceInfo->defaultSampleRate;
+ parent.audioFormat_.nb_channels = outputDeviceInfo->maxOutputChannels;
+ parent.hardwareFormatAvailable(parent.audioFormat_);
+ JAMI_DBG("PortAudioLayer initialized output: %s {%d Hz, %d channels}",
+ outputDeviceInfo->name,
+ parent.audioFormat_.sample_rate,
+ parent.audioFormat_.nb_channels);
+ outputInitialized_ = true;
}
void
@@ -432,52 +411,101 @@ PortAudioLayer::PortAudioLayerImpl::init(PortAudioLayer& parent)
std::fill(std::begin(streams_), std::end(streams_), nullptr);
}
+std::vector<std::string>
+PortAudioLayer::PortAudioLayerImpl::getDevicesByType(AudioDeviceType type) const
+{
+ std::vector<std::string> devices;
+ auto numDevices = Pa_GetDeviceCount();
+ if (numDevices < 0)
+ JAMI_ERR("PortAudioLayer error : %s", Pa_GetErrorText(numDevices));
+ else {
+ for (int i = 0; i < numDevices; i++) {
+ const auto deviceInfo = Pa_GetDeviceInfo(i);
+ if (type == AudioDeviceType::CAPTURE) {
+ if (deviceInfo->maxInputChannels > 0)
+ devices.push_back(deviceInfo->name);
+ } else if (deviceInfo->maxOutputChannels > 0)
+ devices.push_back(deviceInfo->name);
+ }
+ // add the default device aliases if requested and if there are any devices of this type
+ if (!devices.empty()) {
+ // default comm (index:0)
+ auto defaultDeviceName = getApiDefaultDeviceName(type, true);
+ devices.insert(devices.begin(), "{{Default}} - " + defaultDeviceName);
+ }
+ }
+ return devices;
+}
+
int
PortAudioLayer::PortAudioLayerImpl::getIndexByType(AudioDeviceType type)
{
- int index = indexRing_;
- if (type == AudioDeviceType::PLAYBACK) {
- index = indexOut_;
- } else if (type == AudioDeviceType::CAPTURE) {
- index = indexIn_;
+ auto devices = getDevicesByType(type);
+ if (!devices.size()) {
+ return 0;
}
+ std::string_view toMatch = (type == AudioDeviceType::CAPTURE
+ ? deviceRecord_
+ : (type == AudioDeviceType::PLAYBACK ? devicePlayback_
+ : deviceRingtone_));
+ auto it = std::find_if(devices.cbegin(), devices.cend(), [&toMatch](const auto& deviceName) {
+ return deviceName == toMatch;
+ });
+ return it != devices.end() ? std::distance(devices.cbegin(), it) : 0;
+}
- auto deviceList = getDeviceByType(type);
- if (!deviceList.size()) {
- return paNoDevice;
- }
+std::string
+PortAudioLayer::PortAudioLayerImpl::getDeviceNameByType(const int index, AudioDeviceType type)
+{
+ if (index == defaultIndex_)
+ return {};
- const PaDeviceInfo* indexedDeviceInfo;
- indexedDeviceInfo = Pa_GetDeviceInfo(index);
- if (!indexedDeviceInfo) {
- return paNoDevice;
- }
+ auto devices = getDevicesByType(type);
+ if (!devices.size() || index >= devices.size())
+ return {};
+
+ return devices.at(index);
+}
- for (int i = 0; i < deviceList.size(); ++i) {
- if (deviceList.at(i) == indexedDeviceInfo->name) {
- return i;
+PaDeviceIndex
+PortAudioLayer::PortAudioLayerImpl::getApiIndexByType(AudioDeviceType type)
+{
+ auto numDevices = Pa_GetDeviceCount();
+ if (numDevices < 0)
+ JAMI_ERR("PortAudioLayer error : %s", Pa_GetErrorText(numDevices));
+ else {
+ std::string_view toMatch = (type == AudioDeviceType::CAPTURE
+ ? deviceRecord_
+ : (type == AudioDeviceType::PLAYBACK ? devicePlayback_
+ : deviceRingtone_));
+ if (toMatch.empty())
+ return type == AudioDeviceType::CAPTURE ? Pa_GetDefaultCommInputDevice()
+ : Pa_GetDefaultCommOutputDevice();
+ for (int i = 0; i < numDevices; ++i) {
+ if (const auto deviceInfo = Pa_GetDeviceInfo(i)) {
+ if (deviceInfo->name == toMatch)
+ return i;
+ }
}
}
-
return paNoDevice;
}
-int
-PortAudioLayer::PortAudioLayerImpl::getInternalIndexByType(const int index, AudioDeviceType type)
+std::string
+PortAudioLayer::PortAudioLayerImpl::getApiDefaultDeviceName(AudioDeviceType type,
+ bool commDevice) const
{
- auto deviceList = getDeviceByType(type);
- if (!deviceList.size() || index >= deviceList.size()) {
- return paNoDevice;
+ std::string deviceName {};
+ PaDeviceIndex deviceIndex {paNoDevice};
+ if (type == AudioDeviceType::CAPTURE) {
+ deviceIndex = commDevice ? Pa_GetDefaultCommInputDevice() : Pa_GetDefaultInputDevice();
+ } else {
+ deviceIndex = commDevice ? Pa_GetDefaultCommOutputDevice() : Pa_GetDefaultOutputDevice();
}
-
- for (int i = 0; i < Pa_GetDeviceCount(); i++) {
- const auto deviceInfo = Pa_GetDeviceInfo(i);
- if (deviceList.at(index) == deviceInfo->name) {
- return i;
- }
+ if (const auto deviceInfo = Pa_GetDeviceInfo(deviceIndex)) {
+ deviceName = deviceInfo->name;
}
-
- return paNoDevice;
+ return deviceName;
}
void
@@ -563,10 +591,11 @@ PortAudioLayer::PortAudioLayerImpl::initInputStream(PortAudioLayer& parent)
{
JAMI_DBG("Open PortAudio Input Stream");
auto& stream = streams_[Direction::Input];
- if (indexIn_ != paNoDevice) {
+ auto apiIndex = getApiIndexByType(AudioDeviceType::CAPTURE);
+ if (apiIndex != paNoDevice) {
openStreamDevice(
&streams_[Direction::Input],
- indexIn_,
+ apiIndex,
Direction::Input,
[](const void* inputBuffer,
void* outputBuffer,
@@ -604,10 +633,11 @@ PortAudioLayer::PortAudioLayerImpl::initOutputStream(PortAudioLayer& parent)
{
JAMI_DBG("Open PortAudio Output Stream");
auto& stream = streams_[Direction::Output];
- if (indexOut_ != paNoDevice) {
+ auto apiIndex = getApiIndexByType(AudioDeviceType::PLAYBACK);
+ if (apiIndex != paNoDevice) {
openStreamDevice(
&stream,
- indexOut_,
+ apiIndex,
Direction::Output,
[](const void* inputBuffer,
void* outputBuffer,
@@ -643,7 +673,9 @@ PortAudioLayer::PortAudioLayerImpl::initOutputStream(PortAudioLayer& parent)
bool
PortAudioLayer::PortAudioLayerImpl::initFullDuplexStream(PortAudioLayer& parent)
{
- if (indexOut_ == paNoDevice || indexIn_ == paNoDevice) {
+ auto apiIndexRecord = getApiIndexByType(AudioDeviceType::CAPTURE);
+ auto apiIndexPlayback = getApiIndexByType(AudioDeviceType::PLAYBACK);
+ if (apiIndexRecord == paNoDevice || apiIndexPlayback == paNoDevice) {
JAMI_ERR("Error: Invalid input/output devices. There will be no audio.");
return false;
}
@@ -654,8 +686,8 @@ PortAudioLayer::PortAudioLayerImpl::initFullDuplexStream(PortAudioLayer& parent)
auto& stream = streams_[Direction::IO];
openFullDuplexStream(
&stream,
- indexIn_,
- indexOut_,
+ apiIndexRecord,
+ apiIndexPlayback,
[](const void* inputBuffer,
void* outputBuffer,
unsigned long framesPerBuffer,
diff --git a/src/preferences.cpp b/src/preferences.cpp
index 975cd418d6..d122b1563a 100644
--- a/src/preferences.cpp
+++ b/src/preferences.cpp
@@ -104,6 +104,7 @@ static constexpr const char* ZID_FILE_KEY {"zidFile"};
constexpr const char* const AudioPreference::CONFIG_LABEL;
static constexpr const char* ALSAMAP_KEY {"alsa"};
static constexpr const char* PULSEMAP_KEY {"pulse"};
+static constexpr const char* PORTAUDIO_KEY {"portaudio"};
static constexpr const char* CARDIN_KEY {"cardIn"};
static constexpr const char* CARDOUT_KEY {"cardOut"};
static constexpr const char* CARDRING_KEY {"cardRing"};
@@ -446,6 +447,13 @@ AudioPreference::serialize(YAML::Emitter& out) const
out << YAML::Key << DEVICE_RINGTONE_KEY << YAML::Value << pulseDeviceRingtone_;
out << YAML::EndMap;
+ // portaudio submap
+ out << YAML::Key << PORTAUDIO_KEY << YAML::Value << YAML::BeginMap;
+ out << YAML::Key << DEVICE_PLAYBACK_KEY << YAML::Value << portaudioDevicePlayback_;
+ out << YAML::Key << DEVICE_RECORD_KEY << YAML::Value << portaudioDeviceRecord_;
+ out << YAML::Key << DEVICE_RINGTONE_KEY << YAML::Value << portaudioDeviceRingtone_;
+ out << YAML::EndMap;
+
// more common options!
out << YAML::Key << RECORDPATH_KEY << YAML::Value << recordpath_;
out << YAML::Key << VOLUMEMIC_KEY << YAML::Value << volumemic_;
@@ -495,6 +503,12 @@ AudioPreference::unserialize(const YAML::Node& in)
parseValue(pulse, DEVICE_RECORD_KEY, pulseDeviceRecord_);
parseValue(pulse, DEVICE_RINGTONE_KEY, pulseDeviceRingtone_);
+ // portaudio submap
+ const auto& portaudio = node[PORTAUDIO_KEY];
+ parseValue(portaudio, DEVICE_PLAYBACK_KEY, portaudioDevicePlayback_);
+ parseValue(portaudio, DEVICE_RECORD_KEY, portaudioDeviceRecord_);
+ parseValue(portaudio, DEVICE_RINGTONE_KEY, portaudioDeviceRingtone_);
+
// more common options!
parseValue(node, RECORDPATH_KEY, recordpath_);
parseValue(node, VOLUMEMIC_KEY, volumemic_);
diff --git a/src/preferences.h b/src/preferences.h
index afec033475..97da4e697b 100644
--- a/src/preferences.h
+++ b/src/preferences.h
@@ -152,7 +152,6 @@ class AudioPreference : public Serializable
public:
AudioPreference();
AudioLayer* createAudioLayer();
- AudioLayer* switchAndCreateAudioLayer();
static std::vector<std::string> getSupportedAudioManagers();
@@ -161,10 +160,12 @@ public:
void setAudioApi(const std::string& api) { audioApi_ = api; }
void serialize(YAML::Emitter& out) const override;
+
void unserialize(const YAML::Node& in) override;
// alsa preference
int getAlsaCardin() const { return alsaCardin_; }
+
void setAlsaCardin(int c) { alsaCardin_ = c; }
int getAlsaCardout() const { return alsaCardout_; }
@@ -180,6 +181,7 @@ public:
void setAlsaPlugin(const std::string& p) { alsaPlugin_ = p; }
int getAlsaSmplrate() const { return alsaSmplrate_; }
+
void setAlsaSmplrate(int r) { alsaSmplrate_ = r; }
// pulseaudio preference
@@ -194,6 +196,19 @@ public:
void setPulseDeviceRingtone(const std::string& r) { pulseDeviceRingtone_ = r; }
+ // portaudio preference
+ const std::string& getPortAudioDevicePlayback() const { return portaudioDevicePlayback_; }
+
+ void setPortAudioDevicePlayback(const std::string& p) { portaudioDevicePlayback_ = p; }
+
+ const std::string& getPortAudioDeviceRecord() const { return portaudioDeviceRecord_; }
+
+ void setPortAudioDeviceRecord(const std::string& r) { portaudioDeviceRecord_ = r; }
+
+ const std::string& getPortAudioDeviceRingtone() const { return portaudioDeviceRingtone_; }
+
+ void setPortAudioDeviceRingtone(const std::string& r) { portaudioDeviceRingtone_ = r; }
+
// general preference
const std::string& getRecordPath() const { return recordpath_; }
@@ -245,6 +260,11 @@ private:
std::string pulseDeviceRecord_;
std::string pulseDeviceRingtone_;
+ // portaudio preference
+ std::string portaudioDevicePlayback_;
+ std::string portaudioDeviceRecord_;
+ std::string portaudioDeviceRingtone_;
+
// general preference
std::string recordpath_; //: /home/msavard/Bureau
bool alwaysRecording_;
--
GitLab