hashtags/lmms
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

soundio backend: use lmms code style conventions

Browse Source
This commit is contained in:
Andrew Kelley
2015-09-13 18:12:21 -07:00
parent f7e5bf4860
commit e7af4b6f3e
3 changed files with 377 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
include/AudioSoundIo.h
View File

@@ -43,93 +43,89 @@ class LcdSpinBox;
// Exists only to work around "Error: Meta object features not supported for nested classes"
class AudioSoundIoSetupUtil : public QObject
{
Q_OBJECT
Q_OBJECT
public:
void *m_setupWidget;
void *m_setupWidget;
public slots:
void updateDevices();
void reconnectSoundIo();
void updateDevices();
void reconnectSoundIo();
};
class AudioSoundIo : public AudioDevice
{
public:
AudioSoundIo( bool & _success_ful, Mixer* mixer );
virtual ~AudioSoundIo();
AudioSoundIo( bool & _success_ful, Mixer* mixer );
virtual ~AudioSoundIo();
inline static QString name()
{
return QT_TRANSLATE_NOOP( "setupWidget", "soundio" );
}
inline static QString name()
{
return QT_TRANSLATE_NOOP( "setupWidget", "soundio" );
}
class setupWidget : public AudioDeviceSetupWidget
{
public:
setupWidget( QWidget * _parent );
virtual ~setupWidget();
int process_callback( const float *_inputBuffer,
float * _outputBuffer,
unsigned long _framesPerBuffer );
virtual void saveSettings();
void updateDevices();
void reconnectSoundIo();
class setupWidget : public AudioDeviceSetupWidget
{
public:
setupWidget( QWidget * _parent );
virtual ~setupWidget();
private:
virtual void saveSettings();
AudioSoundIoSetupUtil m_setupUtil;
ComboBox * m_backend;
ComboBox * m_device;
void updateDevices();
void reconnectSoundIo();
ComboBoxModel m_backendModel;
ComboBoxModel m_deviceModel;
AudioSoundIoSetupUtil m_setupUtil;
ComboBox * m_backend;
ComboBox * m_device;
SoundIo * m_soundio;
ComboBoxModel m_backendModel;
ComboBoxModel m_deviceModel;
struct DeviceId {
QString id;
bool is_raw;
};
QList<DeviceId> m_deviceList;
SoundIo * m_soundio;
int m_defaultOutIndex;
bool m_isFirst;
struct DeviceId {
QString id;
bool is_raw;
};
QList<DeviceId> m_device_list;
int m_default_out_index;
bool m_is_first;
} ;
} ;
private:
virtual void startProcessing();
virtual void stopProcessing();
virtual void startProcessing();
virtual void stopProcessing();
SoundIo *m_soundio;
SoundIoOutStream *m_outstream;
SoundIo *m_soundio;
SoundIoOutStream *m_outstream;
surroundSampleFrame * m_outBuf;
int m_outBufSize;
fpp_t m_outBufFramesTotal;
fpp_t m_outBufFrameIndex;
surroundSampleFrame * m_outBuf;
int m_outBufSize;
fpp_t m_outBufFramesTotal;
fpp_t m_outBufFrameIndex;
int m_disconnect_err;
void on_backend_disconnect(int err);
int m_disconnectErr;
void onBackendDisconnect(int err);
void write_callback(int frame_count_min, int frame_count_max);
void error_callback(int err);
void underflow_callback();
void writeCallback(int frame_count_min, int frame_count_max);
void errorCallback(int err);
void underflowCallback();
static void static_write_callback(SoundIoOutStream *outstream, int frame_count_min, int frame_count_max) {
return ((AudioSoundIo *)outstream->userdata)->write_callback(frame_count_min, frame_count_max);
}
static void static_error_callback(SoundIoOutStream *outstream, int err) {
return ((AudioSoundIo *)outstream->userdata)->error_callback(err);
}
static void static_underflow_callback(SoundIoOutStream *outstream) {
return ((AudioSoundIo *)outstream->userdata)->underflow_callback();
}
static void static_on_backend_disconnect(SoundIo *soundio, int err) {
return ((AudioSoundIo *)soundio->userdata)->on_backend_disconnect(err);
}
static void staticWriteCallback(SoundIoOutStream *outstream, int frame_count_min, int frame_count_max) {
return ((AudioSoundIo *)outstream->userdata)->writeCallback(frame_count_min, frame_count_max);
}
static void staticErrorCallback(SoundIoOutStream *outstream, int err) {
return ((AudioSoundIo *)outstream->userdata)->errorCallback(err);
}
static void staticUnderflowCallback(SoundIoOutStream *outstream) {
return ((AudioSoundIo *)outstream->userdata)->underflowCallback();
}
static void staticOnBackendDisconnect(SoundIo *soundio, int err) {
return ((AudioSoundIo *)soundio->userdata)->onBackendDisconnect(err);
}
};

2
src/core/CMakeLists.txt
View File

@@ -72,7 +72,7 @@ set(LMMS_SRCS
core/audio/AudioOss.cpp
core/audio/AudioPort.cpp
core/audio/AudioPortAudio.cpp
core/audio/AudioSoundIo.cpp
core/audio/AudioSoundIo.cpp
core/audio/AudioPulseAudio.cpp
core/audio/AudioSampleRecorder.cpp
core/audio/AudioSdl.cpp

588
src/core/audio/AudioSoundIo.cpp
View File

@@ -37,369 +37,417 @@
#include "ComboBox.h"
#include "LcdSpinBox.h"
AudioSoundIo::AudioSoundIo( bool & out_successful, Mixer * _mixer ) :
AudioDevice( tLimit<ch_cnt_t>(
ConfigManager::inst()->value( "audiosoundio", "channels" ).toInt(), DEFAULT_CHANNELS, SURROUND_CHANNELS ),
_mixer )
AudioSoundIo::AudioSoundIo( bool & outSuccessful, Mixer * _mixer ) :
AudioDevice( tLimit<ch_cnt_t>(
ConfigManager::inst()->value( "audiosoundio", "channels" ).toInt(), DEFAULT_CHANNELS, SURROUND_CHANNELS ),
_mixer )
{
out_successful = false;
m_soundio = NULL;
m_outstream = NULL;
m_disconnect_err = 0;
m_outBufFrameIndex = 0;
m_outBufFramesTotal = 0;
outSuccessful = false;
m_soundio = NULL;
m_outstream = NULL;
m_disconnectErr = 0;
m_outBufFrameIndex = 0;
m_outBufFramesTotal = 0;
m_soundio = soundio_create();
if (!m_soundio) {
fprintf(stderr, "Unable to initialize soundio: out of memory\n");
return;
}
m_soundio = soundio_create();
if (!m_soundio)
{
fprintf(stderr, "Unable to initialize soundio: out of memory\n");
return;
}
m_soundio->app_name = "LMMS";
m_soundio->userdata = this;
m_soundio->on_backend_disconnect = static_on_backend_disconnect;
m_soundio->app_name = "LMMS";
m_soundio->userdata = this;
m_soundio->on_backend_disconnect = staticOnBackendDisconnect;
const QString& config_backend = ConfigManager::inst()->value( "audiosoundio", "backend" );
const QString& config_device_id = ConfigManager::inst()->value( "audiosoundio", "out_device_id" );
const QString& config_device_raw = ConfigManager::inst()->value( "audiosoundio", "out_device_raw" );
const QString& configBackend = ConfigManager::inst()->value( "audiosoundio", "backend" );
const QString& configDeviceId = ConfigManager::inst()->value( "audiosoundio", "out_device_id" );
const QString& configDeviceRaw = ConfigManager::inst()->value( "audiosoundio", "out_device_raw" );
int err;
int out_device_count = 0;
int backend_count = soundio_backend_count(m_soundio);
for (int i = 0; i < backend_count; i += 1) {
SoundIoBackend backend = soundio_get_backend(m_soundio, i);
if (config_backend == soundio_backend_name(backend)) {
if ((err = soundio_connect_backend(m_soundio, backend))) {
// error occurred, leave out_device_count 0
} else {
soundio_flush_events(m_soundio);
if (m_disconnect_err) {
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(m_disconnect_err));
return;
}
out_device_count = soundio_output_device_count(m_soundio);
}
break;
}
}
int err;
int outDeviceCount = 0;
int backendCount = soundio_backend_count(m_soundio);
for (int i = 0; i < backendCount; i += 1)
{
SoundIoBackend backend = soundio_get_backend(m_soundio, i);
if (configBackend == soundio_backend_name(backend))
{
if ((err = soundio_connect_backend(m_soundio, backend)))
{
// error occurred, leave outDeviceCount 0
}
else
{
soundio_flush_events(m_soundio);
if (m_disconnectErr)
{
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(m_disconnectErr));
return;
}
outDeviceCount = soundio_output_device_count(m_soundio);
}
break;
}
}
if (out_device_count <= 0) {
// try connecting to the default backend
if ((err = soundio_connect(m_soundio))) {
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(err));
return;
}
if (outDeviceCount <= 0)
{
// try connecting to the default backend
if ((err = soundio_connect(m_soundio)))
{
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(err));
return;
}
soundio_flush_events(m_soundio);
if (m_disconnect_err) {
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(m_disconnect_err));
return;
}
soundio_flush_events(m_soundio);
if (m_disconnectErr)
{
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(m_disconnectErr));
return;
}
out_device_count = soundio_output_device_count(m_soundio);
outDeviceCount = soundio_output_device_count(m_soundio);
if (out_device_count <= 0) {
fprintf(stderr, "Unable to initialize soundio: no devices found\n");
return;
}
}
if (outDeviceCount <= 0)
{
fprintf(stderr, "Unable to initialize soundio: no devices found\n");
return;
}
}
int selected_device_index = soundio_default_output_device_index(m_soundio);
int selected_device_index = soundio_default_output_device_index(m_soundio);
bool want_raw = (config_device_raw == "yes");
for (int i = 0; i < out_device_count; i += 1) {
SoundIoDevice *device = soundio_get_output_device(m_soundio, i);
bool is_this_one = (config_device_id == device->id && want_raw == device->is_raw);
soundio_device_unref(device);
if (is_this_one) {
selected_device_index = i;
break;
}
}
bool wantRaw = (configDeviceRaw == "yes");
for (int i = 0; i < outDeviceCount; i += 1)
{
SoundIoDevice *device = soundio_get_output_device(m_soundio, i);
bool isThisOne = (configDeviceId == device->id && wantRaw == device->is_raw);
soundio_device_unref(device);
if (isThisOne)
{
selected_device_index = i;
break;
}
}
SoundIoDevice *device = soundio_get_output_device(m_soundio, selected_device_index);
m_outstream = soundio_outstream_create(device);
soundio_device_unref(device);
SoundIoDevice *device = soundio_get_output_device(m_soundio, selected_device_index);
m_outstream = soundio_outstream_create(device);
soundio_device_unref(device);
if (!m_outstream) {
fprintf(stderr, "Unable to initialize soundio: out of memory\n");
return;
}
if (!m_outstream)
{
fprintf(stderr, "Unable to initialize soundio: out of memory\n");
return;
}
int current_sample_rate = sampleRate();
int closest_supported_sample_rate = -1;
int currentSampleRate = sampleRate();
int closestSupportedSampleRate = -1;
for (int i = 0; i < device->sample_rate_count; i += 1) {
SoundIoSampleRateRange *range = &device->sample_rates[i];
if (range->min <= current_sample_rate && current_sample_rate <= range->max) {
closest_supported_sample_rate = current_sample_rate;
break;
}
if (closest_supported_sample_rate == -1 ||
abs(range->max - current_sample_rate) < abs(closest_supported_sample_rate - current_sample_rate))
{
closest_supported_sample_rate = range->max;
}
}
for (int i = 0; i < device->sample_rate_count; i += 1)
{
SoundIoSampleRateRange *range = &device->sample_rates[i];
if (range->min <= currentSampleRate && currentSampleRate <= range->max)
{
closestSupportedSampleRate = currentSampleRate;
break;
}
if (closestSupportedSampleRate == -1 ||
abs(range->max - currentSampleRate) < abs(closestSupportedSampleRate - currentSampleRate))
{
closestSupportedSampleRate = range->max;
}
}
if (closest_supported_sample_rate != current_sample_rate) {
setSampleRate(closest_supported_sample_rate);
current_sample_rate = closest_supported_sample_rate;
}
if (closestSupportedSampleRate != currentSampleRate)
{
setSampleRate(closestSupportedSampleRate);
currentSampleRate = closestSupportedSampleRate;
}
m_outstream->name = "LMMS";
m_outstream->software_latency = (double)mixer()->framesPerPeriod() / (double)current_sample_rate;
m_outstream->userdata = this;
m_outstream->write_callback = static_write_callback;
m_outstream->error_callback = static_error_callback;
m_outstream->underflow_callback = static_underflow_callback;
m_outstream->sample_rate = current_sample_rate;
m_outstream->layout = *soundio_channel_layout_get_default(channels());
m_outstream->format = SoundIoFormatFloat32NE;
m_outstream->name = "LMMS";
m_outstream->software_latency = (double)mixer()->framesPerPeriod() / (double)currentSampleRate;
m_outstream->userdata = this;
m_outstream->write_callback = staticWriteCallback;
m_outstream->error_callback = staticErrorCallback;
m_outstream->underflow_callback = staticUnderflowCallback;
m_outstream->sample_rate = currentSampleRate;
m_outstream->layout = *soundio_channel_layout_get_default(channels());
m_outstream->format = SoundIoFormatFloat32NE;
if ((err = soundio_outstream_open(m_outstream))) {
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(err));
return;
}
if ((err = soundio_outstream_open(m_outstream)))
{
fprintf(stderr, "Unable to initialize soundio: %s\n", soundio_strerror(err));
return;
}
fprintf(stderr, "Output device: '%s' backend: '%s'\n",
device->name, soundio_backend_name(m_soundio->current_backend));
fprintf(stderr, "Output device: '%s' backend: '%s'\n",
device->name, soundio_backend_name(m_soundio->current_backend));
out_successful = true;
outSuccessful = true;
}
void AudioSoundIo::on_backend_disconnect(int err) {
m_disconnect_err = err;
void AudioSoundIo::onBackendDisconnect(int err)
{
m_disconnectErr = err;
}
AudioSoundIo::~AudioSoundIo()
{
stopProcessing();
soundio_destroy(m_soundio);
stopProcessing();
soundio_destroy(m_soundio);
}
void AudioSoundIo::startProcessing()
{
m_outBufFrameIndex = 0;
m_outBufFramesTotal = 0;
m_outBufSize = mixer()->framesPerPeriod();
m_outBufFrameIndex = 0;
m_outBufFramesTotal = 0;
m_outBufSize = mixer()->framesPerPeriod();
m_outBuf = new surroundSampleFrame[m_outBufSize];
m_outBuf = new surroundSampleFrame[m_outBufSize];
int err;
if ((err = soundio_outstream_start(m_outstream))) {
fprintf(stderr, "soundio unable to start stream: %s\n", soundio_strerror(err));
}
int err;
if ((err = soundio_outstream_start(m_outstream)))
{
fprintf(stderr, "soundio unable to start stream: %s\n", soundio_strerror(err));
}
}
void AudioSoundIo::stopProcessing()
{
soundio_outstream_destroy(m_outstream);
m_outstream = NULL;
soundio_outstream_destroy(m_outstream);
m_outstream = NULL;
delete[] m_outBuf;
m_outBuf = NULL;
delete[] m_outBuf;
m_outBuf = NULL;
}
void AudioSoundIo::error_callback(int err) {
fprintf(stderr, "soundio: error streaming: %s\n", soundio_strerror(err));
void AudioSoundIo::errorCallback(int err)
{
fprintf(stderr, "soundio: error streaming: %s\n", soundio_strerror(err));
}
void AudioSoundIo::underflow_callback() {
fprintf(stderr, "soundio: buffer underflow reported\n");
void AudioSoundIo::underflowCallback()
{
fprintf(stderr, "soundio: buffer underflow reported\n");
}
void AudioSoundIo::write_callback(int frame_count_min, int frame_count_max) {
const struct SoundIoChannelLayout *layout = &m_outstream->layout;
SoundIoChannelArea *areas;
int bytes_per_sample = m_outstream->bytes_per_sample;
int err;
void AudioSoundIo::writeCallback(int frameCountMin, int frameCountMax)
{
const struct SoundIoChannelLayout *layout = &m_outstream->layout;
SoundIoChannelArea *areas;
int bytesPerSample = m_outstream->bytes_per_sample;
int err;
const float gain = mixer()->masterGain();
const float gain = mixer()->masterGain();
int frames_left = frame_count_max;
int framesLeft = frameCountMax;
while (frames_left > 0) {
int frame_count = frames_left;
if ((err = soundio_outstream_begin_write(m_outstream, &areas, &frame_count))) {
error_callback(err);
return;
}
while (framesLeft > 0)
{
int frameCount = framesLeft;
if ((err = soundio_outstream_begin_write(m_outstream, &areas, &frameCount)))
{
errorCallback(err);
return;
}
if (!frame_count)
break;
if (!frameCount)
break;
for (int frame = 0; frame < frame_count; frame += 1) {
if (m_outBufFrameIndex >= m_outBufFramesTotal) {
m_outBufFramesTotal = getNextBuffer(m_outBuf);
m_outBufFrameIndex = 0;
}
for (int frame = 0; frame < frameCount; frame += 1)
{
if (m_outBufFrameIndex >= m_outBufFramesTotal)
{
m_outBufFramesTotal = getNextBuffer(m_outBuf);
m_outBufFrameIndex = 0;
}
for (int channel = 0; channel < layout->channel_count; channel += 1) {
float sample = gain * m_outBuf[m_outBufFrameIndex][channel];
memcpy(areas[channel].ptr, &sample, bytes_per_sample);
areas[channel].ptr += areas[channel].step;
}
m_outBufFrameIndex += 1;
}
for (int channel = 0; channel < layout->channel_count; channel += 1)
{
float sample = gain * m_outBuf[m_outBufFrameIndex][channel];
memcpy(areas[channel].ptr, &sample, bytesPerSample);
areas[channel].ptr += areas[channel].step;
}
m_outBufFrameIndex += 1;
}
if ((err = soundio_outstream_end_write(m_outstream))) {
error_callback(err);
return;
}
if ((err = soundio_outstream_end_write(m_outstream)))
{
errorCallback(err);
return;
}
frames_left -= frame_count;
}
framesLeft -= frameCount;
}
}
void AudioSoundIoSetupUtil::reconnectSoundIo() {
((AudioSoundIo::setupWidget *)m_setupWidget)->reconnectSoundIo();
void AudioSoundIoSetupUtil::reconnectSoundIo()
{
((AudioSoundIo::setupWidget *)m_setupWidget)->reconnectSoundIo();
}
void AudioSoundIoSetupUtil::updateDevices() {
((AudioSoundIo::setupWidget *)m_setupWidget)->updateDevices();
void AudioSoundIoSetupUtil::updateDevices()
{
((AudioSoundIo::setupWidget *)m_setupWidget)->updateDevices();
}
static void setup_widget_on_backend_disconnect(SoundIo *soundio, int err) {
AudioSoundIo::setupWidget *setup_widget = (AudioSoundIo::setupWidget *)soundio->userdata;
setup_widget->reconnectSoundIo();
static void setupWidgetOnBackendDisconnect(SoundIo *soundio, int err)
{
AudioSoundIo::setupWidget *setupWidget = (AudioSoundIo::setupWidget *)soundio->userdata;
setupWidget->reconnectSoundIo();
}
static void setup_widget_on_devices_change(SoundIo *soundio) {
AudioSoundIo::setupWidget *setup_widget = (AudioSoundIo::setupWidget *)soundio->userdata;
setup_widget->updateDevices();
static void setup_widget_on_devices_change(SoundIo *soundio)
{
AudioSoundIo::setupWidget *setupWidget = (AudioSoundIo::setupWidget *)soundio->userdata;
setupWidget->updateDevices();
}
void AudioSoundIo::setupWidget::reconnectSoundIo() {
const QString& config_backend = m_is_first ?
ConfigManager::inst()->value( "audiosoundio", "backend" ) : m_backendModel.currentText();
m_is_first = false;
void AudioSoundIo::setupWidget::reconnectSoundIo()
{
const QString& configBackend = m_isFirst ?
ConfigManager::inst()->value( "audiosoundio", "backend" ) : m_backendModel.currentText();
m_isFirst = false;
soundio_disconnect(m_soundio);
soundio_disconnect(m_soundio);
int err;
int backend_index = m_backendModel.findText(config_backend);
if (backend_index < 0) {
if ((err = soundio_connect(m_soundio))) {
fprintf(stderr, "soundio: unable to connect backend: %s\n", soundio_strerror(err));
return;
}
backend_index = m_backendModel.findText(soundio_backend_name(m_soundio->current_backend));
assert(backend_index >= 0);
} else {
SoundIoBackend backend = soundio_get_backend(m_soundio, backend_index);
if ((err = soundio_connect_backend(m_soundio, backend))) {
fprintf(stderr, "soundio: unable to connect %s backend: %s\n",
soundio_backend_name(backend), soundio_strerror(err));
if ((err = soundio_connect(m_soundio))) {
fprintf(stderr, "soundio: unable to connect backend: %s\n", soundio_strerror(err));
return;
}
backend_index = m_backendModel.findText(soundio_backend_name(m_soundio->current_backend));
assert(backend_index >= 0);
}
}
m_backendModel.setValue(backend_index);
int err;
int backend_index = m_backendModel.findText(configBackend);
if (backend_index < 0)
{
if ((err = soundio_connect(m_soundio)))
{
fprintf(stderr, "soundio: unable to connect backend: %s\n", soundio_strerror(err));
return;
}
backend_index = m_backendModel.findText(soundio_backend_name(m_soundio->current_backend));
assert(backend_index >= 0);
}
else
{
SoundIoBackend backend = soundio_get_backend(m_soundio, backend_index);
if ((err = soundio_connect_backend(m_soundio, backend)))
{
fprintf(stderr, "soundio: unable to connect %s backend: %s\n",
soundio_backend_name(backend), soundio_strerror(err));
if ((err = soundio_connect(m_soundio)))
{
fprintf(stderr, "soundio: unable to connect backend: %s\n", soundio_strerror(err));
return;
}
backend_index = m_backendModel.findText(soundio_backend_name(m_soundio->current_backend));
assert(backend_index >= 0);
}
}
m_backendModel.setValue(backend_index);
soundio_flush_events(m_soundio);
soundio_flush_events(m_soundio);
const QString& config_device_id = ConfigManager::inst()->value( "audiosoundio", "out_device_id" );
const QString& config_device_raw = ConfigManager::inst()->value( "audiosoundio", "out_device_raw" );
const QString& configDeviceId = ConfigManager::inst()->value( "audiosoundio", "out_device_id" );
const QString& configDeviceRaw = ConfigManager::inst()->value( "audiosoundio", "out_device_raw" );
int device_index = m_default_out_index;
bool want_raw = (config_device_raw == "yes");
for (int i = 0; i < m_device_list.length(); i += 1) {
const DeviceId *device_id = &m_device_list.at(i);
if (device_id->id == config_device_id && device_id->is_raw == want_raw) {
device_index = i;
break;
}
}
int deviceIndex = m_defaultOutIndex;
bool wantRaw = (configDeviceRaw == "yes");
for (int i = 0; i < m_deviceList.length(); i += 1)
{
const DeviceId *deviceId = &m_deviceList.at(i);
if (deviceId->id == configDeviceId && deviceId->is_raw == wantRaw)
{
deviceIndex = i;
break;
}
}
m_deviceModel.setValue(device_index);
m_deviceModel.setValue(deviceIndex);
}
void AudioSoundIo::setupWidget::updateDevices() {
m_default_out_index = soundio_default_output_device_index(m_soundio);
void AudioSoundIo::setupWidget::updateDevices()
{
m_defaultOutIndex = soundio_default_output_device_index(m_soundio);
// get devices for selected backend
m_deviceModel.clear();
m_device_list.clear();
int out_device_count = soundio_output_device_count(m_soundio);
for (int i = 0; i < out_device_count; i += 1) {
SoundIoDevice *device = soundio_get_output_device(m_soundio, i);
// get devices for selected backend
m_deviceModel.clear();
m_deviceList.clear();
int outDeviceCount = soundio_output_device_count(m_soundio);
for (int i = 0; i < outDeviceCount; i += 1)
{
SoundIoDevice *device = soundio_get_output_device(m_soundio, i);
QString raw_text = device->is_raw ? " (raw)" : "";
QString default_text = (i == m_default_out_index) ? " (default)" : "";
QString raw_text = device->is_raw ? " (raw)" : "";
QString default_text = (i == m_defaultOutIndex) ? " (default)" : "";
m_deviceModel.addItem(device->name + raw_text + default_text);
m_device_list.append({device->id, device->is_raw});
}
m_deviceModel.addItem(device->name + raw_text + default_text);
m_deviceList.append({device->id, device->is_raw});
}
}
AudioSoundIo::setupWidget::setupWidget( QWidget * _parent ) :
AudioDeviceSetupWidget( AudioSoundIo::name(), _parent )
AudioDeviceSetupWidget( AudioSoundIo::name(), _parent )
{
m_setupUtil.m_setupWidget = this;
m_setupUtil.m_setupWidget = this;
m_backend = new ComboBox( this, "BACKEND" );
m_backend->setGeometry( 64, 15, 260, 20 );
m_backend = new ComboBox( this, "BACKEND" );
m_backend->setGeometry( 64, 15, 260, 20 );
QLabel * backend_lbl = new QLabel( tr( "BACKEND" ), this );
backend_lbl->setFont( pointSize<7>( backend_lbl->font() ) );
backend_lbl->move( 8, 18 );
QLabel * backend_lbl = new QLabel( tr( "BACKEND" ), this );
backend_lbl->setFont( pointSize<7>( backend_lbl->font() ) );
backend_lbl->move( 8, 18 );
m_device = new ComboBox( this, "DEVICE" );
m_device->setGeometry( 64, 35, 260, 20 );
m_device = new ComboBox( this, "DEVICE" );
m_device->setGeometry( 64, 35, 260, 20 );
QLabel * dev_lbl = new QLabel( tr( "DEVICE" ), this );
dev_lbl->setFont( pointSize<7>( dev_lbl->font() ) );
dev_lbl->move( 8, 38 );
QLabel * dev_lbl = new QLabel( tr( "DEVICE" ), this );
dev_lbl->setFont( pointSize<7>( dev_lbl->font() ) );
dev_lbl->move( 8, 38 );
// Setup models
m_soundio = soundio_create();
if (!m_soundio) {
fprintf(stderr, "Unable to initialize soundio: out of memory\n");
return;
}
m_soundio->userdata = this;
m_soundio->on_backend_disconnect = setup_widget_on_backend_disconnect;
m_soundio->on_devices_change = setup_widget_on_devices_change;
m_soundio->app_name = "LMMS";
// Setup models
m_soundio = soundio_create();
if (!m_soundio)
{
fprintf(stderr, "Unable to initialize soundio: out of memory\n");
return;
}
m_soundio->userdata = this;
m_soundio->on_backend_disconnect = setupWidgetOnBackendDisconnect;
m_soundio->on_devices_change = setup_widget_on_devices_change;
m_soundio->app_name = "LMMS";
int backend_count = soundio_backend_count(m_soundio);
for (int i = 0; i < backend_count; i += 1) {
SoundIoBackend backend = soundio_get_backend(m_soundio, i);
m_backendModel.addItem(soundio_backend_name(backend));
}
int backendCount = soundio_backend_count(m_soundio);
for (int i = 0; i < backendCount; i += 1)
{
SoundIoBackend backend = soundio_get_backend(m_soundio, i);
m_backendModel.addItem(soundio_backend_name(backend));
}
m_is_first = true;
m_isFirst = true;
reconnectSoundIo();
reconnectSoundIo();
bool ok = connect( &m_backendModel, SIGNAL( dataChanged() ), &m_setupUtil, SLOT( reconnectSoundIo() ) );
assert(ok);
bool ok = connect( &m_backendModel, SIGNAL( dataChanged() ), &m_setupUtil, SLOT( reconnectSoundIo() ) );
assert(ok);
m_backend->setModel( &m_backendModel );
m_device->setModel( &m_deviceModel );
m_backend->setModel( &m_backendModel );
m_device->setModel( &m_deviceModel );
}
AudioSoundIo::setupWidget::~setupWidget() {
bool ok = disconnect( &m_backendModel, SIGNAL( dataChanged() ), &m_setupUtil, SLOT( reconnectSoundIo() ) );
assert(ok);
soundio_destroy(m_soundio);
AudioSoundIo::setupWidget::~setupWidget()
{
bool ok = disconnect( &m_backendModel, SIGNAL( dataChanged() ), &m_setupUtil, SLOT( reconnectSoundIo() ) );
assert(ok);
soundio_destroy(m_soundio);
}
void AudioSoundIo::setupWidget::saveSettings() {
int device_index = m_deviceModel.value();
const DeviceId *device_id = &m_device_list.at(device_index);
void AudioSoundIo::setupWidget::saveSettings()
{
int deviceIndex = m_deviceModel.value();
const DeviceId *deviceId = &m_deviceList.at(deviceIndex);
QString config_device_raw = device_id->is_raw ? "yes" : "no";
QString configDeviceRaw = deviceId->is_raw ? "yes" : "no";
ConfigManager::inst()->setValue( "audiosoundio", "backend", m_backendModel.currentText());
ConfigManager::inst()->setValue( "audiosoundio", "out_device_id", device_id->id);
ConfigManager::inst()->setValue( "audiosoundio", "out_device_raw", config_device_raw);
ConfigManager::inst()->setValue( "audiosoundio", "backend", m_backendModel.currentText());
ConfigManager::inst()->setValue( "audiosoundio", "out_device_id", deviceId->id);
ConfigManager::inst()->setValue( "audiosoundio", "out_device_raw", configDeviceRaw);
}
#endif