Dima353/openal-soft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Avoid using select()

Browse Source
This commit is contained in:
Chris Robinson
2018-12-24 09:58:48 -08:00
parent 95631aa358
commit cd213fe6b7
3 changed files with 54 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Alc/backends/oss.cpp
+25 -39
View File
@@ -33,6 +33,7 @@
#include <memory.h>
#include <unistd.h>
#include <errno.h>
#include <poll.h>
#include <math.h>
#include <atomic>
@@ -286,52 +287,44 @@ void ALCplaybackOSS_Destruct(ALCplaybackOSS *self)
int ALCplaybackOSS_mixerProc(ALCplaybackOSS *self)
{
ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
struct timeval timeout;
ALubyte *write_ptr;
ALint frame_size;
ALint to_write;
ssize_t wrote;
fd_set wfds;
int sret;
ALCdevice *device{STATIC_CAST(ALCbackend, self)->mDevice};
SetRTPriority();
althrd_setname(MIXER_THREAD_NAME);
frame_size = device->frameSizeFromFmt();
const int frame_size{device->frameSizeFromFmt()};
ALCplaybackOSS_lock(self);
while(!self->mKillNow.load(std::memory_order_acquire) &&
device->Connected.load(std::memory_order_acquire))
{
FD_ZERO(&wfds);
FD_SET(self->fd, &wfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
pollfd pollitem{};
pollitem.fd = self->fd;
pollitem.events = POLLOUT;
ALCplaybackOSS_unlock(self);
sret = select(self->fd+1, nullptr, &wfds, nullptr, &timeout);
int pret{poll(&pollitem, 1, 1000)};
ALCplaybackOSS_lock(self);
if(sret < 0)
if(pret < 0)
{
if(errno == EINTR)
if(errno == EINTR || errno == EAGAIN)
continue;
ERR("select failed: %s\n", strerror(errno));
ERR("poll failed: %s\n", strerror(errno));
aluHandleDisconnect(device, "Failed waiting for playback buffer: %s", strerror(errno));
break;
}
else if(sret == 0)
else if(pret == 0)
{
WARN("select timeout\n");
WARN("poll timeout\n");
continue;
}
write_ptr = self->mMixData.data();
to_write = self->mMixData.size();
ALubyte *write_ptr{self->mMixData.data()};
size_t to_write{self->mMixData.size()};
aluMixData(device, write_ptr, to_write/frame_size);
while(to_write > 0 && !self->mKillNow.load())
{
wrote = write(self->fd, write_ptr, to_write);
ssize_t wrote{write(self->fd, write_ptr, to_write)};
if(wrote < 0)
{
if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
@@ -544,44 +537,37 @@ void ALCcaptureOSS_Destruct(ALCcaptureOSS *self)
int ALCcaptureOSS_recordProc(ALCcaptureOSS *self)
{
ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
struct timeval timeout;
int frame_size;
fd_set rfds;
ssize_t amt;
int sret;
ALCdevice *device{STATIC_CAST(ALCbackend, self)->mDevice};
SetRTPriority();
althrd_setname(RECORD_THREAD_NAME);
frame_size = device->frameSizeFromFmt();
const int frame_size{device->frameSizeFromFmt()};
while(!self->mKillNow.load())
{
FD_ZERO(&rfds);
FD_SET(self->fd, &rfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
pollfd pollitem{};
pollitem.fd = self->fd;
pollitem.events = POLLIN;
sret = select(self->fd+1, &rfds, nullptr, nullptr, &timeout);
int sret{poll(&pollitem, 1, 1000)};
if(sret < 0)
{
if(errno == EINTR)
if(errno == EINTR || errno == EAGAIN)
continue;
ERR("select failed: %s\n", strerror(errno));
ERR("poll failed: %s\n", strerror(errno));
aluHandleDisconnect(device, "Failed to check capture samples: %s", strerror(errno));
break;
}
else if(sret == 0)
{
WARN("select timeout\n");
WARN("poll timeout\n");
continue;
}
auto vec = ll_ringbuffer_get_write_vector(self->mRing.get());
if(vec.first.len > 0)
{
amt = read(self->fd, vec.first.buf, vec.first.len*frame_size);
ssize_t amt{read(self->fd, vec.first.buf, vec.first.len*frame_size)};
if(amt < 0)
{
ERR("read failed: %s\n", strerror(errno));
Alc/backends/qsa.cpp
+14 -22
View File
@@ -27,6 +27,7 @@
#include <sched.h>
#include <errno.h>
#include <memory.h>
#include <poll.h>
#include <thread>
#include <memory>
@@ -36,7 +37,6 @@
#include "alu.h"
#include "threads.h"
#include <sys/select.h>
#include <sys/asoundlib.h>
#include <sys/neutrino.h>
@@ -196,9 +196,7 @@ FORCE_ALIGN static int qsa_proc_playback(void *ptr)
qsa_data *data = self->ExtraData;
snd_pcm_channel_status_t status;
struct sched_param param;
struct timeval timeout;
char* write_ptr;
fd_set wfds;
ALint len;
int sret;
@@ -215,24 +213,25 @@ FORCE_ALIGN static int qsa_proc_playback(void *ptr)
PlaybackWrapper_lock(self);
while(!data->mKillNow.load(std::memory_order_acquire))
{
FD_ZERO(&wfds);
FD_SET(data->audio_fd, &wfds);
timeout.tv_sec=2;
timeout.tv_usec=0;
pollfd pollitem{};
pollitem.fd = data->audio_fd;
pollitem.events = POLLOUT;
/* Select also works like time slice to OS */
PlaybackWrapper_unlock(self);
sret = select(data->audio_fd+1, NULL, &wfds, NULL, &timeout);
sret = poll(&pollitem, 1, 2000);
PlaybackWrapper_lock(self);
if(sret == -1)
{
ERR("select error: %s\n", strerror(errno));
if(errno == EINTR || errno == EAGAIN)
continue;
ERR("poll error: %s\n", strerror(errno));
aluHandleDisconnect(device, "Failed waiting for playback buffer: %s", strerror(errno));
break;
}
if(sret == 0)
{
ERR("select timeout\n");
ERR("poll timeout\n");
continue;
}
@@ -850,9 +849,7 @@ static ALCenum qsa_capture_samples(CaptureWrapper *self, ALCvoid *buffer, ALCuin
qsa_data *data = self->ExtraData.get();
char* read_ptr;
snd_pcm_channel_status_t status;
fd_set rfds;
int selectret;
struct timeval timeout;
int bytes_read;
ALint frame_size=device->frameSizeFromFmt();
ALint len=samples*frame_size;
@@ -862,14 +859,13 @@ static ALCenum qsa_capture_samples(CaptureWrapper *self, ALCvoid *buffer, ALCuin
while (len>0)
{
FD_ZERO(&rfds);
FD_SET(data->audio_fd, &rfds);
timeout.tv_sec=2;
timeout.tv_usec=0;
pollfd pollitem{};
pollitem.fd = data->audio_fd;
pollitem.events = POLLOUT;
/* Select also works like time slice to OS */
bytes_read=0;
selectret=select(data->audio_fd+1, &rfds, NULL, NULL, &timeout);
selectret = poll(&pollitem, 1, 2000);
switch (selectret)
{
case -1:
@@ -878,11 +874,7 @@ static ALCenum qsa_capture_samples(CaptureWrapper *self, ALCvoid *buffer, ALCuin
case 0:
break;
default:
if (FD_ISSET(data->audio_fd, &rfds))
{
bytes_read=snd_pcm_plugin_read(data->pcmHandle, read_ptr, len);
break;
}
bytes_read=snd_pcm_plugin_read(data->pcmHandle, read_ptr, len);
break;
}
Alc/backends/solaris.cpp
+15 -22
View File
@@ -32,6 +32,7 @@
#include <memory.h>
#include <unistd.h>
#include <errno.h>
#include <poll.h>
#include <math.h>
#include <thread>
@@ -102,52 +103,44 @@ static void ALCsolarisBackend_Destruct(ALCsolarisBackend *self)
static int ALCsolarisBackend_mixerProc(ALCsolarisBackend *self)
{
ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
struct timeval timeout;
ALubyte *write_ptr;
ALint frame_size;
ALint to_write;
ssize_t wrote;
fd_set wfds;
int sret;
ALCdevice *device{STATIC_CAST(ALCbackend, self)->mDevice};
SetRTPriority();
althrd_setname(MIXER_THREAD_NAME);
frame_size = device->frameSizeFromFmt();
const int frame_size{device->frameSizeFromFmt()};
ALCsolarisBackend_lock(self);
while(!self->mKillNow.load(std::memory_order_acquire) &&
device->Connected.load(std::memory_order_acquire))
{
FD_ZERO(&wfds);
FD_SET(self->fd, &wfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
pollfd pollitem{};
pollitem.fd = self->fd;
pollitem.events = POLLOUT;
ALCsolarisBackend_unlock(self);
sret = select(self->fd+1, nullptr, &wfds, nullptr, &timeout);
int pret{poll(&pollitem, 1, 1000)};
ALCsolarisBackend_lock(self);
if(sret < 0)
if(pret < 0)
{
if(errno == EINTR)
if(errno == EINTR || errno == EAGAIN)
continue;
ERR("select failed: %s\n", strerror(errno));
ERR("poll failed: %s\n", strerror(errno));
aluHandleDisconnect(device, "Failed to wait for playback buffer: %s", strerror(errno));
break;
}
else if(sret == 0)
else if(pret == 0)
{
WARN("select timeout\n");
WARN("poll timeout\n");
continue;
}
write_ptr = self->mix_data;
to_write = self->data_size;
ALubyte *write_ptr{self->mix_data};
int to_write{self->data_size};
aluMixData(device, write_ptr, to_write/frame_size);
while(to_write > 0 && !self->mKillNow.load())
{
wrote = write(self->fd, write_ptr, to_write);
ssize_t wrote{write(self->fd, write_ptr, to_write)};
if(wrote < 0)
{
if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)