333 lines
10 KiB
C++
333 lines
10 KiB
C++
|
//
|
||
|
|
// libtgvoip is free and unencumbered public domain software.
|
||
|
|
// For more information, see http://unlicense.org or the UNLICENSE file
|
||
|
|
// you should have received with this source code distribution.
|
||
|
|
//
|
||
|
|
|
||
|
|
#include "../../logging.h"
|
||
|
|
#include "AudioPulse.h"
|
||
|
|
|
||
|
|
#include <dlfcn.h>
|
||
|
|
|
||
|
|
#include <cstring>
|
||
|
|
|
||
|
|
#define DECLARE_DL_FUNCTION(name) decltype(name)* AudioPulse::_import_##name = nullptr
|
||
|
|
#define CHECK_DL_ERROR(res, msg) \
|
||
|
|
if (!res) \
|
||
|
|
{ \
|
||
|
|
LOGE(msg ": %s", dlerror()); \
|
||
|
|
return false; \
|
||
|
|
}
|
||
|
|
#define LOAD_DL_FUNCTION(name) \
|
||
|
|
{ \
|
||
|
|
_import_##name = reinterpret_cast<decltype(_import_##name)>(::dlsym(m_lib, #name)); \
|
||
|
|
CHECK_DL_ERROR(_import_##name, "Error getting entry point for " #name); \
|
||
|
|
}
|
||
|
|
#define CHECK_ERROR(res, msg) \
|
||
|
|
if (res != 0) \
|
||
|
|
{ \
|
||
|
|
LOGE(msg " failed: %s", pa_strerror(res)); \
|
||
|
|
m_failed = true; \
|
||
|
|
return; \
|
||
|
|
}
|
||
|
|
|
||
|
|
using namespace tgvoip;
|
||
|
|
using namespace tgvoip::audio;
|
||
|
|
|
||
|
|
bool AudioPulse::m_loaded = false;
|
||
|
|
void* AudioPulse::m_lib = nullptr;
|
||
|
|
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_new);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_get_api);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_new);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_new_with_proplist);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_set_state_callback);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_lock);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_unlock);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_start);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_connect);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_get_state);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_wait);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_new_with_proplist);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_set_state_callback);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_set_write_callback);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_connect_playback);
|
||
|
|
DECLARE_DL_FUNCTION(pa_operation_unref);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_cork);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_stop);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_disconnect);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_unref);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_disconnect);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_unref);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_free);
|
||
|
|
DECLARE_DL_FUNCTION(pa_threaded_mainloop_signal);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_begin_write);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_write);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_get_state);
|
||
|
|
DECLARE_DL_FUNCTION(pa_strerror);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_set_read_callback);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_connect_record);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_peek);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_drop);
|
||
|
|
DECLARE_DL_FUNCTION(pa_mainloop_new);
|
||
|
|
DECLARE_DL_FUNCTION(pa_mainloop_get_api);
|
||
|
|
DECLARE_DL_FUNCTION(pa_mainloop_iterate);
|
||
|
|
DECLARE_DL_FUNCTION(pa_mainloop_free);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_get_sink_info_list);
|
||
|
|
DECLARE_DL_FUNCTION(pa_context_get_source_info_list);
|
||
|
|
DECLARE_DL_FUNCTION(pa_operation_get_state);
|
||
|
|
DECLARE_DL_FUNCTION(pa_proplist_new);
|
||
|
|
DECLARE_DL_FUNCTION(pa_proplist_sets);
|
||
|
|
DECLARE_DL_FUNCTION(pa_proplist_free);
|
||
|
|
DECLARE_DL_FUNCTION(pa_stream_get_latency);
|
||
|
|
|
||
|
|
#include "PulseFunctions.h"
|
||
|
|
|
||
|
|
bool AudioPulse::Load()
|
||
|
|
{
|
||
|
|
if (m_loaded)
|
||
|
|
return true;
|
||
|
|
|
||
|
|
m_lib = dlopen("libpulse.so.0", RTLD_LAZY);
|
||
|
|
if (!m_lib)
|
||
|
|
m_lib = dlopen("libpulse.so", RTLD_LAZY);
|
||
|
|
if (!m_lib)
|
||
|
|
{
|
||
|
|
LOGE("Error loading libpulse: %s", dlerror());
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_new);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_get_api);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_new);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_new_with_proplist);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_set_state_callback);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_lock);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_unlock);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_start);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_connect);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_get_state);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_wait);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_new_with_proplist);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_set_state_callback);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_set_write_callback);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_connect_playback);
|
||
|
|
LOAD_DL_FUNCTION(pa_operation_unref);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_cork);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_stop);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_disconnect);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_unref);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_disconnect);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_unref);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_free);
|
||
|
|
LOAD_DL_FUNCTION(pa_threaded_mainloop_signal);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_begin_write);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_write);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_get_state);
|
||
|
|
LOAD_DL_FUNCTION(pa_strerror);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_set_read_callback);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_connect_record);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_peek);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_drop);
|
||
|
|
LOAD_DL_FUNCTION(pa_mainloop_new);
|
||
|
|
LOAD_DL_FUNCTION(pa_mainloop_get_api);
|
||
|
|
LOAD_DL_FUNCTION(pa_mainloop_iterate);
|
||
|
|
LOAD_DL_FUNCTION(pa_mainloop_free);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_get_sink_info_list);
|
||
|
|
LOAD_DL_FUNCTION(pa_context_get_source_info_list);
|
||
|
|
LOAD_DL_FUNCTION(pa_operation_get_state);
|
||
|
|
LOAD_DL_FUNCTION(pa_proplist_new);
|
||
|
|
LOAD_DL_FUNCTION(pa_proplist_sets);
|
||
|
|
LOAD_DL_FUNCTION(pa_proplist_free);
|
||
|
|
LOAD_DL_FUNCTION(pa_stream_get_latency);
|
||
|
|
|
||
|
|
m_loaded = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
AudioPulse::AudioPulse(std::string inputDevice, std::string outputDevice)
|
||
|
|
{
|
||
|
|
if (!Load())
|
||
|
|
{
|
||
|
|
m_failed = true;
|
||
|
|
LOGE("Failed to load libpulse");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_mainloop = pa_threaded_mainloop_new();
|
||
|
|
if (!m_mainloop)
|
||
|
|
{
|
||
|
|
LOGE("Error initializing PulseAudio (pa_threaded_mainloop_new)");
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
m_mainloopApi = pa_threaded_mainloop_get_api(m_mainloop);
|
||
|
|
#ifndef MAXPATHLEN
|
||
|
|
char exeName[20];
|
||
|
|
#else
|
||
|
|
char exePath[MAXPATHLEN];
|
||
|
|
char exeName[MAXPATHLEN];
|
||
|
|
ssize_t lres = readlink("/proc/self/exe", exePath, sizeof(exePath));
|
||
|
|
if (lres == -1)
|
||
|
|
lres = readlink("/proc/curproc/file", exePath, sizeof(exePath));
|
||
|
|
if (lres == -1)
|
||
|
|
lres = readlink("/proc/curproc/exe", exePath, sizeof(exePath));
|
||
|
|
if (lres > 0)
|
||
|
|
{
|
||
|
|
std::strcpy(exeName, ::basename(exePath));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
std::snprintf(exeName, sizeof(exeName), "Process %d", ::getpid());
|
||
|
|
}
|
||
|
|
pa_proplist* proplist = pa_proplist_new();
|
||
|
|
pa_proplist_sets(proplist, PA_PROP_MEDIA_ROLE, "phone");
|
||
|
|
m_context = pa_context_new_with_proplist(m_mainloopApi, exeName, proplist);
|
||
|
|
pa_proplist_free(proplist);
|
||
|
|
if (m_context == nullptr)
|
||
|
|
{
|
||
|
|
LOGE("Error initializing PulseAudio (pa_context_new)");
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
pa_context_set_state_callback(
|
||
|
|
m_context, [](pa_context* context, void* arg)
|
||
|
|
{
|
||
|
|
AudioPulse* self = reinterpret_cast<AudioPulse*>(arg);
|
||
|
|
pa_threaded_mainloop_signal(self->m_mainloop, 0);
|
||
|
|
},
|
||
|
|
this);
|
||
|
|
pa_threaded_mainloop_lock(m_mainloop);
|
||
|
|
m_isLocked = true;
|
||
|
|
int err = pa_threaded_mainloop_start(m_mainloop);
|
||
|
|
CHECK_ERROR(err, "pa_threaded_mainloop_start");
|
||
|
|
m_didStart = true;
|
||
|
|
|
||
|
|
err = pa_context_connect(m_context, nullptr, PA_CONTEXT_NOAUTOSPAWN, nullptr);
|
||
|
|
CHECK_ERROR(err, "pa_context_connect");
|
||
|
|
|
||
|
|
while (true)
|
||
|
|
{
|
||
|
|
pa_context_state_t contextState = pa_context_get_state(m_context);
|
||
|
|
if (!PA_CONTEXT_IS_GOOD(contextState))
|
||
|
|
{
|
||
|
|
LOGE("Error initializing PulseAudio (PA_CONTEXT_IS_GOOD)");
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (contextState == PA_CONTEXT_READY)
|
||
|
|
break;
|
||
|
|
pa_threaded_mainloop_wait(m_mainloop);
|
||
|
|
}
|
||
|
|
pa_threaded_mainloop_unlock(m_mainloop);
|
||
|
|
m_isLocked = false;
|
||
|
|
|
||
|
|
m_output = new AudioOutputPulse(m_context, m_mainloop, std::move(outputDevice));
|
||
|
|
m_input = new AudioInputPulse(m_context, m_mainloop, std::move(inputDevice));
|
||
|
|
}
|
||
|
|
|
||
|
|
AudioPulse::~AudioPulse()
|
||
|
|
{
|
||
|
|
if (m_mainloop != nullptr && m_didStart)
|
||
|
|
{
|
||
|
|
if (m_isLocked)
|
||
|
|
pa_threaded_mainloop_unlock(m_mainloop);
|
||
|
|
pa_threaded_mainloop_stop(m_mainloop);
|
||
|
|
}
|
||
|
|
|
||
|
|
delete m_input;
|
||
|
|
delete m_output;
|
||
|
|
|
||
|
|
if (m_context != nullptr)
|
||
|
|
{
|
||
|
|
pa_context_disconnect(m_context);
|
||
|
|
pa_context_unref(m_context);
|
||
|
|
}
|
||
|
|
if (m_mainloop != nullptr)
|
||
|
|
pa_threaded_mainloop_free(m_mainloop);
|
||
|
|
}
|
||
|
|
|
||
|
|
AudioOutput* AudioPulse::GetOutput()
|
||
|
|
{
|
||
|
|
return m_output;
|
||
|
|
}
|
||
|
|
|
||
|
|
AudioInput* AudioPulse::GetInput()
|
||
|
|
{
|
||
|
|
return m_input;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool AudioPulse::DoOneOperation(std::function<pa_operation*(pa_context*)> f)
|
||
|
|
{
|
||
|
|
if (!Load())
|
||
|
|
return false;
|
||
|
|
|
||
|
|
pa_mainloop* ml;
|
||
|
|
pa_mainloop_api* mlAPI;
|
||
|
|
pa_context* ctx;
|
||
|
|
pa_operation* op = nullptr;
|
||
|
|
int paReady = 0;
|
||
|
|
|
||
|
|
ml = pa_mainloop_new();
|
||
|
|
mlAPI = pa_mainloop_get_api(ml);
|
||
|
|
ctx = pa_context_new(mlAPI, "libtgvoip");
|
||
|
|
|
||
|
|
pa_context_connect(ctx, nullptr, PA_CONTEXT_NOFLAGS, nullptr);
|
||
|
|
pa_context_set_state_callback(
|
||
|
|
ctx, [](pa_context* context, void* arg)
|
||
|
|
{
|
||
|
|
pa_context_state_t state;
|
||
|
|
int* pa_ready = reinterpret_cast<int*>(arg);
|
||
|
|
|
||
|
|
state = pa_context_get_state(context);
|
||
|
|
switch (state)
|
||
|
|
{
|
||
|
|
case PA_CONTEXT_UNCONNECTED:
|
||
|
|
case PA_CONTEXT_CONNECTING:
|
||
|
|
case PA_CONTEXT_AUTHORIZING:
|
||
|
|
case PA_CONTEXT_SETTING_NAME:
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
case PA_CONTEXT_FAILED:
|
||
|
|
case PA_CONTEXT_TERMINATED:
|
||
|
|
*pa_ready = 2;
|
||
|
|
break;
|
||
|
|
case PA_CONTEXT_READY:
|
||
|
|
*pa_ready = 1;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
&paReady);
|
||
|
|
|
||
|
|
while (true)
|
||
|
|
{
|
||
|
|
if (paReady == 0)
|
||
|
|
{
|
||
|
|
pa_mainloop_iterate(ml, 1, nullptr);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (paReady == 2)
|
||
|
|
{
|
||
|
|
pa_context_disconnect(ctx);
|
||
|
|
pa_context_unref(ctx);
|
||
|
|
pa_mainloop_free(ml);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (op == nullptr)
|
||
|
|
{
|
||
|
|
op = f(ctx);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (pa_operation_get_state(op) == PA_OPERATION_DONE)
|
||
|
|
{
|
||
|
|
pa_operation_unref(op);
|
||
|
|
pa_context_disconnect(ctx);
|
||
|
|
pa_context_unref(ctx);
|
||
|
|
pa_mainloop_free(ml);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
pa_mainloop_iterate(ml, 1, nullptr);
|
||
|
|
}
|
||
|
|
}
|