From 3d92e8c4df4ebaffbe44507f787f2382e3982c96 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Fri, 28 Dec 2018 22:56:20 -0800 Subject: Convert the backends to use proper inheritence --- Alc/backends/jack.cpp | 199 ++++++++++++++++++++++---------------------------- 1 file changed, 87 insertions(+), 112 deletions(-) (limited to 'Alc/backends/jack.cpp') diff --git a/Alc/backends/jack.cpp b/Alc/backends/jack.cpp index 26086bf9..77bbf487 100644 --- a/Alc/backends/jack.cpp +++ b/Alc/backends/jack.cpp @@ -148,9 +148,9 @@ ALCboolean jack_load(void) } -struct ALCjackPlayback final : public ALCbackend { - ALCjackPlayback(ALCdevice *device) noexcept : ALCbackend{device} { } - ~ALCjackPlayback() override; +struct JackPlayback final : public BackendBase { + JackPlayback(ALCdevice *device) noexcept : BackendBase{device} { } + ~JackPlayback() override; static int bufferSizeNotifyC(jack_nframes_t numframes, void *arg); int bufferSizeNotify(jack_nframes_t numframes); @@ -160,6 +160,12 @@ struct ALCjackPlayback final : public ALCbackend { int mixerProc(); + ALCenum open(const ALCchar *name) override; + ALCboolean reset() override; + ALCboolean start() override; + void stop() override; + ClockLatency getClockLatency() override; + jack_client_t *mClient{nullptr}; jack_port_t *mPort[MAX_OUTPUT_CHANNELS]{}; @@ -168,34 +174,12 @@ struct ALCjackPlayback final : public ALCbackend { std::atomic mKillNow{true}; std::thread mThread; -}; - -void ALCjackPlayback_Construct(ALCjackPlayback *self, ALCdevice *device); -void ALCjackPlayback_Destruct(ALCjackPlayback *self); -ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name); -ALCboolean ALCjackPlayback_reset(ALCjackPlayback *self); -ALCboolean ALCjackPlayback_start(ALCjackPlayback *self); -void ALCjackPlayback_stop(ALCjackPlayback *self); -DECLARE_FORWARD2(ALCjackPlayback, ALCbackend, ALCenum, captureSamples, void*, ALCuint) -DECLARE_FORWARD(ALCjackPlayback, ALCbackend, ALCuint, availableSamples) -ClockLatency ALCjackPlayback_getClockLatency(ALCjackPlayback *self); -DECLARE_FORWARD(ALCjackPlayback, ALCbackend, void, lock) -DECLARE_FORWARD(ALCjackPlayback, ALCbackend, void, unlock) -DECLARE_DEFAULT_ALLOCATORS(ALCjackPlayback) - -DEFINE_ALCBACKEND_VTABLE(ALCjackPlayback); + static constexpr inline const char *CurrentPrefix() noexcept { return "JackPlayback::"; } + DEF_NEWDEL(JackPlayback) +}; -void ALCjackPlayback_Construct(ALCjackPlayback *self, ALCdevice *device) -{ - new (self) ALCjackPlayback{device}; - SET_VTABLE2(ALCjackPlayback, ALCbackend, self); -} - -void ALCjackPlayback_Destruct(ALCjackPlayback *self) -{ self->~ALCjackPlayback(); } - -ALCjackPlayback::~ALCjackPlayback() +JackPlayback::~JackPlayback() { if(!mClient) return; @@ -210,12 +194,12 @@ ALCjackPlayback::~ALCjackPlayback() } -int ALCjackPlayback::bufferSizeNotifyC(jack_nframes_t numframes, void *arg) -{ return static_cast(arg)->bufferSizeNotify(numframes); } +int JackPlayback::bufferSizeNotifyC(jack_nframes_t numframes, void *arg) +{ return static_cast(arg)->bufferSizeNotify(numframes); } -int ALCjackPlayback::bufferSizeNotify(jack_nframes_t numframes) +int JackPlayback::bufferSizeNotify(jack_nframes_t numframes) { - ALCjackPlayback_lock(this); + lock(); mDevice->UpdateSize = numframes; mDevice->NumUpdates = 2; @@ -233,15 +217,15 @@ int ALCjackPlayback::bufferSizeNotify(jack_nframes_t numframes) ERR("Failed to reallocate ringbuffer\n"); aluHandleDisconnect(mDevice, "Failed to reallocate %u-sample buffer", bufsize); } - ALCjackPlayback_unlock(this); + unlock(); return 0; } -int ALCjackPlayback::processC(jack_nframes_t numframes, void *arg) -{ return static_cast(arg)->process(numframes); } +int JackPlayback::processC(jack_nframes_t numframes, void *arg) +{ return static_cast(arg)->process(numframes); } -int ALCjackPlayback::process(jack_nframes_t numframes) +int JackPlayback::process(jack_nframes_t numframes) { jack_default_audio_sample_t *out[MAX_OUTPUT_CHANNELS]; ALsizei numchans{0}; @@ -311,20 +295,20 @@ int ALCjackPlayback::process(jack_nframes_t numframes) return 0; } -int ALCjackPlayback::mixerProc() +int JackPlayback::mixerProc() { SetRTPriority(); althrd_setname(MIXER_THREAD_NAME); - ALCjackPlayback_lock(this); + lock(); while(!mKillNow.load(std::memory_order_acquire) && mDevice->Connected.load(std::memory_order_acquire)) { if(mRing->writeSpace() < mDevice->UpdateSize) { - ALCjackPlayback_unlock(this); + unlock(); mSem.wait(); - ALCjackPlayback_lock(this); + lock(); continue; } @@ -340,13 +324,13 @@ int ALCjackPlayback::mixerProc() aluMixData(mDevice, data.second.buf, len2); mRing->writeAdvance(todo); } - ALCjackPlayback_unlock(this); + unlock(); return 0; } -ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name) +ALCenum JackPlayback::open(const ALCchar *name) { if(!name) name = jackDevice; @@ -355,8 +339,8 @@ ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name) const char *client_name{"alsoft"}; jack_status_t status; - self->mClient = jack_client_open(client_name, ClientOptions, &status, nullptr); - if(self->mClient == nullptr) + mClient = jack_client_open(client_name, ClientOptions, &status, nullptr); + if(mClient == nullptr) { ERR("jack_client_open() failed, status = 0x%02x\n", status); return ALC_INVALID_VALUE; @@ -365,104 +349,102 @@ ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name) TRACE("JACK server started\n"); if((status&JackNameNotUnique)) { - client_name = jack_get_client_name(self->mClient); + client_name = jack_get_client_name(mClient); TRACE("Client name not unique, got `%s' instead\n", client_name); } - jack_set_process_callback(self->mClient, &ALCjackPlayback::processC, self); - jack_set_buffer_size_callback(self->mClient, &ALCjackPlayback::bufferSizeNotifyC, self); + jack_set_process_callback(mClient, &JackPlayback::processC, this); + jack_set_buffer_size_callback(mClient, &JackPlayback::bufferSizeNotifyC, this); - ALCdevice *device{self->mDevice}; - device->DeviceName = name; + mDevice->DeviceName = name; return ALC_NO_ERROR; } -ALCboolean ALCjackPlayback_reset(ALCjackPlayback *self) +ALCboolean JackPlayback::reset() { - std::for_each(std::begin(self->mPort), std::end(self->mPort), - [self](jack_port_t *port) -> void - { if(port) jack_port_unregister(self->mClient, port); } + std::for_each(std::begin(mPort), std::end(mPort), + [this](jack_port_t *port) -> void + { if(port) jack_port_unregister(mClient, port); } ); - std::fill(std::begin(self->mPort), std::end(self->mPort), nullptr); + std::fill(std::begin(mPort), std::end(mPort), nullptr); /* Ignore the requested buffer metrics and just keep one JACK-sized buffer * ready for when requested. */ - ALCdevice *device{self->mDevice}; - device->Frequency = jack_get_sample_rate(self->mClient); - device->UpdateSize = jack_get_buffer_size(self->mClient); - device->NumUpdates = 2; + mDevice->Frequency = jack_get_sample_rate(mClient); + mDevice->UpdateSize = jack_get_buffer_size(mClient); + mDevice->NumUpdates = 2; - ALuint bufsize{device->UpdateSize}; - if(ConfigValueUInt(device->DeviceName.c_str(), "jack", "buffer-size", &bufsize)) - bufsize = maxu(NextPowerOf2(bufsize), device->UpdateSize); - device->NumUpdates = (bufsize+device->UpdateSize) / device->UpdateSize; + ALuint bufsize{mDevice->UpdateSize}; + if(ConfigValueUInt(mDevice->DeviceName.c_str(), "jack", "buffer-size", &bufsize)) + bufsize = maxu(NextPowerOf2(bufsize), mDevice->UpdateSize); + mDevice->NumUpdates = (bufsize+mDevice->UpdateSize) / mDevice->UpdateSize; /* Force 32-bit float output. */ - device->FmtType = DevFmtFloat; + mDevice->FmtType = DevFmtFloat; - ALsizei numchans{device->channelsFromFmt()}; - auto ports_end = std::begin(self->mPort) + numchans; - auto bad_port = std::find_if_not(std::begin(self->mPort), ports_end, - [self](jack_port_t *&port) -> bool + ALsizei numchans{mDevice->channelsFromFmt()}; + auto ports_end = std::begin(mPort) + numchans; + auto bad_port = std::find_if_not(std::begin(mPort), ports_end, + [this](jack_port_t *&port) -> bool { - std::string name{"channel_" + std::to_string(&port - self->mPort + 1)}; - port = jack_port_register(self->mClient, name.c_str(), JACK_DEFAULT_AUDIO_TYPE, + std::string name{"channel_" + std::to_string(&port - mPort + 1)}; + port = jack_port_register(mClient, name.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); return port != nullptr; } ); if(bad_port != ports_end) { - ERR("Not enough JACK ports available for %s output\n", DevFmtChannelsString(device->FmtChans)); - if(bad_port == std::begin(self->mPort)) return ALC_FALSE; + ERR("Not enough JACK ports available for %s output\n", DevFmtChannelsString(mDevice->FmtChans)); + if(bad_port == std::begin(mPort)) return ALC_FALSE; - if(bad_port == std::begin(self->mPort)+1) - device->FmtChans = DevFmtMono; + if(bad_port == std::begin(mPort)+1) + mDevice->FmtChans = DevFmtMono; else { - ports_end = self->mPort+2; + ports_end = mPort+2; while(bad_port != ports_end) { - jack_port_unregister(self->mClient, *(--bad_port)); + jack_port_unregister(mClient, *(--bad_port)); *bad_port = nullptr; } - device->FmtChans = DevFmtStereo; + mDevice->FmtChans = DevFmtStereo; } - numchans = std::distance(std::begin(self->mPort), bad_port); + numchans = std::distance(std::begin(mPort), bad_port); } - self->mRing = nullptr; - self->mRing = CreateRingBuffer(bufsize, device->frameSizeFromFmt(), true); - if(!self->mRing) + mRing = nullptr; + mRing = CreateRingBuffer(bufsize, mDevice->frameSizeFromFmt(), true); + if(!mRing) { ERR("Failed to allocate ringbuffer\n"); return ALC_FALSE; } - SetDefaultChannelOrder(device); + SetDefaultChannelOrder(mDevice); return ALC_TRUE; } -ALCboolean ALCjackPlayback_start(ALCjackPlayback *self) +ALCboolean JackPlayback::start() { - if(jack_activate(self->mClient)) + if(jack_activate(mClient)) { ERR("Failed to activate client\n"); return ALC_FALSE; } - const char **ports{jack_get_ports(self->mClient, nullptr, nullptr, + const char **ports{jack_get_ports(mClient, nullptr, nullptr, JackPortIsPhysical|JackPortIsInput)}; if(ports == nullptr) { ERR("No physical playback ports found\n"); - jack_deactivate(self->mClient); + jack_deactivate(mClient); return ALC_FALSE; } - std::mismatch(std::begin(self->mPort), std::end(self->mPort), ports, - [self](const jack_port_t *port, const char *pname) -> bool + std::mismatch(std::begin(mPort), std::end(mPort), ports, + [this](const jack_port_t *port, const char *pname) -> bool { if(!port) return false; if(!pname) @@ -470,7 +452,7 @@ ALCboolean ALCjackPlayback_start(ALCjackPlayback *self) ERR("No physical playback port for \"%s\"\n", jack_port_name(port)); return false; } - if(jack_connect(self->mClient, jack_port_name(port), pname)) + if(jack_connect(mClient, jack_port_name(port), pname)) ERR("Failed to connect output port \"%s\" to \"%s\"\n", jack_port_name(port), pname); return true; @@ -479,8 +461,8 @@ ALCboolean ALCjackPlayback_start(ALCjackPlayback *self) jack_free(ports); try { - self->mKillNow.store(false, std::memory_order_release); - self->mThread = std::thread(std::mem_fn(&ALCjackPlayback::mixerProc), self); + mKillNow.store(false, std::memory_order_release); + mThread = std::thread{std::mem_fn(&JackPlayback::mixerProc), this}; return ALC_TRUE; } catch(std::exception& e) { @@ -488,33 +470,31 @@ ALCboolean ALCjackPlayback_start(ALCjackPlayback *self) } catch(...) { } - jack_deactivate(self->mClient); + jack_deactivate(mClient); return ALC_FALSE; } -void ALCjackPlayback_stop(ALCjackPlayback *self) +void JackPlayback::stop() { - if(self->mKillNow.exchange(true, std::memory_order_acq_rel) || !self->mThread.joinable()) + if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable()) return; - self->mSem.post(); - self->mThread.join(); + mSem.post(); + mThread.join(); - jack_deactivate(self->mClient); + jack_deactivate(mClient); } -ClockLatency ALCjackPlayback_getClockLatency(ALCjackPlayback *self) +ClockLatency JackPlayback::getClockLatency() { ClockLatency ret; - ALCjackPlayback_lock(self); - ALCdevice *device{self->mDevice}; - RingBuffer *ring{self->mRing.get()}; - ret.ClockTime = GetDeviceClockTime(device); - ret.Latency = std::chrono::seconds{ring->readSpace()}; - ret.Latency /= device->Frequency; - ALCjackPlayback_unlock(self); + lock(); + ret.ClockTime = GetDeviceClockTime(mDevice); + ret.Latency = std::chrono::seconds{mRing->readSpace()}; + ret.Latency /= mDevice->Frequency; + unlock(); return ret; } @@ -578,15 +558,10 @@ void JackBackendFactory::probe(DevProbe type, std::string *outnames) } } -ALCbackend *JackBackendFactory::createBackend(ALCdevice *device, ALCbackend_Type type) +BackendBase *JackBackendFactory::createBackend(ALCdevice *device, ALCbackend_Type type) { if(type == ALCbackend_Playback) - { - ALCjackPlayback *backend; - NEW_OBJ(backend, ALCjackPlayback)(device); - return backend; - } - + return new JackPlayback{device}; return nullptr; } -- cgit v1.2.3