alc/backends/sndio.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "sndio.h"
  24
  25 #include <cinttypes>
  26 #include <cstdio>
  27 #include <cstdlib>
  28 #include <cstring>
  29 #include <functional>
  30 #include <poll.h>
  31 #include <system_error>
  32 #include <thread>
  33 #include <vector>
  34
  35 #include "alnumeric.h"
  36 #include "alstring.h"
  37 #include "althrd_setname.h"
  38 #include "core/device.h"
  39 #include "core/helpers.h"
  40 #include "core/logging.h"
  41 #include "ringbuffer.h"
  42
  43 #include <sndio.h> /* NOLINT(*-duplicate-include) Not the same header. */
  44
  45
  46 namespace {
  47
  48 using namespace std::string_view_literals;
  49
  50 [[nodiscard]] constexpr auto GetDefaultName() noexcept { return "SndIO Default"sv; }
  51
  52 struct SioPar : public sio_par {
  53     SioPar() : sio_par{} { sio_initpar(this); }
  54
  55     void clear() { sio_initpar(this); }
  56 };
  57
  58 struct SndioPlayback final : public BackendBase {
  59     SndioPlayback(DeviceBase *device) noexcept : BackendBase{device} { }
  60     ~SndioPlayback() override;
  61
  62     int mixerProc();
  63
  64     void open(std::string_view name) override;
  65     bool reset() override;
  66     void start() override;
  67     void stop() override;
  68
  69     sio_hdl *mSndHandle{nullptr};
  70     uint mFrameStep{};
  71
  72     std::vector<std::byte> mBuffer;
  73
  74     std::atomic<bool> mKillNow{true};
  75     std::thread mThread;
  76 };
  77
  78 SndioPlayback::~SndioPlayback()
  79 {
  80     if(mSndHandle)
  81         sio_close(mSndHandle);
  82     mSndHandle = nullptr;
  83 }
  84
  85 int SndioPlayback::mixerProc()
  86 {
  87     const size_t frameStep{mFrameStep};
  88     const size_t frameSize{frameStep * mDevice->bytesFromFmt()};
  89
  90     SetRTPriority();
  91     althrd_setname(GetMixerThreadName());
  92
  93     while(!mKillNow.load(std::memory_order_acquire)
  94         && mDevice->Connected.load(std::memory_order_acquire))
  95     {
  96         al::span<std::byte> buffer{mBuffer};
  97
  98         mDevice->renderSamples(buffer.data(), static_cast<uint>(buffer.size() / frameSize),
  99             frameStep);
 100         while(!buffer.empty() && !mKillNow.load(std::memory_order_acquire))
 101         {
 102             size_t wrote{sio_write(mSndHandle, buffer.data(), buffer.size())};
 103             if(wrote > buffer.size() || wrote == 0)
 104             {
 105                 ERR("sio_write failed: 0x%" PRIx64 "\n", wrote);
 106                 mDevice->handleDisconnect("Failed to write playback samples");
 107                 break;
 108             }
 109             buffer = buffer.subspan(wrote);
 110         }
 111     }
 112
 113     return 0;
 114 }
 115
 116
 117 void SndioPlayback::open(std::string_view name)
 118 {
 119     if(name.empty())
 120         name = GetDefaultName();
 121     else if(name != GetDefaultName())
 122         throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%.*s\" not found",
 123             al::sizei(name), name.data()};
 124
 125     sio_hdl *sndHandle{sio_open(nullptr, SIO_PLAY, 0)};
 126     if(!sndHandle)
 127         throw al::backend_exception{al::backend_error::NoDevice, "Could not open backend device"};
 128
 129     if(mSndHandle)
 130         sio_close(mSndHandle);
 131     mSndHandle = sndHandle;
 132
 133     mDevice->DeviceName = name;
 134 }
 135
 136 bool SndioPlayback::reset()
 137 {
 138     SioPar par;
 139
 140     auto tryfmt = mDevice->FmtType;
 141     while(true)
 142     {
 143         switch(tryfmt)
 144         {
 145         case DevFmtByte:
 146             par.bits = 8;
 147             par.sig = 1;
 148             break;
 149         case DevFmtUByte:
 150             par.bits = 8;
 151             par.sig = 0;
 152             break;
 153         case DevFmtShort:
 154             par.bits = 16;
 155             par.sig = 1;
 156             break;
 157         case DevFmtUShort:
 158             par.bits = 16;
 159             par.sig = 0;
 160             break;
 161         case DevFmtFloat:
 162         case DevFmtInt:
 163             par.bits = 32;
 164             par.sig = 1;
 165             break;
 166         case DevFmtUInt:
 167             par.bits = 32;
 168             par.sig = 0;
 169             break;
 170         }
 171         par.bps = SIO_BPS(par.bits);
 172         par.le = SIO_LE_NATIVE;
 173         par.msb = 1;
 174
 175         par.rate = mDevice->Frequency;
 176         par.pchan = mDevice->channelsFromFmt();
 177
 178         par.round = mDevice->UpdateSize;
 179         par.appbufsz = mDevice->BufferSize - mDevice->UpdateSize;
 180         if(!par.appbufsz) par.appbufsz = mDevice->UpdateSize;
 181
 182         try {
 183             if(!sio_setpar(mSndHandle, &par))
 184                 throw al::backend_exception{al::backend_error::DeviceError,
 185                     "Failed to set device parameters"};
 186
 187             par.clear();
 188             if(!sio_getpar(mSndHandle, &par))
 189                 throw al::backend_exception{al::backend_error::DeviceError,
 190                     "Failed to get device parameters"};
 191
 192             if(par.bps > 1 && par.le != SIO_LE_NATIVE)
 193                 throw al::backend_exception{al::backend_error::DeviceError,
 194                     "%s-endian samples not supported", par.le ? "Little" : "Big"};
 195             if(par.bits < par.bps*8 && !par.msb)
 196                 throw al::backend_exception{al::backend_error::DeviceError,
 197                     "MSB-padded samples not supported (%u of %u bits)", par.bits, par.bps*8};
 198             if(par.pchan < 1)
 199                 throw al::backend_exception{al::backend_error::DeviceError,
 200                     "No playback channels on device"};
 201
 202             break;
 203         }
 204         catch(al::backend_exception &e) {
 205             if(tryfmt == DevFmtShort)
 206                 throw;
 207             par.clear();
 208             tryfmt = DevFmtShort;
 209         }
 210     }
 211
 212     if(par.bps == 1)
 213         mDevice->FmtType = (par.sig==1) ? DevFmtByte : DevFmtUByte;
 214     else if(par.bps == 2)
 215         mDevice->FmtType = (par.sig==1) ? DevFmtShort : DevFmtUShort;
 216     else if(par.bps == 4)
 217         mDevice->FmtType = (par.sig==1) ? DevFmtInt : DevFmtUInt;
 218     else
 219         throw al::backend_exception{al::backend_error::DeviceError,
 220             "Unhandled sample format: %s %u-bit", (par.sig?"signed":"unsigned"), par.bps*8};
 221
 222     mFrameStep = par.pchan;
 223     if(par.pchan != mDevice->channelsFromFmt())
 224     {
 225         WARN("Got %u channel%s for %s\n", par.pchan, (par.pchan==1)?"":"s",
 226             DevFmtChannelsString(mDevice->FmtChans));
 227         if(par.pchan < 2) mDevice->FmtChans = DevFmtMono;
 228         else mDevice->FmtChans = DevFmtStereo;
 229     }
 230     mDevice->Frequency = par.rate;
 231
 232     setDefaultChannelOrder();
 233
 234     mDevice->UpdateSize = par.round;
 235     mDevice->BufferSize = par.bufsz + par.round;
 236
 237     mBuffer.resize(size_t{mDevice->UpdateSize} * par.pchan*par.bps);
 238     if(par.sig == 1)
 239         std::fill(mBuffer.begin(), mBuffer.end(), std::byte{});
 240     else if(par.bits == 8)
 241         std::fill_n(mBuffer.data(), mBuffer.size(), std::byte(0x80));
 242     else if(par.bits == 16)
 243         std::fill_n(reinterpret_cast<uint16_t*>(mBuffer.data()), mBuffer.size()/2, 0x8000);
 244     else if(par.bits == 32)
 245         std::fill_n(reinterpret_cast<uint32_t*>(mBuffer.data()), mBuffer.size()/4, 0x80000000u);
 246
 247     return true;
 248 }
 249
 250 void SndioPlayback::start()
 251 {
 252     if(!sio_start(mSndHandle))
 253         throw al::backend_exception{al::backend_error::DeviceError, "Error starting playback"};
 254
 255     try {
 256         mKillNow.store(false, std::memory_order_release);
 257         mThread = std::thread{std::mem_fn(&SndioPlayback::mixerProc), this};
 258     }
 259     catch(std::exception& e) {
 260         sio_stop(mSndHandle);
 261         throw al::backend_exception{al::backend_error::DeviceError,
 262             "Failed to start mixing thread: %s", e.what()};
 263     }
 264 }
 265
 266 void SndioPlayback::stop()
 267 {
 268     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 269         return;
 270     mThread.join();
 271
 272     if(!sio_stop(mSndHandle))
 273         ERR("Error stopping device\n");
 274 }
 275
 276
 277 /* TODO: This could be improved by avoiding the ring buffer and record thread,
 278  * counting the available samples with the sio_onmove callback and reading
 279  * directly from the device. However, this depends on reasonable support for
 280  * capture buffer sizes apps may request.
 281  */
 282 struct SndioCapture final : public BackendBase {
 283     SndioCapture(DeviceBase *device) noexcept : BackendBase{device} { }
 284     ~SndioCapture() override;
 285
 286     int recordProc();
 287
 288     void open(std::string_view name) override;
 289     void start() override;
 290     void stop() override;
 291     void captureSamples(std::byte *buffer, uint samples) override;
 292     uint availableSamples() override;
 293
 294     sio_hdl *mSndHandle{nullptr};
 295
 296     RingBufferPtr mRing;
 297
 298     std::atomic<bool> mKillNow{true};
 299     std::thread mThread;
 300 };
 301
 302 SndioCapture::~SndioCapture()
 303 {
 304     if(mSndHandle)
 305         sio_close(mSndHandle);
 306     mSndHandle = nullptr;
 307 }
 308
 309 int SndioCapture::recordProc()
 310 {
 311     SetRTPriority();
 312     althrd_setname(GetRecordThreadName());
 313
 314     const uint frameSize{mDevice->frameSizeFromFmt()};
 315
 316     int nfds_pre{sio_nfds(mSndHandle)};
 317     if(nfds_pre <= 0)
 318     {
 319         mDevice->handleDisconnect("Incorrect return value from sio_nfds(): %d", nfds_pre);
 320         return 1;
 321     }
 322
 323     auto fds = std::vector<pollfd>(static_cast<uint>(nfds_pre));
 324
 325     while(!mKillNow.load(std::memory_order_acquire)
 326         && mDevice->Connected.load(std::memory_order_acquire))
 327     {
 328         /* Wait until there's some samples to read. */
 329         const int nfds{sio_pollfd(mSndHandle, fds.data(), POLLIN)};
 330         if(nfds <= 0)
 331         {
 332             mDevice->handleDisconnect("Failed to get polling fds: %d", nfds);
 333             break;
 334         }
 335         int pollres{::poll(fds.data(), fds.size(), 2000)};
 336         if(pollres < 0)
 337         {
 338             if(errno == EINTR) continue;
 339             mDevice->handleDisconnect("Poll error: %s",
 340                 std::generic_category().message(errno).c_str());
 341             break;
 342         }
 343         if(pollres == 0)
 344             continue;
 345
 346         const int revents{sio_revents(mSndHandle, fds.data())};
 347         if((revents&POLLHUP))
 348         {
 349             mDevice->handleDisconnect("Got POLLHUP from poll events");
 350             break;
 351         }
 352         if(!(revents&POLLIN))
 353             continue;
 354
 355         auto data = mRing->getWriteVector();
 356         al::span<std::byte> buffer{data.first.buf, data.first.len*frameSize};
 357         while(!buffer.empty())
 358         {
 359             size_t got{sio_read(mSndHandle, buffer.data(), buffer.size())};
 360             if(got == 0)
 361                 break;
 362             if(got > buffer.size())
 363             {
 364                 ERR("sio_read failed: 0x%" PRIx64 "\n", got);
 365                 mDevice->handleDisconnect("sio_read failed: 0x%" PRIx64, got);
 366                 break;
 367             }
 368
 369             mRing->writeAdvance(got / frameSize);
 370             buffer = buffer.subspan(got);
 371             if(buffer.empty())
 372             {
 373                 data = mRing->getWriteVector();
 374                 buffer = {data.first.buf, data.first.len*frameSize};
 375             }
 376         }
 377         if(buffer.empty())
 378         {
 379             /* Got samples to read, but no place to store it. Drop it. */
 380             static std::array<char,4096> junk;
 381             sio_read(mSndHandle, junk.data(), junk.size() - (junk.size()%frameSize));
 382         }
 383     }
 384
 385     return 0;
 386 }
 387
 388
 389 void SndioCapture::open(std::string_view name)
 390 {
 391     if(name.empty())
 392         name = GetDefaultName();
 393     else if(name != GetDefaultName())
 394         throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%.*s\" not found",
 395             al::sizei(name), name.data()};
 396
 397     mSndHandle = sio_open(nullptr, SIO_REC, true);
 398     if(mSndHandle == nullptr)
 399         throw al::backend_exception{al::backend_error::NoDevice, "Could not open backend device"};
 400
 401     SioPar par;
 402     switch(mDevice->FmtType)
 403     {
 404     case DevFmtByte:
 405         par.bits = 8;
 406         par.sig = 1;
 407         break;
 408     case DevFmtUByte:
 409         par.bits = 8;
 410         par.sig = 0;
 411         break;
 412     case DevFmtShort:
 413         par.bits = 16;
 414         par.sig = 1;
 415         break;
 416     case DevFmtUShort:
 417         par.bits = 16;
 418         par.sig = 0;
 419         break;
 420     case DevFmtInt:
 421         par.bits = 32;
 422         par.sig = 1;
 423         break;
 424     case DevFmtUInt:
 425         par.bits = 32;
 426         par.sig = 0;
 427         break;
 428     case DevFmtFloat:
 429         throw al::backend_exception{al::backend_error::DeviceError,
 430             "%s capture samples not supported", DevFmtTypeString(mDevice->FmtType)};
 431     }
 432     par.bps = SIO_BPS(par.bits);
 433     par.le = SIO_LE_NATIVE;
 434     par.msb = 1;
 435     par.rchan = mDevice->channelsFromFmt();
 436     par.rate = mDevice->Frequency;
 437
 438     par.appbufsz = std::max(mDevice->BufferSize, mDevice->Frequency/10u);
 439     par.round = std::min(par.appbufsz/2u, mDevice->Frequency/40u);
 440
 441     if(!sio_setpar(mSndHandle, &par) || !sio_getpar(mSndHandle, &par))
 442         throw al::backend_exception{al::backend_error::DeviceError,
 443             "Failed to set device parameters"};
 444
 445     if(par.bps > 1 && par.le != SIO_LE_NATIVE)
 446         throw al::backend_exception{al::backend_error::DeviceError,
 447             "%s-endian samples not supported", par.le ? "Little" : "Big"};
 448     if(par.bits < par.bps*8 && !par.msb)
 449         throw al::backend_exception{al::backend_error::DeviceError,
 450             "Padded samples not supported (got %u of %u bits)", par.bits, par.bps*8};
 451
 452     auto match_fmt = [](DevFmtType fmttype, const sio_par &p) -> bool
 453     {
 454         return (fmttype == DevFmtByte && p.bps == 1 && p.sig != 0)
 455             || (fmttype == DevFmtUByte && p.bps == 1 && p.sig == 0)
 456             || (fmttype == DevFmtShort && p.bps == 2 && p.sig != 0)
 457             || (fmttype == DevFmtUShort && p.bps == 2 && p.sig == 0)
 458             || (fmttype == DevFmtInt && p.bps == 4 && p.sig != 0)
 459             || (fmttype == DevFmtUInt && p.bps == 4 && p.sig == 0);
 460     };
 461     if(!match_fmt(mDevice->FmtType, par) || mDevice->channelsFromFmt() != par.rchan
 462         || mDevice->Frequency != par.rate)
 463         throw al::backend_exception{al::backend_error::DeviceError,
 464             "Failed to set format %s %s %uhz, got %c%u %u-channel %uhz instead",
 465             DevFmtTypeString(mDevice->FmtType), DevFmtChannelsString(mDevice->FmtChans),
 466             mDevice->Frequency, par.sig?'s':'u', par.bps*8, par.rchan, par.rate};
 467
 468     mRing = RingBuffer::Create(mDevice->BufferSize, size_t{par.bps}*par.rchan, false);
 469     mDevice->BufferSize = static_cast<uint>(mRing->writeSpace());
 470     mDevice->UpdateSize = par.round;
 471
 472     setDefaultChannelOrder();
 473
 474     mDevice->DeviceName = name;
 475 }
 476
 477 void SndioCapture::start()
 478 {
 479     if(!sio_start(mSndHandle))
 480         throw al::backend_exception{al::backend_error::DeviceError, "Error starting capture"};
 481
 482     try {
 483         mKillNow.store(false, std::memory_order_release);
 484         mThread = std::thread{std::mem_fn(&SndioCapture::recordProc), this};
 485     }
 486     catch(std::exception& e) {
 487         sio_stop(mSndHandle);
 488         throw al::backend_exception{al::backend_error::DeviceError,
 489             "Failed to start capture thread: %s", e.what()};
 490     }
 491 }
 492
 493 void SndioCapture::stop()
 494 {
 495     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 496         return;
 497     mThread.join();
 498
 499     if(!sio_stop(mSndHandle))
 500         ERR("Error stopping device\n");
 501 }
 502
 503 void SndioCapture::captureSamples(std::byte *buffer, uint samples)
 504 { std::ignore = mRing->read(buffer, samples); }
 505
 506 uint SndioCapture::availableSamples()
 507 { return static_cast<uint>(mRing->readSpace()); }
 508
 509 } // namespace
 510
 511 BackendFactory &SndIOBackendFactory::getFactory()
 512 {
 513     static SndIOBackendFactory factory{};
 514     return factory;
 515 }
 516
 517 bool SndIOBackendFactory::init()
 518 { return true; }
 519
 520 bool SndIOBackendFactory::querySupport(BackendType type)
 521 { return (type == BackendType::Playback || type == BackendType::Capture); }
 522
 523 auto SndIOBackendFactory::enumerate(BackendType type) -> std::vector<std::string>
 524 {
 525     switch(type)
 526     {
 527     case BackendType::Playback:
 528     case BackendType::Capture:
 529         return std::vector{std::string{GetDefaultName()}};
 530     }
 531     return {};
 532 }
 533
 534 BackendPtr SndIOBackendFactory::createBackend(DeviceBase *device, BackendType type)
 535 {
 536     if(type == BackendType::Playback)
 537         return BackendPtr{new SndioPlayback{device}};
 538     if(type == BackendType::Capture)
 539         return BackendPtr{new SndioCapture{device}};
 540     return nullptr;
 541 }