TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-12 23:24:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

update openal-soft to 1.24.3

Browse source 
keeping the alt 87514151c4 (diff-73a8dc1ce58605f6c5ea53548454c3bae516ec5132a29c9d7ff7edf9730c75be)
This commit is contained in:
AzaezelX 2025-09-03 11:09:27 -05:00
parent 12db0500e8
commit ba32094b7b
276 changed files with 49304 additions and 8712 deletions
Download patch file Download diff file Expand all files Collapse all files

127
Engine/lib/openal-soft/alc/backends/jack.cpp
View file

@ -29,18 +29,17 @@
#include <memory.h>
#include <mutex>
#include <thread>
#include <functional>
#include <vector>
#include "alc/alconfig.h"
#include "alnumeric.h"
#include "alsem.h"
#include "alstring.h"
#include "althrd_setname.h"
#include "core/device.h"
#include "core/helpers.h"
#include "core/logging.h"
#include "dynload.h"
#include "fmt/format.h"
#include "ringbuffer.h"
#include <jack/jack.h>
@ -51,7 +50,7 @@ namespace {
using namespace std::string_view_literals;
#ifdef HAVE_DYNLOAD
#if HAVE_DYNLOAD
#define JACK_FUNCS(MAGIC) \
MAGIC(jack_client_open); \
MAGIC(jack_client_close); \
@ -108,10 +107,12 @@ jack_options_t ClientOptions = JackNullOption;
bool jack_load()
{
#ifdef HAVE_DYNLOAD
#if HAVE_DYNLOAD
if(!jack_handle)
{
#ifdef _WIN32
#if defined(_WIN64)
#define JACKLIB "libjack64.dll"
#elif defined(_WIN32)
#define JACKLIB "libjack.dll"
#else
#define JACKLIB "libjack.so.0"
@ -119,7 +120,7 @@ bool jack_load()
jack_handle = LoadLib(JACKLIB);
if(!jack_handle)
{
WARN("Failed to load %s\n", JACKLIB);
WARN("Failed to load {}", JACKLIB);
return false;
}
@ -137,7 +138,7 @@ bool jack_load()
if(!missing_funcs.empty())
{
WARN("Missing expected functions:%s\n", missing_funcs.c_str());
WARN("Missing expected functions:{}", missing_funcs);
CloseLib(jack_handle);
jack_handle = nullptr;
return false;
@ -194,15 +195,15 @@ void EnumerateDevices(jack_client_t *client, std::vector<DeviceEntry> &list)
if(std::find_if(list.cbegin(), list.cend(), check_name) != list.cend())
continue;
const auto &entry = list.emplace_back(portdev, std::string{portdev}+":");
TRACE("Got device: %s = %s\n", entry.mName.c_str(), entry.mPattern.c_str());
const auto &entry = list.emplace_back(portdev, fmt::format("{}:", portdev));
TRACE("Got device: {} = {}", entry.mName, entry.mPattern);
}
/* There are ports but couldn't get device names from them. Add a
* generic entry.
*/
if(ports[0] && list.empty())
{
WARN("No device names found in available ports, adding a generic name.\n");
WARN("No device names found in available ports, adding a generic name.");
list.emplace_back("JACK"sv, ""sv);
}
}
@ -216,7 +217,7 @@ void EnumerateDevices(jack_client_t *client, std::vector<DeviceEntry> &list)
if(seppos >= nextpos || seppos == strpos)
{
const auto entry = std::string_view{*listopt}.substr(strpos, nextpos-strpos);
ERR("Invalid device entry: \"%.*s\"\n", al::sizei(entry), entry.data());
ERR("Invalid device entry: \"{}\"", entry);
if(nextpos != std::string::npos) ++nextpos;
strpos = nextpos;
continue;
@ -234,14 +235,13 @@ void EnumerateDevices(jack_client_t *client, std::vector<DeviceEntry> &list)
{
/* If so, replace the name with this custom one. */
itemmatch->mName = name;
TRACE("Customized device name: %s = %s\n", itemmatch->mName.c_str(),
itemmatch->mPattern.c_str());
TRACE("Customized device name: {} = {}", itemmatch->mName, itemmatch->mPattern);
}
else
{
/* Otherwise, add a new device entry. */
const auto &entry = list.emplace_back(name, pattern);
TRACE("Got custom device: %s = %s\n", entry.mName.c_str(), entry.mPattern.c_str());
TRACE("Got custom device: {} = {}", entry.mName, entry.mPattern);
}
if(nextpos != std::string::npos) ++nextpos;
@ -277,7 +277,7 @@ void EnumerateDevices(jack_client_t *client, std::vector<DeviceEntry> &list)
struct JackPlayback final : public BackendBase {
JackPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
explicit JackPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
~JackPlayback() override;
int processRt(jack_nframes_t numframes) noexcept;
@ -329,13 +329,13 @@ JackPlayback::~JackPlayback()
int JackPlayback::processRt(jack_nframes_t numframes) noexcept
{
auto outptrs = std::array<jack_default_audio_sample_t*,MaxOutputChannels>{};
auto outptrs = std::array<void*,MaxOutputChannels>{};
auto numchans = size_t{0};
for(auto port : mPort)
{
if(!port || numchans == mDevice->RealOut.Buffer.size())
break;
outptrs[numchans++] = static_cast<float*>(jack_port_get_buffer(port, numframes));
outptrs[numchans++] = jack_port_get_buffer(port, numframes);
}
const auto dst = al::span{outptrs}.first(numchans);
@ -343,8 +343,8 @@ int JackPlayback::processRt(jack_nframes_t numframes) noexcept
mDevice->renderSamples(dst, static_cast<uint>(numframes));
else
{
std::for_each(dst.begin(), dst.end(), [numframes](float *outbuf) -> void
{ std::fill_n(outbuf, numframes, 0.0f); });
std::for_each(dst.begin(), dst.end(), [numframes](void *outbuf) -> void
{ std::fill_n(static_cast<float*>(outbuf), numframes, 0.0f); });
}
return 0;
@ -365,13 +365,13 @@ int JackPlayback::process(jack_nframes_t numframes) noexcept
if(mPlaying.load(std::memory_order_acquire)) LIKELY
{
auto data = mRing->getReadVector();
const auto update_size = size_t{mDevice->UpdateSize};
const auto update_size = size_t{mDevice->mUpdateSize};
const auto outlen = size_t{numframes / update_size};
const auto len1 = size_t{std::min(data.first.len/update_size, outlen)};
const auto len2 = size_t{std::min(data.second.len/update_size, outlen-len1)};
const auto len1 = size_t{std::min(data[0].len/update_size, outlen)};
const auto len2 = size_t{std::min(data[1].len/update_size, outlen-len1)};
auto src = al::span{reinterpret_cast<float*>(data.first.buf), update_size*len1*numchans};
auto src = al::span{reinterpret_cast<float*>(data[0].buf), update_size*len1*numchans};
for(size_t i{0};i < len1;++i)
{
for(size_t c{0};c < numchans;++c)
@ -383,7 +383,7 @@ int JackPlayback::process(jack_nframes_t numframes) noexcept
total += update_size;
}
src = al::span{reinterpret_cast<float*>(data.second.buf), update_size*len2*numchans};
src = al::span{reinterpret_cast<float*>(data[1].buf), update_size*len2*numchans};
for(size_t i{0};i < len2;++i)
{
for(size_t c{0};c < numchans;++c)
@ -414,9 +414,9 @@ int JackPlayback::mixerProc()
SetRTPriority();
althrd_setname(GetMixerThreadName());
const auto update_size = uint{mDevice->UpdateSize};
const auto update_size = uint{mDevice->mUpdateSize};
const auto num_channels = size_t{mDevice->channelsFromFmt()};
auto outptrs = std::vector<float*>(num_channels);
auto outptrs = std::vector<void*>(num_channels);
while(!mKillNow.load(std::memory_order_acquire)
&& mDevice->Connected.load(std::memory_order_acquire))
@ -428,12 +428,11 @@ int JackPlayback::mixerProc()
}
auto data = mRing->getWriteVector();
const auto len1 = size_t{data.first.len / update_size};
const auto len2 = size_t{data.second.len / update_size};
const auto len1 = size_t{data[0].len / update_size};
const auto len2 = size_t{data[1].len / update_size};
std::lock_guard<std::mutex> dlock{mMutex};
auto buffer = al::span{reinterpret_cast<float*>(data.first.buf),
data.first.len*num_channels};
auto buffer = al::span{reinterpret_cast<float*>(data[0].buf), data[0].len*num_channels};
auto bufiter = buffer.begin();
for(size_t i{0};i < len1;++i)
{
@ -447,8 +446,7 @@ int JackPlayback::mixerProc()
}
if(len2 > 0)
{
buffer = al::span{reinterpret_cast<float*>(data.second.buf),
data.second.len*num_channels};
buffer = al::span{reinterpret_cast<float*>(data[1].buf), data[1].len*num_channels};
bufiter = buffer.begin();
for(size_t i{0};i < len2;++i)
{
@ -479,13 +477,14 @@ void JackPlayback::open(std::string_view name)
mClient = jack_client_open(client_name, ClientOptions, &status, nullptr);
if(mClient == nullptr)
throw al::backend_exception{al::backend_error::DeviceError,
"Failed to open client connection: 0x%02x", status};
"Failed to open client connection: {:#02x}",
as_unsigned(al::to_underlying(status))};
if((status&JackServerStarted))
TRACE("JACK server started\n");
TRACE("JACK server started");
if((status&JackNameNotUnique))
{
client_name = jack_get_client_name(mClient);
TRACE("Client name not unique, got '%s' instead\n", client_name);
TRACE("Client name not unique, got '{}' instead", client_name);
}
}
@ -504,11 +503,11 @@ void JackPlayback::open(std::string_view name)
auto iter = std::find_if(PlaybackList.cbegin(), PlaybackList.cend(), check_name);
if(iter == PlaybackList.cend())
throw al::backend_exception{al::backend_error::NoDevice,
"Device name \"%.*s\" not found", al::sizei(name), name.data()};
"Device name \"{}\" not found", name};
mPortPattern = iter->mPattern;
}
mDevice->DeviceName = name;
mDeviceName = name;
}
bool JackPlayback::reset()
@ -518,28 +517,29 @@ bool JackPlayback::reset()
std::for_each(mPort.begin(), mPort.end(), unregister_port);
mPort.fill(nullptr);
mRTMixing = GetConfigValueBool(mDevice->DeviceName, "jack", "rt-mix", true);
mRTMixing = GetConfigValueBool(mDevice->mDeviceName, "jack", "rt-mix", true);
jack_set_process_callback(mClient,
mRTMixing ? &JackPlayback::processRtC : &JackPlayback::processC, this);
/* Ignore the requested buffer metrics and just keep one JACK-sized buffer
* ready for when requested.
*/
mDevice->Frequency = jack_get_sample_rate(mClient);
mDevice->UpdateSize = jack_get_buffer_size(mClient);
mDevice->mSampleRate = jack_get_sample_rate(mClient);
mDevice->mUpdateSize = jack_get_buffer_size(mClient);
if(mRTMixing)
{
/* Assume only two periods when directly mixing. Should try to query
* the total port latency when connected.
*/
mDevice->BufferSize = mDevice->UpdateSize * 2;
mDevice->mBufferSize = mDevice->mUpdateSize * 2;
}
else
{
const std::string_view devname{mDevice->DeviceName};
uint bufsize{ConfigValueUInt(devname, "jack", "buffer-size").value_or(mDevice->UpdateSize)};
bufsize = std::max(NextPowerOf2(bufsize), mDevice->UpdateSize);
mDevice->BufferSize = bufsize + mDevice->UpdateSize;
const auto devname = std::string_view{mDevice->mDeviceName};
auto bufsize = ConfigValueUInt(devname, "jack", "buffer-size")
.value_or(mDevice->mUpdateSize);
bufsize = std::max(NextPowerOf2(bufsize), mDevice->mUpdateSize);
mDevice->mBufferSize = bufsize + mDevice->mUpdateSize;
}
/* Force 32-bit float output. */
@ -558,7 +558,7 @@ bool JackPlayback::reset()
}
if(bad_port != ports.end())
{
ERR("Failed to register enough JACK ports for %s output\n",
ERR("Failed to register enough JACK ports for {} output",
DevFmtChannelsString(mDevice->FmtChans));
if(bad_port == ports.begin()) return false;
@ -586,7 +586,7 @@ void JackPlayback::start()
if(jack_activate(mClient))
throw al::backend_exception{al::backend_error::DeviceError, "Failed to activate client"};
const std::string_view devname{mDevice->DeviceName};
const auto devname = std::string_view{mDevice->mDeviceName};
if(ConfigValueBool(devname, "jack", "connect-ports").value_or(true))
{
JackPortsPtr pnames{jack_get_ports(mClient, mPortPattern.c_str(), JACK_DEFAULT_AUDIO_TYPE,
@ -601,11 +601,11 @@ void JackPlayback::start()
{
if(!pnames[i])
{
ERR("No physical playback port for \"%s\"\n", jack_port_name(mPort[i]));
ERR("No physical playback port for \"{}\"", jack_port_name(mPort[i]));
break;
}
if(jack_connect(mClient, jack_port_name(mPort[i]), pnames[i]))
ERR("Failed to connect output port \"%s\" to \"%s\"\n", jack_port_name(mPort[i]),
ERR("Failed to connect output port \"{}\" to \"{}\"", jack_port_name(mPort[i]),
pnames[i]);
}
}
@ -614,31 +614,32 @@ void JackPlayback::start()
* (it won't change again after jack_activate), then allocate the ring
* buffer with the appropriate size.
*/
mDevice->Frequency = jack_get_sample_rate(mClient);
mDevice->UpdateSize = jack_get_buffer_size(mClient);
mDevice->BufferSize = mDevice->UpdateSize * 2;
mDevice->mSampleRate = jack_get_sample_rate(mClient);
mDevice->mUpdateSize = jack_get_buffer_size(mClient);
mDevice->mBufferSize = mDevice->mUpdateSize * 2;
mRing = nullptr;
if(mRTMixing)
mPlaying.store(true, std::memory_order_release);
else
{
uint bufsize{ConfigValueUInt(devname, "jack", "buffer-size").value_or(mDevice->UpdateSize)};
bufsize = std::max(NextPowerOf2(bufsize), mDevice->UpdateSize);
mDevice->BufferSize = bufsize + mDevice->UpdateSize;
uint bufsize{ConfigValueUInt(devname, "jack", "buffer-size")
.value_or(mDevice->mUpdateSize)};
bufsize = std::max(NextPowerOf2(bufsize), mDevice->mUpdateSize);
mDevice->mBufferSize = bufsize + mDevice->mUpdateSize;
mRing = RingBuffer::Create(bufsize, mDevice->frameSizeFromFmt(), true);
try {
mPlaying.store(true, std::memory_order_release);
mKillNow.store(false, std::memory_order_release);
mThread = std::thread{std::mem_fn(&JackPlayback::mixerProc), this};
mThread = std::thread{&JackPlayback::mixerProc, this};
}
catch(std::exception& e) {
jack_deactivate(mClient);
mPlaying.store(false, std::memory_order_release);
throw al::backend_exception{al::backend_error::DeviceError,
"Failed to start mixing thread: %s", e.what()};
"Failed to start mixing thread: {}", e.what()};
}
}
}
@ -665,8 +666,8 @@ ClockLatency JackPlayback::getClockLatency()
std::lock_guard<std::mutex> dlock{mMutex};
ClockLatency ret{};
ret.ClockTime = mDevice->getClockTime();
ret.Latency = std::chrono::seconds{mRing ? mRing->readSpace() : mDevice->UpdateSize};
ret.Latency /= mDevice->Frequency;
ret.Latency = std::chrono::seconds{mRing ? mRing->readSpace() : mDevice->mUpdateSize};
ret.Latency /= mDevice->mSampleRate;
return ret;
}
@ -674,7 +675,7 @@ ClockLatency JackPlayback::getClockLatency()
void jack_msg_handler(const char *message)
{
WARN("%s\n", message);
WARN("{}", message);
}
} // namespace
@ -697,9 +698,9 @@ bool JackBackendFactory::init()
jack_set_error_function(old_error_cb);
if(!client)
{
WARN("jack_client_open() failed, 0x%02x\n", status);
WARN("jack_client_open() failed, {:#02x}", as_unsigned(al::to_underlying(status)));
if((status&JackServerFailed) && !(ClientOptions&JackNoStartServer))
ERR("Unable to connect to JACK server\n");
ERR("Unable to connect to JACK server");
return false;
}
@ -728,7 +729,7 @@ auto JackBackendFactory::enumerate(BackendType type) -> std::vector<std::string>
jack_client_close(client);
}
else
WARN("jack_client_open() failed, 0x%02x\n", status);
WARN("jack_client_open() failed, {:#02x}", as_unsigned(al::to_underlying(status)));
outnames.reserve(PlaybackList.size());
std::for_each(PlaybackList.cbegin(), PlaybackList.cend(), append_name);
break;