318 lines
7.7 KiB
C++
318 lines
7.7 KiB
C++
#include <grabber/AudioGrabberLinux.h>
|
|
|
|
#include <alsa/asoundlib.h>
|
|
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
|
|
typedef void* (*THREADFUNCPTR)(void*);
|
|
|
|
AudioGrabberLinux::AudioGrabberLinux()
|
|
: AudioGrabber()
|
|
, _isRunning{ false }
|
|
, _captureDevice {nullptr}
|
|
, _sampleRate(44100)
|
|
{
|
|
}
|
|
|
|
AudioGrabberLinux::~AudioGrabberLinux()
|
|
{
|
|
this->stop();
|
|
}
|
|
|
|
void AudioGrabberLinux::refreshDevices()
|
|
{
|
|
Debug(_log, "Enumerating Audio Input Devices");
|
|
|
|
_deviceProperties.clear();
|
|
|
|
snd_ctl_t* deviceHandle;
|
|
int soundCard {-1};
|
|
int error {-1};
|
|
int cardInput {-1};
|
|
|
|
snd_ctl_card_info_t* cardInfo;
|
|
snd_pcm_info_t* deviceInfo;
|
|
|
|
snd_ctl_card_info_alloca(&cardInfo);
|
|
snd_pcm_info_alloca(&deviceInfo);
|
|
|
|
while (snd_card_next(&soundCard) > -1)
|
|
{
|
|
if (soundCard < 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
char cardId[32];
|
|
sprintf(cardId, "hw:%d", soundCard);
|
|
|
|
if ((error = snd_ctl_open(&deviceHandle, cardId, SND_CTL_NONBLOCK)) < 0)
|
|
{
|
|
Error(_log, "Erorr opening device: (%i): %s", soundCard, snd_strerror(error));
|
|
continue;
|
|
}
|
|
|
|
if ((error = snd_ctl_card_info(deviceHandle, cardInfo)) < 0)
|
|
{
|
|
Error(_log, "Erorr getting hardware info: (%i): %s", soundCard, snd_strerror(error));
|
|
snd_ctl_close(deviceHandle);
|
|
continue;
|
|
}
|
|
|
|
cardInput = -1;
|
|
|
|
while (true)
|
|
{
|
|
if (snd_ctl_pcm_next_device(deviceHandle, &cardInput) < 0)
|
|
Error(_log, "Error selecting device input");
|
|
|
|
if (cardInput < 0)
|
|
break;
|
|
|
|
snd_pcm_info_set_device(deviceInfo, static_cast<uint>(cardInput));
|
|
snd_pcm_info_set_subdevice(deviceInfo, 0);
|
|
snd_pcm_info_set_stream(deviceInfo, SND_PCM_STREAM_CAPTURE);
|
|
|
|
if ((error = snd_ctl_pcm_info(deviceHandle, deviceInfo)) < 0)
|
|
{
|
|
if (error != -ENOENT)
|
|
Error(_log, "Digital Audio Info: (%i): %s", soundCard, snd_strerror(error));
|
|
|
|
continue;
|
|
}
|
|
|
|
AudioGrabber::DeviceProperties device;
|
|
|
|
device.id = QString("hw:%1,%2").arg(snd_pcm_info_get_card(deviceInfo)).arg(snd_pcm_info_get_device(deviceInfo));
|
|
device.name = QString("%1: %2").arg(snd_ctl_card_info_get_name(cardInfo),snd_pcm_info_get_name(deviceInfo));
|
|
|
|
Debug(_log, "Found sound card (%s): %s", QSTRING_CSTR(device.id), QSTRING_CSTR(device.name));
|
|
|
|
_deviceProperties.insert(device.id, device);
|
|
}
|
|
|
|
snd_ctl_close(deviceHandle);
|
|
}
|
|
}
|
|
|
|
bool AudioGrabberLinux::configureCaptureInterface()
|
|
{
|
|
int error = -1;
|
|
QString name = (_device.isEmpty() || _device == "auto") ? "default" : (_device);
|
|
|
|
if ((error = snd_pcm_open(&_captureDevice, QSTRING_CSTR(name) , SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0)
|
|
{
|
|
Error(_log, "Failed to open audio device: %s, - %s", QSTRING_CSTR(_device), snd_strerror(error));
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_hw_params_malloc(&_captureDeviceConfig)) < 0)
|
|
{
|
|
Error(_log, "Failed to create hardware parameters: %s", snd_strerror(error));
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_hw_params_any(_captureDevice, _captureDeviceConfig)) < 0)
|
|
{
|
|
Error(_log, "Failed to initialize hardware parameters: %s", snd_strerror(error));
|
|
snd_pcm_hw_params_free(_captureDeviceConfig);
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_hw_params_set_access(_captureDevice, _captureDeviceConfig, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
|
|
{
|
|
Error(_log, "Failed to configure interleaved mode: %s", snd_strerror(error));
|
|
snd_pcm_hw_params_free(_captureDeviceConfig);
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_hw_params_set_format(_captureDevice, _captureDeviceConfig, SND_PCM_FORMAT_S16_LE)) < 0)
|
|
{
|
|
Error(_log, "Failed to configure capture format: %s", snd_strerror(error));
|
|
snd_pcm_hw_params_free(_captureDeviceConfig);
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_hw_params_set_rate_near(_captureDevice, _captureDeviceConfig, &_sampleRate, nullptr)) < 0)
|
|
{
|
|
Error(_log, "Failed to configure sample rate: %s", snd_strerror(error));
|
|
snd_pcm_hw_params_free(_captureDeviceConfig);
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_hw_params(_captureDevice, _captureDeviceConfig)) < 0)
|
|
{
|
|
Error(_log, "Failed to configure hardware parameters: %s", snd_strerror(error));
|
|
snd_pcm_hw_params_free(_captureDeviceConfig);
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
snd_pcm_hw_params_free(_captureDeviceConfig);
|
|
|
|
if ((error = snd_pcm_prepare(_captureDevice)) < 0)
|
|
{
|
|
Error(_log, "Failed to prepare audio interface: %s", snd_strerror(error));
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
if ((error = snd_pcm_start(_captureDevice)) < 0)
|
|
{
|
|
Error(_log, "Failed to start audio interface: %s", snd_strerror(error));
|
|
snd_pcm_close(_captureDevice);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AudioGrabberLinux::start()
|
|
{
|
|
if (!_isEnabled)
|
|
return false;
|
|
|
|
if (_isRunning.load(std::memory_order_acquire))
|
|
return true;
|
|
|
|
Debug(_log, "Start Audio With %s", QSTRING_CSTR(getDeviceName(_device)));
|
|
|
|
if (!configureCaptureInterface())
|
|
return false;
|
|
|
|
_isRunning.store(true, std::memory_order_release);
|
|
|
|
pthread_attr_t threadAttributes;
|
|
int threadPriority = 1;
|
|
|
|
sched_param schedulerParameter;
|
|
schedulerParameter.sched_priority = threadPriority;
|
|
|
|
if (pthread_attr_init(&threadAttributes) != 0)
|
|
{
|
|
Debug(_log, "Failed to create thread attributes");
|
|
stop();
|
|
return false;
|
|
}
|
|
|
|
if (pthread_create(&_audioThread, &threadAttributes, static_cast<THREADFUNCPTR>(&AudioThreadRunner), static_cast<void*>(this)) != 0)
|
|
{
|
|
Debug(_log, "Failed to create audio capture thread");
|
|
stop();
|
|
return false;
|
|
}
|
|
|
|
AudioGrabber::start();
|
|
|
|
return true;
|
|
}
|
|
|
|
void AudioGrabberLinux::stop()
|
|
{
|
|
if (!_isRunning.load(std::memory_order_acquire))
|
|
return;
|
|
|
|
Debug(_log, "Stopping Audio Interface");
|
|
|
|
_isRunning.store(false, std::memory_order_release);
|
|
|
|
if (_audioThread != 0) {
|
|
pthread_join(_audioThread, NULL);
|
|
}
|
|
|
|
snd_pcm_close(_captureDevice);
|
|
|
|
AudioGrabber::stop();
|
|
}
|
|
|
|
void AudioGrabberLinux::processAudioBuffer(snd_pcm_sframes_t frames)
|
|
{
|
|
if (!_isRunning.load(std::memory_order_acquire))
|
|
return;
|
|
|
|
ssize_t bytes = snd_pcm_frames_to_bytes(_captureDevice, frames);
|
|
|
|
int16_t * buffer = static_cast<int16_t*>(calloc(static_cast<size_t>(bytes / 2), sizeof(int16_t)));
|
|
|
|
if (frames == 0)
|
|
{
|
|
buffer[0] = 0;
|
|
processAudioFrame(buffer, 1);
|
|
}
|
|
else
|
|
{
|
|
snd_pcm_sframes_t framesRead = snd_pcm_readi(_captureDevice, buffer, static_cast<snd_pcm_uframes_t>(frames));
|
|
|
|
if (framesRead < frames)
|
|
{
|
|
Error(_log, "Error reading audio. Got %d frames instead of %d", framesRead, frames);
|
|
}
|
|
else
|
|
{
|
|
processAudioFrame(buffer, static_cast<int>(snd_pcm_frames_to_bytes(_captureDevice, framesRead)) / 2);
|
|
}
|
|
}
|
|
|
|
free(buffer);
|
|
}
|
|
|
|
QJsonArray AudioGrabberLinux::discover(const QJsonObject& /*params*/)
|
|
{
|
|
refreshDevices();
|
|
|
|
QJsonArray devices;
|
|
|
|
for (auto deviceIterator = _deviceProperties.begin(); deviceIterator != _deviceProperties.end(); ++deviceIterator)
|
|
{
|
|
// Device
|
|
QJsonObject device;
|
|
QJsonArray deviceInputs;
|
|
|
|
device["device"] = deviceIterator.key();
|
|
device["device_name"] = deviceIterator.value().name;
|
|
device["type"] = "audio";
|
|
|
|
devices.append(device);
|
|
}
|
|
|
|
return devices;
|
|
}
|
|
|
|
QString AudioGrabberLinux::getDeviceName(const QString& devicePath) const
|
|
{
|
|
if (devicePath.isEmpty() || devicePath == "auto")
|
|
{
|
|
return "Default Audio Device";
|
|
}
|
|
|
|
return _deviceProperties.value(devicePath).name;
|
|
}
|
|
|
|
static void * AudioThreadRunner(void* params)
|
|
{
|
|
AudioGrabberLinux* This = static_cast<AudioGrabberLinux*>(params);
|
|
|
|
Debug(This->getLog(), "Audio Thread Started");
|
|
|
|
snd_pcm_sframes_t framesAvailable = 0;
|
|
|
|
while (This->_isRunning.load(std::memory_order_acquire))
|
|
{
|
|
snd_pcm_wait(This->_captureDevice, 1000);
|
|
|
|
if ((framesAvailable = snd_pcm_avail(This->_captureDevice)) > 0)
|
|
This->processAudioBuffer(framesAvailable);
|
|
|
|
sched_yield();
|
|
}
|
|
|
|
Debug(This->getLog(), "Audio Thread Shutting Down");
|
|
return nullptr;
|
|
}
|