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 "backends/sndio.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <thread>
  30 #include <functional>
  31
  32 #include "alcmain.h"
  33 #include "alu.h"
  34 #include "threads.h"
  35 #include "vector.h"
  36 #include "ringbuffer.h"
  37
  38 #include <sndio.h>
  39
  40
  41 namespace {
  42
  43 static const ALCchar sndio_device[] = "SndIO Default";
  44
  45
  46 struct SndioPlayback final : public BackendBase {
  47     SndioPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
  48     ~SndioPlayback() override;
  49
  50     int mixerProc();
  51
  52     ALCenum open(const ALCchar *name) override;
  53     bool reset() override;
  54     bool start() override;
  55     void stop() override;
  56
  57     sio_hdl *mSndHandle{nullptr};
  58
  59     al::vector<ALubyte> mBuffer;
  60
  61     std::atomic<bool> mKillNow{true};
  62     std::thread mThread;
  63
  64     DEF_NEWDEL(SndioPlayback)
  65 };
  66
  67 SndioPlayback::~SndioPlayback()
  68 {
  69     if(mSndHandle)
  70         sio_close(mSndHandle);
  71     mSndHandle = nullptr;
  72 }
  73
  74 int SndioPlayback::mixerProc()
  75 {
  76     SetRTPriority();
  77     althrd_setname(MIXER_THREAD_NAME);
  78
  79     const ALuint frameSize{mDevice->frameSizeFromFmt()};
  80
  81     while(!mKillNow.load(std::memory_order_acquire) &&
  82           mDevice->Connected.load(std::memory_order_acquire))
  83     {
  84         ALubyte *WritePtr{mBuffer.data()};
  85         size_t len{mBuffer.size()};
  86
  87         lock();
  88         aluMixData(mDevice, WritePtr, static_cast<ALuint>(len/frameSize));
  89         unlock();
  90         while(len > 0 && !mKillNow.load(std::memory_order_acquire))
  91         {
  92             size_t wrote{sio_write(mSndHandle, WritePtr, len)};
  93             if(wrote == 0)
  94             {
  95                 ERR("sio_write failed\n");
  96                 aluHandleDisconnect(mDevice, "Failed to write playback samples");
  97                 break;
  98             }
  99
 100             len -= wrote;
 101             WritePtr += wrote;
 102         }
 103     }
 104
 105     return 0;
 106 }
 107
 108
 109 ALCenum SndioPlayback::open(const ALCchar *name)
 110 {
 111     if(!name)
 112         name = sndio_device;
 113     else if(strcmp(name, sndio_device) != 0)
 114         return ALC_INVALID_VALUE;
 115
 116     mSndHandle = sio_open(nullptr, SIO_PLAY, 0);
 117     if(mSndHandle == nullptr)
 118     {
 119         ERR("Could not open device\n");
 120         return ALC_INVALID_VALUE;
 121     }
 122
 123     mDevice->DeviceName = name;
 124     return ALC_NO_ERROR;
 125 }
 126
 127 bool SndioPlayback::reset()
 128 {
 129     sio_par par;
 130     sio_initpar(&par);
 131
 132     par.rate = mDevice->Frequency;
 133     par.pchan = ((mDevice->FmtChans != DevFmtMono) ? 2 : 1);
 134
 135     switch(mDevice->FmtType)
 136     {
 137         case DevFmtByte:
 138             par.bits = 8;
 139             par.sig = 1;
 140             break;
 141         case DevFmtUByte:
 142             par.bits = 8;
 143             par.sig = 0;
 144             break;
 145         case DevFmtFloat:
 146         case DevFmtShort:
 147             par.bits = 16;
 148             par.sig = 1;
 149             break;
 150         case DevFmtUShort:
 151             par.bits = 16;
 152             par.sig = 0;
 153             break;
 154         case DevFmtInt:
 155             par.bits = 32;
 156             par.sig = 1;
 157             break;
 158         case DevFmtUInt:
 159             par.bits = 32;
 160             par.sig = 0;
 161             break;
 162     }
 163     par.le = SIO_LE_NATIVE;
 164
 165     par.round = mDevice->UpdateSize;
 166     par.appbufsz = mDevice->BufferSize - mDevice->UpdateSize;
 167     if(!par.appbufsz) par.appbufsz = mDevice->UpdateSize;
 168
 169     if(!sio_setpar(mSndHandle, &par) || !sio_getpar(mSndHandle, &par))
 170     {
 171         ERR("Failed to set device parameters\n");
 172         return false;
 173     }
 174
 175     if(par.bits != par.bps*8)
 176     {
 177         ERR("Padded samples not supported (%u of %u bits)\n", par.bits, par.bps*8);
 178         return true;
 179     }
 180
 181     mDevice->Frequency = par.rate;
 182     mDevice->FmtChans = ((par.pchan==1) ? DevFmtMono : DevFmtStereo);
 183
 184     if(par.bits == 8 && par.sig == 1)
 185         mDevice->FmtType = DevFmtByte;
 186     else if(par.bits == 8 && par.sig == 0)
 187         mDevice->FmtType = DevFmtUByte;
 188     else if(par.bits == 16 && par.sig == 1)
 189         mDevice->FmtType = DevFmtShort;
 190     else if(par.bits == 16 && par.sig == 0)
 191         mDevice->FmtType = DevFmtUShort;
 192     else if(par.bits == 32 && par.sig == 1)
 193         mDevice->FmtType = DevFmtInt;
 194     else if(par.bits == 32 && par.sig == 0)
 195         mDevice->FmtType = DevFmtUInt;
 196     else
 197     {
 198         ERR("Unhandled sample format: %s %u-bit\n", (par.sig?"signed":"unsigned"), par.bits);
 199         return false;
 200     }
 201
 202     SetDefaultChannelOrder(mDevice);
 203
 204     mDevice->UpdateSize = par.round;
 205     mDevice->BufferSize = par.bufsz + par.round;
 206
 207     mBuffer.resize(mDevice->UpdateSize * mDevice->frameSizeFromFmt());
 208     std::fill(mBuffer.begin(), mBuffer.end(), 0);
 209
 210     return true;
 211 }
 212
 213 bool SndioPlayback::start()
 214 {
 215     if(!sio_start(mSndHandle))
 216     {
 217         ERR("Error starting playback\n");
 218         return false;
 219     }
 220
 221     try {
 222         mKillNow.store(false, std::memory_order_release);
 223         mThread = std::thread{std::mem_fn(&SndioPlayback::mixerProc), this};
 224         return true;
 225     }
 226     catch(std::exception& e) {
 227         ERR("Could not create playback thread: %s\n", e.what());
 228     }
 229     catch(...) {
 230     }
 231     sio_stop(mSndHandle);
 232     return false;
 233 }
 234
 235 void SndioPlayback::stop()
 236 {
 237     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 238         return;
 239     mThread.join();
 240
 241     if(!sio_stop(mSndHandle))
 242         ERR("Error stopping device\n");
 243 }
 244
 245
 246 struct SndioCapture final : public BackendBase {
 247     SndioCapture(ALCdevice *device) noexcept : BackendBase{device} { }
 248     ~SndioCapture() override;
 249
 250     int recordProc();
 251
 252     ALCenum open(const ALCchar *name) override;
 253     bool start() override;
 254     void stop() override;
 255     ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
 256     ALCuint availableSamples() override;
 257
 258     sio_hdl *mSndHandle{nullptr};
 259
 260     RingBufferPtr mRing;
 261
 262     std::atomic<bool> mKillNow{true};
 263     std::thread mThread;
 264
 265     DEF_NEWDEL(SndioCapture)
 266 };
 267
 268 SndioCapture::~SndioCapture()
 269 {
 270     if(mSndHandle)
 271         sio_close(mSndHandle);
 272     mSndHandle = nullptr;
 273 }
 274
 275 int SndioCapture::recordProc()
 276 {
 277     SetRTPriority();
 278     althrd_setname(RECORD_THREAD_NAME);
 279
 280     const ALuint frameSize{mDevice->frameSizeFromFmt()};
 281
 282     while(!mKillNow.load(std::memory_order_acquire) &&
 283           mDevice->Connected.load(std::memory_order_acquire))
 284     {
 285         auto data = mRing->getWriteVector();
 286         size_t todo{data.first.len + data.second.len};
 287         if(todo == 0)
 288         {
 289             static char junk[4096];
 290             sio_read(mSndHandle, junk,
 291                 minz(sizeof(junk)/frameSize, mDevice->UpdateSize)*frameSize);
 292             continue;
 293         }
 294
 295         size_t total{0u};
 296         data.first.len  *= frameSize;
 297         data.second.len *= frameSize;
 298         todo = minz(todo, mDevice->UpdateSize) * frameSize;
 299         while(total < todo)
 300         {
 301             if(!data.first.len)
 302                 data.first = data.second;
 303
 304             size_t got{sio_read(mSndHandle, data.first.buf, minz(todo-total, data.first.len))};
 305             if(!got)
 306             {
 307                 aluHandleDisconnect(mDevice, "Failed to read capture samples");
 308                 break;
 309             }
 310
 311             data.first.buf += got;
 312             data.first.len -= got;
 313             total += got;
 314         }
 315         mRing->writeAdvance(total / frameSize);
 316     }
 317
 318     return 0;
 319 }
 320
 321
 322 ALCenum SndioCapture::open(const ALCchar *name)
 323 {
 324     if(!name)
 325         name = sndio_device;
 326     else if(strcmp(name, sndio_device) != 0)
 327         return ALC_INVALID_VALUE;
 328
 329     mSndHandle = sio_open(nullptr, SIO_REC, 0);
 330     if(mSndHandle == nullptr)
 331     {
 332         ERR("Could not open device\n");
 333         return ALC_INVALID_VALUE;
 334     }
 335
 336     sio_par par;
 337     sio_initpar(&par);
 338
 339     switch(mDevice->FmtType)
 340     {
 341         case DevFmtByte:
 342             par.bps = 1;
 343             par.sig = 1;
 344             break;
 345         case DevFmtUByte:
 346             par.bps = 1;
 347             par.sig = 0;
 348             break;
 349         case DevFmtShort:
 350             par.bps = 2;
 351             par.sig = 1;
 352             break;
 353         case DevFmtUShort:
 354             par.bps = 2;
 355             par.sig = 0;
 356             break;
 357         case DevFmtInt:
 358             par.bps = 4;
 359             par.sig = 1;
 360             break;
 361         case DevFmtUInt:
 362             par.bps = 4;
 363             par.sig = 0;
 364             break;
 365         case DevFmtFloat:
 366             ERR("%s capture samples not supported\n", DevFmtTypeString(mDevice->FmtType));
 367             return ALC_INVALID_VALUE;
 368     }
 369     par.bits = par.bps * 8;
 370     par.le = SIO_LE_NATIVE;
 371     par.msb = SIO_LE_NATIVE ? 0 : 1;
 372     par.rchan = mDevice->channelsFromFmt();
 373     par.rate = mDevice->Frequency;
 374
 375     par.appbufsz = maxu(mDevice->BufferSize, mDevice->Frequency/10);
 376     par.round = minu(par.appbufsz, mDevice->Frequency/40);
 377
 378     mDevice->UpdateSize = par.round;
 379     mDevice->BufferSize = par.appbufsz;
 380
 381     if(!sio_setpar(mSndHandle, &par) || !sio_getpar(mSndHandle, &par))
 382     {
 383         ERR("Failed to set device parameters\n");
 384         return ALC_INVALID_VALUE;
 385     }
 386
 387     if(par.bits != par.bps*8)
 388     {
 389         ERR("Padded samples not supported (%u of %u bits)\n", par.bits, par.bps*8);
 390         return ALC_INVALID_VALUE;
 391     }
 392
 393     if(!((mDevice->FmtType == DevFmtByte && par.bits == 8 && par.sig != 0) ||
 394          (mDevice->FmtType == DevFmtUByte && par.bits == 8 && par.sig == 0) ||
 395          (mDevice->FmtType == DevFmtShort && par.bits == 16 && par.sig != 0) ||
 396          (mDevice->FmtType == DevFmtUShort && par.bits == 16 && par.sig == 0) ||
 397          (mDevice->FmtType == DevFmtInt && par.bits == 32 && par.sig != 0) ||
 398          (mDevice->FmtType == DevFmtUInt && par.bits == 32 && par.sig == 0)) ||
 399        mDevice->channelsFromFmt() != par.rchan || mDevice->Frequency != par.rate)
 400     {
 401         ERR("Failed to set format %s %s %uhz, got %c%u %u-channel %uhz instead\n",
 402             DevFmtTypeString(mDevice->FmtType), DevFmtChannelsString(mDevice->FmtChans),
 403             mDevice->Frequency, par.sig?'s':'u', par.bits, par.rchan, par.rate);
 404         return ALC_INVALID_VALUE;
 405     }
 406
 407     mRing = CreateRingBuffer(mDevice->BufferSize, par.bps*par.rchan, false);
 408     if(!mRing)
 409     {
 410         ERR("Failed to allocate %u-byte ringbuffer\n", mDevice->BufferSize*par.bps*par.rchan);
 411         return ALC_OUT_OF_MEMORY;
 412     }
 413
 414     SetDefaultChannelOrder(mDevice);
 415
 416     mDevice->DeviceName = name;
 417     return ALC_NO_ERROR;
 418 }
 419
 420 bool SndioCapture::start()
 421 {
 422     if(!sio_start(mSndHandle))
 423     {
 424         ERR("Error starting playback\n");
 425         return false;
 426     }
 427
 428     try {
 429         mKillNow.store(false, std::memory_order_release);
 430         mThread = std::thread{std::mem_fn(&SndioCapture::recordProc), this};
 431         return true;
 432     }
 433     catch(std::exception& e) {
 434         ERR("Could not create record thread: %s\n", e.what());
 435     }
 436     catch(...) {
 437     }
 438     sio_stop(mSndHandle);
 439     return false;
 440 }
 441
 442 void SndioCapture::stop()
 443 {
 444     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 445         return;
 446     mThread.join();
 447
 448     if(!sio_stop(mSndHandle))
 449         ERR("Error stopping device\n");
 450 }
 451
 452 ALCenum SndioCapture::captureSamples(al::byte *buffer, ALCuint samples)
 453 {
 454     mRing->read(buffer, samples);
 455     return ALC_NO_ERROR;
 456 }
 457
 458 ALCuint SndioCapture::availableSamples()
 459 { return static_cast<ALCuint>(mRing->readSpace()); }
 460
 461 } // namespace
 462
 463 BackendFactory &SndIOBackendFactory::getFactory()
 464 {
 465     static SndIOBackendFactory factory{};
 466     return factory;
 467 }
 468
 469 bool SndIOBackendFactory::init()
 470 { return true; }
 471
 472 bool SndIOBackendFactory::querySupport(BackendType type)
 473 { return (type == BackendType::Playback || type == BackendType::Capture); }
 474
 475 void SndIOBackendFactory::probe(DevProbe type, std::string *outnames)
 476 {
 477     switch(type)
 478     {
 479         case DevProbe::Playback:
 480         case DevProbe::Capture:
 481             /* Includes null char. */
 482             outnames->append(sndio_device, sizeof(sndio_device));
 483             break;
 484     }
 485 }
 486
 487 BackendPtr SndIOBackendFactory::createBackend(ALCdevice *device, BackendType type)
 488 {
 489     if(type == BackendType::Playback)
 490         return BackendPtr{new SndioPlayback{device}};
 491     if(type == BackendType::Capture)
 492         return BackendPtr{new SndioCapture{device}};
 493     return nullptr;
 494 }