godot/drivers/pulseaudio/audio_driver_pulseaudio.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

849 lines
24 KiB
C++
Raw Normal View History

/**************************************************************************/
/* audio_driver_pulseaudio.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "audio_driver_pulseaudio.h"
#ifdef PULSEAUDIO_ENABLED
#include "core/config/project_settings.h"
#include "core/os/os.h"
#include "core/version.h"
#ifdef ALSAMIDI_ENABLED
#ifdef SOWRAP_ENABLED
#include "drivers/alsa/asound-so_wrap.h"
#else
#include <alsa/asoundlib.h>
#endif
#endif
void AudioDriverPulseAudio::pa_state_cb(pa_context *c, void *userdata) {
2022-04-05 10:40:26 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(userdata);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_TERMINATED:
print_verbose("PulseAudio: context terminated");
ad->pa_ready = -1;
break;
case PA_CONTEXT_FAILED:
print_verbose("PulseAudio: context failed");
ad->pa_ready = -1;
break;
case PA_CONTEXT_READY:
print_verbose("PulseAudio: context ready");
ad->pa_ready = 1;
break;
default:
print_verbose("PulseAudio: context other");
// TODO: Check if we want to handle some of the other
// PA context states like PA_CONTEXT_UNCONNECTED.
break;
}
}
void AudioDriverPulseAudio::pa_sink_info_cb(pa_context *c, const pa_sink_info *l, int eol, void *userdata) {
2022-04-05 10:40:26 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(userdata);
// If eol is set to a positive number, you're at the end of the list
if (eol > 0) {
return;
}
// If eol is set to a negative number there's an error.
if (eol < 0) {
ERR_PRINT("PulseAudio: sink info error: " + String(pa_strerror(pa_context_errno(c))));
ad->pa_status--;
return;
}
ad->pa_map = l->channel_map;
ad->pa_status++;
}
void AudioDriverPulseAudio::pa_source_info_cb(pa_context *c, const pa_source_info *l, int eol, void *userdata) {
2022-04-05 10:40:26 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(userdata);
// If eol is set to a positive number, you're at the end of the list
if (eol > 0) {
return;
}
// If eol is set to a negative number there's an error.
if (eol < 0) {
ERR_PRINT("PulseAudio: sink info error: " + String(pa_strerror(pa_context_errno(c))));
ad->pa_status--;
return;
}
ad->pa_rec_map = l->channel_map;
ad->pa_status++;
}
void AudioDriverPulseAudio::pa_server_info_cb(pa_context *c, const pa_server_info *i, void *userdata) {
ERR_FAIL_COND_MSG(!i, "PulseAudio server info is null.");
2022-04-05 10:40:26 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(userdata);
ad->default_input_device = i->default_source_name;
ad->default_output_device = i->default_sink_name;
ad->pa_status++;
}
Error AudioDriverPulseAudio::detect_channels(bool input) {
pa_channel_map_init_stereo(input ? &pa_rec_map : &pa_map);
String device = input ? input_device_name : output_device_name;
if (device == "Default") {
// Get the default output device name
pa_status = 0;
pa_operation *pa_op = pa_context_get_server_info(pa_ctx, &AudioDriverPulseAudio::pa_server_info_cb, (void *)this);
if (pa_op) {
while (pa_status == 0) {
2020-04-01 23:20:12 +00:00
int ret = pa_mainloop_iterate(pa_ml, 1, nullptr);
if (ret < 0) {
ERR_PRINT("pa_mainloop_iterate error");
}
}
pa_operation_unref(pa_op);
} else {
ERR_PRINT("pa_context_get_server_info error: " + String(pa_strerror(pa_context_errno(pa_ctx))));
return FAILED;
}
}
char dev[1024];
if (device == "Default") {
strcpy(dev, input ? default_input_device.utf8().get_data() : default_output_device.utf8().get_data());
} else {
strcpy(dev, device.utf8().get_data());
}
print_verbose("PulseAudio: Detecting channels for device: " + String(dev));
// Now using the device name get the amount of channels
pa_status = 0;
pa_operation *pa_op;
if (input) {
pa_op = pa_context_get_source_info_by_name(pa_ctx, dev, &AudioDriverPulseAudio::pa_source_info_cb, (void *)this);
} else {
pa_op = pa_context_get_sink_info_by_name(pa_ctx, dev, &AudioDriverPulseAudio::pa_sink_info_cb, (void *)this);
}
if (pa_op) {
while (pa_status == 0) {
2020-04-01 23:20:12 +00:00
int ret = pa_mainloop_iterate(pa_ml, 1, nullptr);
if (ret < 0) {
ERR_PRINT("pa_mainloop_iterate error");
}
}
pa_operation_unref(pa_op);
if (pa_status == -1) {
return FAILED;
}
} else {
if (input) {
ERR_PRINT("pa_context_get_source_info_by_name error");
} else {
ERR_PRINT("pa_context_get_sink_info_by_name error");
}
}
return OK;
}
Error AudioDriverPulseAudio::init_output_device() {
// If there is a specified output device, check that it is really present
if (output_device_name != "Default") {
PackedStringArray list = get_output_device_list();
if (list.find(output_device_name) == -1) {
output_device_name = "Default";
new_output_device = "Default";
}
}
// Detect the amount of channels PulseAudio is using
// Note: If using an even amount of channels (2, 4, etc) channels and pa_map.channels will be equal,
// if not then pa_map.channels will have the real amount of channels PulseAudio is using and channels
// will have the amount of channels Godot is using (in this case it's pa_map.channels + 1)
Error err = detect_channels();
if (err != OK) {
// This most likely means there are no sinks.
ERR_PRINT("PulseAudio: init_output_device failed to detect number of output channels");
return err;
}
switch (pa_map.channels) {
case 1: // Mono
case 3: // Surround 2.1
case 5: // Surround 5.0
case 7: // Surround 7.0
channels = pa_map.channels + 1;
break;
case 2: // Stereo
case 4: // Surround 4.0
case 6: // Surround 5.1
case 8: // Surround 7.1
channels = pa_map.channels;
break;
default:
WARN_PRINT("PulseAudio: Unsupported number of output channels: " + itos(pa_map.channels));
pa_channel_map_init_stereo(&pa_map);
channels = 2;
break;
}
int tmp_latency = GLOBAL_GET("audio/driver/output_latency");
buffer_frames = closest_power_of_2(tmp_latency * mix_rate / 1000);
pa_buffer_size = buffer_frames * pa_map.channels;
print_verbose("PulseAudio: detected " + itos(pa_map.channels) + " output channels");
print_verbose("PulseAudio: audio buffer frames: " + itos(buffer_frames) + " calculated output latency: " + itos(buffer_frames * 1000 / mix_rate) + "ms");
pa_sample_spec spec;
spec.format = PA_SAMPLE_S16LE;
spec.channels = pa_map.channels;
spec.rate = mix_rate;
pa_map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
pa_map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
pa_map.map[2] = PA_CHANNEL_POSITION_FRONT_CENTER;
pa_map.map[3] = PA_CHANNEL_POSITION_LFE;
pa_map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
pa_map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
pa_map.map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
pa_map.map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
pa_str = pa_stream_new(pa_ctx, "Sound", &spec, &pa_map);
2020-04-01 23:20:12 +00:00
if (pa_str == nullptr) {
2019-11-06 16:03:04 +00:00
ERR_PRINT("PulseAudio: pa_stream_new error: " + String(pa_strerror(pa_context_errno(pa_ctx))));
ERR_FAIL_V(ERR_CANT_OPEN);
}
pa_buffer_attr attr;
// set to appropriate buffer length (in bytes) from global settings
2018-04-15 14:29:16 +00:00
// Note: PulseAudio defaults to 4 fragments, which means that the actual
// latency is tlength / fragments. It seems that the PulseAudio has no way
// to get the fragments number so we're hardcoding this to the default of 4
const int fragments = 4;
attr.tlength = pa_buffer_size * sizeof(int16_t) * fragments;
// set them to be automatically chosen
attr.prebuf = (uint32_t)-1;
attr.maxlength = (uint32_t)-1;
attr.minreq = (uint32_t)-1;
const char *dev = output_device_name == "Default" ? nullptr : output_device_name.utf8().get_data();
pa_stream_flags flags = pa_stream_flags(PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE);
2020-04-01 23:20:12 +00:00
int error_code = pa_stream_connect_playback(pa_str, dev, &attr, flags, nullptr, nullptr);
ERR_FAIL_COND_V(error_code < 0, ERR_CANT_OPEN);
samples_in.resize(buffer_frames * channels);
samples_out.resize(pa_buffer_size);
// Reset audio input to keep synchronization.
input_position = 0;
input_size = 0;
return OK;
}
Error AudioDriverPulseAudio::init() {
#ifdef SOWRAP_ENABLED
#ifdef DEBUG_ENABLED
int dylibloader_verbose = 1;
#else
int dylibloader_verbose = 0;
#endif
#ifdef ALSAMIDI_ENABLED
// If using PulseAudio with ALSA MIDI, we need to initialize ALSA as well
initialize_asound(dylibloader_verbose);
#endif
if (initialize_pulse(dylibloader_verbose)) {
return ERR_CANT_OPEN;
}
#endif
bool ver_ok = false;
String version = String::utf8(pa_get_library_version());
Vector<String> ver_parts = version.split(".");
if (ver_parts.size() >= 2) {
ver_ok = (ver_parts[0].to_int() >= 8); // 8.0.0
}
print_verbose(vformat("PulseAudio %s detected.", version));
if (!ver_ok) {
print_verbose("Unsupported PulseAudio library version!");
return ERR_CANT_OPEN;
}
2022-08-19 08:38:13 +00:00
active.clear();
exit_thread.clear();
mix_rate = _get_configured_mix_rate();
pa_ml = pa_mainloop_new();
2020-04-01 23:20:12 +00:00
ERR_FAIL_COND_V(pa_ml == nullptr, ERR_CANT_OPEN);
String context_name;
if (Engine::get_singleton()->is_editor_hint()) {
context_name = VERSION_NAME " Editor";
} else {
context_name = GLOBAL_GET("application/config/name");
if (context_name.is_empty()) {
context_name = VERSION_NAME " Project";
}
}
pa_ctx = pa_context_new(pa_mainloop_get_api(pa_ml), context_name.utf8().ptr());
2020-04-01 23:20:12 +00:00
ERR_FAIL_COND_V(pa_ctx == nullptr, ERR_CANT_OPEN);
pa_ready = 0;
pa_context_set_state_callback(pa_ctx, pa_state_cb, (void *)this);
2020-04-01 23:20:12 +00:00
int ret = pa_context_connect(pa_ctx, nullptr, PA_CONTEXT_NOFLAGS, nullptr);
if (ret < 0) {
if (pa_ctx) {
pa_context_unref(pa_ctx);
2020-04-01 23:20:12 +00:00
pa_ctx = nullptr;
}
if (pa_ml) {
pa_mainloop_free(pa_ml);
2020-04-01 23:20:12 +00:00
pa_ml = nullptr;
}
return ERR_CANT_OPEN;
}
while (pa_ready == 0) {
2020-04-01 23:20:12 +00:00
ret = pa_mainloop_iterate(pa_ml, 1, nullptr);
if (ret < 0) {
ERR_PRINT("pa_mainloop_iterate error");
}
}
if (pa_ready < 0) {
if (pa_ctx) {
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
2020-04-01 23:20:12 +00:00
pa_ctx = nullptr;
}
if (pa_ml) {
pa_mainloop_free(pa_ml);
2020-04-01 23:20:12 +00:00
pa_ml = nullptr;
}
return ERR_CANT_OPEN;
}
init_output_device();
thread.start(AudioDriverPulseAudio::thread_func, this);
return OK;
}
float AudioDriverPulseAudio::get_latency() {
if (latency == 0) { //only do this once since it's approximate anyway
lock();
pa_usec_t palat = 0;
if (pa_stream_get_state(pa_str) == PA_STREAM_READY) {
int negative = 0;
if (pa_stream_get_latency(pa_str, &palat, &negative) >= 0) {
if (negative) {
palat = 0;
}
}
}
if (palat > 0) {
latency = double(palat) / 1000000.0;
}
unlock();
}
return latency;
}
void AudioDriverPulseAudio::thread_func(void *p_udata) {
2022-04-07 10:23:40 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(p_udata);
unsigned int write_ofs = 0;
size_t avail_bytes = 0;
uint64_t default_device_msec = OS::get_singleton()->get_ticks_msec();
2022-08-19 08:38:13 +00:00
while (!ad->exit_thread.is_set()) {
size_t read_bytes = 0;
size_t written_bytes = 0;
if (avail_bytes == 0) {
ad->lock();
ad->start_counting_ticks();
2022-08-19 08:38:13 +00:00
if (!ad->active.is_set()) {
ad->samples_out.fill(0);
} else {
ad->audio_server_process(ad->buffer_frames, ad->samples_in.ptrw());
int16_t *out_ptr = ad->samples_out.ptrw();
if (ad->channels == ad->pa_map.channels) {
for (unsigned int i = 0; i < ad->pa_buffer_size; i++) {
out_ptr[i] = ad->samples_in[i] >> 16;
}
} else {
// Uneven amount of channels
unsigned int in_idx = 0;
unsigned int out_idx = 0;
for (unsigned int i = 0; i < ad->buffer_frames; i++) {
Fix warnings for comparison between signed and unsigned integers [-Wsign-compare] Also turn off -Wsign-compare warnings in the future, we do not consider them important. Fixes the following GCC 5 warnings: ``` core/node_path.cpp:279:24: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] core/oa_hash_map.h:169:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] core/oa_hash_map.h:314:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] drivers/gles2/shader_gles2.cpp:985:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] drivers/gles3/rasterizer_storage_gles3.cpp:1075:25: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] drivers/pulseaudio/audio_driver_pulseaudio.cpp:343:34: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] editor/editor_plugin.cpp:525:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] editor/editor_properties_array_dict.cpp:747:25: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] editor/plugins/spatial_editor_plugin.cpp:2078:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] editor/plugins/spatial_editor_plugin.cpp:4096:27: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] editor/plugins/sprite_editor_plugin.cpp:100:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/cvtt/image_compress_cvtt.cpp:122:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/cvtt/image_compress_cvtt.cpp:134:77: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/cvtt/image_compress_cvtt.cpp:339:25: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/etc/image_etc.cpp:222:34: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/gdnative/register_types.cpp:242:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/gdnative/register_types.cpp:258:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/opensimplex/simplex_noise.cpp:200:13: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/opensimplex/simplex_noise.cpp:222:13: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] modules/opensimplex/simplex_noise.cpp:246:13: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/android/export/export.cpp:1085:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/android/export/export.cpp:1489:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/android/export/export.cpp:1623:22: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/iphone/export/export.cpp:206:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/iphone/export/export.cpp:356:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/iphone/export/export.cpp:406:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] platform/iphone/export/export.cpp:493:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/3d/audio_stream_player_3d.cpp:420:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/resources/audio_stream_sample.cpp:565:22: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/resources/audio_stream_sample.cpp:571:22: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] servers/audio/audio_rb_resampler.cpp:156:36: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] ``` The following warnings were not fixed, as they implied casting for no gain: ``` core/io/packet_peer.cpp:228:38: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] core/io/resource_format_binary.cpp:109:11: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] drivers/gles2/rasterizer_scene_gles2.cpp:144:57: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] drivers/unix/file_access_unix.cpp:249:46: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/3d/voxel_light_baker.cpp:889:14: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/3d/voxel_light_baker.cpp:1020:14: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/3d/voxel_light_baker.cpp:1154:14: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/3d/voxel_light_baker.cpp:2255:38: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] scene/resources/bit_mask.cpp:336:25: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] servers/audio/audio_stream.cpp:141:49: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] servers/audio/audio_stream.cpp:150:19: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] servers/audio/audio_stream.cpp:154:19: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] servers/audio_server.cpp:86:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] servers/audio_server.cpp:89:17: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] ```
2018-09-26 15:38:02 +00:00
for (int j = 0; j < ad->pa_map.channels - 1; j++) {
out_ptr[out_idx++] = ad->samples_in[in_idx++] >> 16;
}
uint32_t l = ad->samples_in[in_idx++] >> 16;
uint32_t r = ad->samples_in[in_idx++] >> 16;
out_ptr[out_idx++] = (l + r) / 2;
}
}
}
avail_bytes = ad->pa_buffer_size * sizeof(int16_t);
write_ofs = 0;
ad->stop_counting_ticks();
ad->unlock();
}
ad->lock();
ad->start_counting_ticks();
int ret;
do {
2020-04-01 23:20:12 +00:00
ret = pa_mainloop_iterate(ad->pa_ml, 0, nullptr);
} while (ret > 0);
if (avail_bytes > 0 && pa_stream_get_state(ad->pa_str) == PA_STREAM_READY) {
size_t bytes = pa_stream_writable_size(ad->pa_str);
if (bytes > 0) {
size_t bytes_to_write = MIN(bytes, avail_bytes);
const void *ptr = ad->samples_out.ptr();
2020-04-01 23:20:12 +00:00
ret = pa_stream_write(ad->pa_str, (char *)ptr + write_ofs, bytes_to_write, nullptr, 0LL, PA_SEEK_RELATIVE);
if (ret != 0) {
2019-11-06 16:03:04 +00:00
ERR_PRINT("PulseAudio: pa_stream_write error: " + String(pa_strerror(ret)));
} else {
avail_bytes -= bytes_to_write;
write_ofs += bytes_to_write;
written_bytes += bytes_to_write;
}
}
}
// User selected a new output device, finish the current one so we'll init the new output device
if (ad->output_device_name != ad->new_output_device) {
ad->output_device_name = ad->new_output_device;
ad->finish_output_device();
Error err = ad->init_output_device();
if (err != OK) {
ERR_PRINT("PulseAudio: init_output_device error");
ad->output_device_name = "Default";
ad->new_output_device = "Default";
err = ad->init_output_device();
if (err != OK) {
2022-08-19 08:38:13 +00:00
ad->active.clear();
ad->exit_thread.set();
break;
}
}
avail_bytes = 0;
write_ofs = 0;
}
// If we're using the default output device, check that the current output device is still the default
if (ad->output_device_name == "Default") {
uint64_t msec = OS::get_singleton()->get_ticks_msec();
if (msec > (default_device_msec + 1000)) {
String old_default_device = ad->default_output_device;
default_device_msec = msec;
ad->pa_status = 0;
pa_operation *pa_op = pa_context_get_server_info(ad->pa_ctx, &AudioDriverPulseAudio::pa_server_info_cb, (void *)ad);
if (pa_op) {
while (ad->pa_status == 0) {
2020-04-01 23:20:12 +00:00
ret = pa_mainloop_iterate(ad->pa_ml, 1, nullptr);
if (ret < 0) {
ERR_PRINT("pa_mainloop_iterate error");
}
}
pa_operation_unref(pa_op);
} else {
ERR_PRINT("pa_context_get_server_info error: " + String(pa_strerror(pa_context_errno(ad->pa_ctx))));
}
if (old_default_device != ad->default_output_device) {
ad->finish_output_device();
Error err = ad->init_output_device();
if (err != OK) {
ERR_PRINT("PulseAudio: init_output_device error");
2022-08-19 08:38:13 +00:00
ad->active.clear();
ad->exit_thread.set();
break;
}
avail_bytes = 0;
write_ofs = 0;
}
}
}
if (ad->pa_rec_str && pa_stream_get_state(ad->pa_rec_str) == PA_STREAM_READY) {
size_t bytes = pa_stream_readable_size(ad->pa_rec_str);
if (bytes > 0) {
2020-04-01 23:20:12 +00:00
const void *ptr = nullptr;
size_t maxbytes = ad->input_buffer.size() * sizeof(int16_t);
bytes = MIN(bytes, maxbytes);
ret = pa_stream_peek(ad->pa_rec_str, &ptr, &bytes);
if (ret != 0) {
ERR_PRINT("pa_stream_peek error");
} else {
int16_t *srcptr = (int16_t *)ptr;
for (size_t i = bytes >> 1; i > 0; i--) {
int32_t sample = int32_t(*srcptr++) << 16;
ad->input_buffer_write(sample);
if (ad->pa_rec_map.channels == 1) {
// In case input device is single channel convert it to Stereo
ad->input_buffer_write(sample);
}
}
read_bytes += bytes;
ret = pa_stream_drop(ad->pa_rec_str);
if (ret != 0) {
ERR_PRINT("pa_stream_drop error");
}
}
}
// User selected a new input device, finish the current one so we'll init the new input device
if (ad->input_device_name != ad->new_input_device) {
ad->input_device_name = ad->new_input_device;
ad->finish_input_device();
Error err = ad->init_input_device();
if (err != OK) {
ERR_PRINT("PulseAudio: init_input_device error");
ad->input_device_name = "Default";
ad->new_input_device = "Default";
err = ad->init_input_device();
if (err != OK) {
2022-08-19 08:38:13 +00:00
ad->active.clear();
ad->exit_thread.set();
break;
}
}
}
}
ad->stop_counting_ticks();
ad->unlock();
// Let the thread rest a while if we haven't read or write anything
if (written_bytes == 0 && read_bytes == 0) {
OS::get_singleton()->delay_usec(1000);
}
}
}
void AudioDriverPulseAudio::start() {
2022-08-19 08:38:13 +00:00
active.set();
}
int AudioDriverPulseAudio::get_mix_rate() const {
return mix_rate;
}
2017-01-15 19:06:14 +00:00
AudioDriver::SpeakerMode AudioDriverPulseAudio::get_speaker_mode() const {
return get_speaker_mode_by_total_channels(channels);
}
void AudioDriverPulseAudio::pa_sinklist_cb(pa_context *c, const pa_sink_info *l, int eol, void *userdata) {
2022-04-05 10:40:26 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(userdata);
// If eol is set to a positive number, you're at the end of the list
if (eol > 0) {
return;
}
ad->pa_devices.push_back(l->name);
ad->pa_status++;
}
PackedStringArray AudioDriverPulseAudio::get_output_device_list() {
pa_devices.clear();
pa_devices.push_back("Default");
2020-04-01 23:20:12 +00:00
if (pa_ctx == nullptr) {
return pa_devices;
}
lock();
// Get the output device list
pa_status = 0;
pa_operation *pa_op = pa_context_get_sink_info_list(pa_ctx, pa_sinklist_cb, (void *)this);
if (pa_op) {
while (pa_status == 0) {
2020-04-01 23:20:12 +00:00
int ret = pa_mainloop_iterate(pa_ml, 1, nullptr);
if (ret < 0) {
ERR_PRINT("pa_mainloop_iterate error");
}
}
pa_operation_unref(pa_op);
} else {
ERR_PRINT("pa_context_get_server_info error");
}
unlock();
return pa_devices;
}
String AudioDriverPulseAudio::get_output_device() {
return output_device_name;
}
void AudioDriverPulseAudio::set_output_device(const String &p_name) {
lock();
new_output_device = p_name;
unlock();
}
void AudioDriverPulseAudio::lock() {
mutex.lock();
}
void AudioDriverPulseAudio::unlock() {
mutex.unlock();
}
void AudioDriverPulseAudio::finish_output_device() {
if (pa_str) {
pa_stream_disconnect(pa_str);
pa_stream_unref(pa_str);
2020-04-01 23:20:12 +00:00
pa_str = nullptr;
}
}
void AudioDriverPulseAudio::finish() {
if (!thread.is_started()) {
return;
}
2022-08-19 08:38:13 +00:00
exit_thread.set();
2023-04-27 16:34:30 +00:00
if (thread.is_started()) {
thread.wait_to_finish();
}
finish_output_device();
if (pa_ctx) {
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
2020-04-01 23:20:12 +00:00
pa_ctx = nullptr;
}
if (pa_ml) {
pa_mainloop_free(pa_ml);
2020-04-01 23:20:12 +00:00
pa_ml = nullptr;
}
}
Error AudioDriverPulseAudio::init_input_device() {
// If there is a specified input device, check that it is really present
if (input_device_name != "Default") {
PackedStringArray list = get_input_device_list();
if (list.find(input_device_name) == -1) {
input_device_name = "Default";
new_input_device = "Default";
}
}
2018-02-27 07:54:56 +00:00
detect_channels(true);
switch (pa_rec_map.channels) {
case 1: // Mono
case 2: // Stereo
break;
default:
2019-11-07 08:44:15 +00:00
WARN_PRINT("PulseAudio: Unsupported number of input channels: " + itos(pa_rec_map.channels));
pa_channel_map_init_stereo(&pa_rec_map);
break;
}
print_verbose("PulseAudio: detected " + itos(pa_rec_map.channels) + " input channels");
pa_sample_spec spec;
2018-02-27 07:54:56 +00:00
spec.format = PA_SAMPLE_S16LE;
spec.channels = pa_rec_map.channels;
spec.rate = mix_rate;
2018-10-19 19:32:03 +00:00
int input_latency = 30;
int input_buffer_frames = closest_power_of_2(input_latency * mix_rate / 1000);
int input_buffer_size = input_buffer_frames * spec.channels;
2018-02-27 07:54:56 +00:00
pa_buffer_attr attr;
2018-10-19 19:32:03 +00:00
attr.fragsize = input_buffer_size * sizeof(int16_t);
pa_rec_str = pa_stream_new(pa_ctx, "Record", &spec, &pa_rec_map);
2020-04-01 23:20:12 +00:00
if (pa_rec_str == nullptr) {
2019-11-06 16:03:04 +00:00
ERR_PRINT("PulseAudio: pa_stream_new error: " + String(pa_strerror(pa_context_errno(pa_ctx))));
ERR_FAIL_V(ERR_CANT_OPEN);
}
const char *dev = input_device_name == "Default" ? nullptr : input_device_name.utf8().get_data();
pa_stream_flags flags = pa_stream_flags(PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE);
int error_code = pa_stream_connect_record(pa_rec_str, dev, &attr, flags);
if (error_code < 0) {
2019-11-06 16:03:04 +00:00
ERR_PRINT("PulseAudio: pa_stream_connect_record error: " + String(pa_strerror(error_code)));
ERR_FAIL_V(ERR_CANT_OPEN);
}
input_buffer_init(input_buffer_frames);
2018-10-19 19:32:03 +00:00
print_verbose("PulseAudio: detected " + itos(pa_rec_map.channels) + " input channels");
print_verbose("PulseAudio: input buffer frames: " + itos(input_buffer_frames) + " calculated latency: " + itos(input_buffer_frames * 1000 / mix_rate) + "ms");
return OK;
2018-02-27 07:54:56 +00:00
}
void AudioDriverPulseAudio::finish_input_device() {
if (pa_rec_str) {
int ret = pa_stream_disconnect(pa_rec_str);
if (ret != 0) {
2019-11-06 16:03:04 +00:00
ERR_PRINT("PulseAudio: pa_stream_disconnect error: " + String(pa_strerror(ret)));
}
pa_stream_unref(pa_rec_str);
2020-04-01 23:20:12 +00:00
pa_rec_str = nullptr;
}
}
Error AudioDriverPulseAudio::input_start() {
lock();
Error err = init_input_device();
unlock();
return err;
}
Error AudioDriverPulseAudio::input_stop() {
lock();
finish_input_device();
unlock();
2018-02-27 07:54:56 +00:00
return OK;
2018-02-27 07:54:56 +00:00
}
void AudioDriverPulseAudio::pa_sourcelist_cb(pa_context *c, const pa_source_info *l, int eol, void *userdata) {
2022-04-05 10:40:26 +00:00
AudioDriverPulseAudio *ad = static_cast<AudioDriverPulseAudio *>(userdata);
// If eol is set to a positive number, you're at the end of the list
if (eol > 0) {
return;
}
if (l->monitor_of_sink == PA_INVALID_INDEX) {
ad->pa_rec_devices.push_back(l->name);
}
ad->pa_status++;
}
PackedStringArray AudioDriverPulseAudio::get_input_device_list() {
pa_rec_devices.clear();
pa_rec_devices.push_back("Default");
2020-04-01 23:20:12 +00:00
if (pa_ctx == nullptr) {
return pa_rec_devices;
}
lock();
// Get the device list
pa_status = 0;
pa_operation *pa_op = pa_context_get_source_info_list(pa_ctx, pa_sourcelist_cb, (void *)this);
if (pa_op) {
while (pa_status == 0) {
2020-04-01 23:20:12 +00:00
int ret = pa_mainloop_iterate(pa_ml, 1, nullptr);
if (ret < 0) {
ERR_PRINT("pa_mainloop_iterate error");
}
}
pa_operation_unref(pa_op);
} else {
ERR_PRINT("pa_context_get_server_info error");
}
unlock();
return pa_rec_devices;
}
String AudioDriverPulseAudio::get_input_device() {
lock();
String name = input_device_name;
unlock();
return name;
}
void AudioDriverPulseAudio::set_input_device(const String &p_name) {
lock();
new_input_device = p_name;
unlock();
}
AudioDriverPulseAudio::AudioDriverPulseAudio() {
samples_in.clear();
samples_out.clear();
}
#endif // PULSEAUDIO_ENABLED