alc/backends/oss.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/oss.h"
  24
  25 #include <fcntl.h>
  26 #include <poll.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #include <algorithm>
  32 #include <atomic>
  33 #include <cerrno>
  34 #include <cstdio>
  35 #include <cstring>
  36 #include <exception>
  37 #include <functional>
  38 #include <memory>
  39 #include <new>
  40 #include <string>
  41 #include <thread>
  42 #include <utility>
  43
  44 #include "AL/al.h"
  45
  46 #include "alcmain.h"
  47 #include "alconfig.h"
  48 #include "almalloc.h"
  49 #include "alnumeric.h"
  50 #include "aloptional.h"
  51 #include "alu.h"
  52 #include "logging.h"
  53 #include "ringbuffer.h"
  54 #include "threads.h"
  55 #include "vector.h"
  56
  57 #include <sys/soundcard.h>
  58
  59 /*
  60  * The OSS documentation talks about SOUND_MIXER_READ, but the header
  61  * only contains MIXER_READ. Play safe. Same for WRITE.
  62  */
  63 #ifndef SOUND_MIXER_READ
  64 #define SOUND_MIXER_READ MIXER_READ
  65 #endif
  66 #ifndef SOUND_MIXER_WRITE
  67 #define SOUND_MIXER_WRITE MIXER_WRITE
  68 #endif
  69
  70 #if defined(SOUND_VERSION) && (SOUND_VERSION < 0x040000)
  71 #define ALC_OSS_COMPAT
  72 #endif
  73 #ifndef SNDCTL_AUDIOINFO
  74 #define ALC_OSS_COMPAT
  75 #endif
  76
  77 /*
  78  * FreeBSD strongly discourages the use of specific devices,
  79  * such as those returned in oss_audioinfo.devnode
  80  */
  81 #ifdef __FreeBSD__
  82 #define ALC_OSS_DEVNODE_TRUC
  83 #endif
  84
  85 namespace {
  86
  87 constexpr char DefaultName[] = "OSS Default";
  88 std::string DefaultPlayback{"/dev/dsp"};
  89 std::string DefaultCapture{"/dev/dsp"};
  90
  91 struct DevMap {
  92     std::string name;
  93     std::string device_name;
  94 };
  95
  96 bool checkName(const al::vector<DevMap> &list, const std::string &name)
  97 {
  98     return std::find_if(list.cbegin(), list.cend(),
  99         [&name](const DevMap &entry) -> bool
 100         { return entry.name == name; }
 101     ) != list.cend();
 102 }
 103
 104 al::vector<DevMap> PlaybackDevices;
 105 al::vector<DevMap> CaptureDevices;
 106
 107
 108 #ifdef ALC_OSS_COMPAT
 109
 110 #define DSP_CAP_OUTPUT 0x00020000
 111 #define DSP_CAP_INPUT 0x00010000
 112 void ALCossListPopulate(al::vector<DevMap> *devlist, int type)
 113 {
 114     devlist->emplace_back(DevMap{DefaultName, (type==DSP_CAP_INPUT) ? DefaultCapture : DefaultPlayback});
 115 }
 116
 117 #else
 118
 119 void ALCossListAppend(al::vector<DevMap> *list, const char *handle, size_t hlen, const char *path, size_t plen)
 120 {
 121 #ifdef ALC_OSS_DEVNODE_TRUC
 122     for(size_t i{0};i < plen;i++)
 123     {
 124         if(path[i] == '.')
 125         {
 126             if(strncmp(path + i, handle + hlen + i - plen, plen - i) == 0)
 127                 hlen = hlen + i - plen;
 128             plen = i;
 129         }
 130     }
 131 #endif
 132     if(handle[0] == '\0')
 133     {
 134         handle = path;
 135         hlen = plen;
 136     }
 137
 138     std::string basename{handle, hlen};
 139     basename.erase(std::find(basename.begin(), basename.end(), '\0'), basename.end());
 140     std::string devname{path, plen};
 141     devname.erase(std::find(devname.begin(), devname.end(), '\0'), devname.end());
 142
 143     auto iter = std::find_if(list->cbegin(), list->cend(),
 144         [&devname](const DevMap &entry) -> bool
 145         { return entry.device_name == devname; }
 146     );
 147     if(iter != list->cend())
 148         return;
 149
 150     int count{1};
 151     std::string newname{basename};
 152     while(checkName(PlaybackDevices, newname))
 153     {
 154         newname = basename;
 155         newname += " #";
 156         newname += std::to_string(++count);
 157     }
 158
 159     list->emplace_back(DevMap{std::move(newname), std::move(devname)});
 160     const DevMap &entry = list->back();
 161
 162     TRACE("Got device \"%s\", \"%s\"\n", entry.name.c_str(), entry.device_name.c_str());
 163 }
 164
 165 void ALCossListPopulate(al::vector<DevMap> *devlist, int type_flag)
 166 {
 167     int fd{open("/dev/mixer", O_RDONLY)};
 168     if(fd < 0)
 169     {
 170         TRACE("Could not open /dev/mixer: %s\n", strerror(errno));
 171         goto done;
 172     }
 173
 174     oss_sysinfo si;
 175     if(ioctl(fd, SNDCTL_SYSINFO, &si) == -1)
 176     {
 177         TRACE("SNDCTL_SYSINFO failed: %s\n", strerror(errno));
 178         goto done;
 179     }
 180
 181     for(int i{0};i < si.numaudios;i++)
 182     {
 183         oss_audioinfo ai;
 184         ai.dev = i;
 185         if(ioctl(fd, SNDCTL_AUDIOINFO, &ai) == -1)
 186         {
 187             ERR("SNDCTL_AUDIOINFO (%d) failed: %s\n", i, strerror(errno));
 188             continue;
 189         }
 190         if(!(ai.caps&type_flag) || ai.devnode[0] == '\0')
 191             continue;
 192
 193         const char *handle;
 194         size_t len;
 195         if(ai.handle[0] != '\0')
 196         {
 197             len = strnlen(ai.handle, sizeof(ai.handle));
 198             handle = ai.handle;
 199         }
 200         else
 201         {
 202             len = strnlen(ai.name, sizeof(ai.name));
 203             handle = ai.name;
 204         }
 205
 206         ALCossListAppend(devlist, handle, len, ai.devnode,
 207                          strnlen(ai.devnode, sizeof(ai.devnode)));
 208     }
 209
 210 done:
 211     if(fd >= 0)
 212         close(fd);
 213     fd = -1;
 214
 215     const char *defdev{((type_flag==DSP_CAP_INPUT) ? DefaultCapture : DefaultPlayback).c_str()};
 216     auto iter = std::find_if(devlist->cbegin(), devlist->cend(),
 217         [defdev](const DevMap &entry) -> bool
 218         { return entry.device_name == defdev; }
 219     );
 220     if(iter == devlist->cend())
 221         devlist->insert(devlist->begin(), DevMap{DefaultName, defdev});
 222     else
 223     {
 224         DevMap entry{std::move(*iter)};
 225         devlist->erase(iter);
 226         devlist->insert(devlist->begin(), std::move(entry));
 227     }
 228     devlist->shrink_to_fit();
 229 }
 230
 231 #endif
 232
 233 ALCuint log2i(ALCuint x)
 234 {
 235     ALCuint y{0};
 236     while(x > 1)
 237     {
 238         x >>= 1;
 239         y++;
 240     }
 241     return y;
 242 }
 243
 244
 245 struct OSSPlayback final : public BackendBase {
 246     OSSPlayback(ALCdevice *device) noexcept : BackendBase{device} { }
 247     ~OSSPlayback() override;
 248
 249     int mixerProc();
 250
 251     ALCenum open(const ALCchar *name) override;
 252     bool reset() override;
 253     bool start() override;
 254     void stop() override;
 255
 256     int mFd{-1};
 257
 258     al::vector<ALubyte> mMixData;
 259
 260     std::atomic<bool> mKillNow{true};
 261     std::thread mThread;
 262
 263     DEF_NEWDEL(OSSPlayback)
 264 };
 265
 266 OSSPlayback::~OSSPlayback()
 267 {
 268     if(mFd != -1)
 269         close(mFd);
 270     mFd = -1;
 271 }
 272
 273
 274 int OSSPlayback::mixerProc()
 275 {
 276     SetRTPriority();
 277     althrd_setname(MIXER_THREAD_NAME);
 278
 279     const ALuint frame_size{mDevice->frameSizeFromFmt()};
 280
 281     lock();
 282     while(!mKillNow.load(std::memory_order_acquire) &&
 283           mDevice->Connected.load(std::memory_order_acquire))
 284     {
 285         pollfd pollitem{};
 286         pollitem.fd = mFd;
 287         pollitem.events = POLLOUT;
 288
 289         unlock();
 290         int pret{poll(&pollitem, 1, 1000)};
 291         lock();
 292         if(pret < 0)
 293         {
 294             if(errno == EINTR || errno == EAGAIN)
 295                 continue;
 296             ERR("poll failed: %s\n", strerror(errno));
 297             aluHandleDisconnect(mDevice, "Failed waiting for playback buffer: %s", strerror(errno));
 298             break;
 299         }
 300         else if(pret == 0)
 301         {
 302             WARN("poll timeout\n");
 303             continue;
 304         }
 305
 306         ALubyte *write_ptr{mMixData.data()};
 307         size_t to_write{mMixData.size()};
 308         aluMixData(mDevice, write_ptr, static_cast<ALuint>(to_write/frame_size));
 309         while(to_write > 0 && !mKillNow.load(std::memory_order_acquire))
 310         {
 311             ssize_t wrote{write(mFd, write_ptr, to_write)};
 312             if(wrote < 0)
 313             {
 314                 if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 315                     continue;
 316                 ERR("write failed: %s\n", strerror(errno));
 317                 aluHandleDisconnect(mDevice, "Failed writing playback samples: %s",
 318                                     strerror(errno));
 319                 break;
 320             }
 321
 322             to_write -= static_cast<size_t>(wrote);
 323             write_ptr += wrote;
 324         }
 325     }
 326     unlock();
 327
 328     return 0;
 329 }
 330
 331
 332 ALCenum OSSPlayback::open(const ALCchar *name)
 333 {
 334     const char *devname{DefaultPlayback.c_str()};
 335     if(!name)
 336         name = DefaultName;
 337     else
 338     {
 339         if(PlaybackDevices.empty())
 340             ALCossListPopulate(&PlaybackDevices, DSP_CAP_OUTPUT);
 341
 342         auto iter = std::find_if(PlaybackDevices.cbegin(), PlaybackDevices.cend(),
 343             [&name](const DevMap &entry) -> bool
 344             { return entry.name == name; }
 345         );
 346         if(iter == PlaybackDevices.cend())
 347             return ALC_INVALID_VALUE;
 348         devname = iter->device_name.c_str();
 349     }
 350
 351     mFd = ::open(devname, O_WRONLY);
 352     if(mFd == -1)
 353     {
 354         ERR("Could not open %s: %s\n", devname, strerror(errno));
 355         return ALC_INVALID_VALUE;
 356     }
 357
 358     mDevice->DeviceName = name;
 359     return ALC_NO_ERROR;
 360 }
 361
 362 bool OSSPlayback::reset()
 363 {
 364     int ossFormat{};
 365     switch(mDevice->FmtType)
 366     {
 367         case DevFmtByte:
 368             ossFormat = AFMT_S8;
 369             break;
 370         case DevFmtUByte:
 371             ossFormat = AFMT_U8;
 372             break;
 373         case DevFmtUShort:
 374         case DevFmtInt:
 375         case DevFmtUInt:
 376         case DevFmtFloat:
 377             mDevice->FmtType = DevFmtShort;
 378             /* fall-through */
 379         case DevFmtShort:
 380             ossFormat = AFMT_S16_NE;
 381             break;
 382     }
 383
 384     ALuint periods{mDevice->BufferSize / mDevice->UpdateSize};
 385     ALuint numChannels{mDevice->channelsFromFmt()};
 386     ALuint ossSpeed{mDevice->Frequency};
 387     ALuint frameSize{numChannels * mDevice->bytesFromFmt()};
 388     /* According to the OSS spec, 16 bytes (log2(16)) is the minimum. */
 389     ALuint log2FragmentSize{maxu(log2i(mDevice->UpdateSize*frameSize), 4)};
 390     ALuint numFragmentsLogSize{(periods << 16) | log2FragmentSize};
 391
 392     audio_buf_info info{};
 393     const char *err;
 394 #define CHECKERR(func) if((func) < 0) {                                       \
 395     err = #func;                                                              \
 396     goto err;                                                                 \
 397 }
 398     /* Don't fail if SETFRAGMENT fails. We can handle just about anything
 399      * that's reported back via GETOSPACE */
 400     ioctl(mFd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize);
 401     CHECKERR(ioctl(mFd, SNDCTL_DSP_SETFMT, &ossFormat));
 402     CHECKERR(ioctl(mFd, SNDCTL_DSP_CHANNELS, &numChannels));
 403     CHECKERR(ioctl(mFd, SNDCTL_DSP_SPEED, &ossSpeed));
 404     CHECKERR(ioctl(mFd, SNDCTL_DSP_GETOSPACE, &info));
 405     if(0)
 406     {
 407     err:
 408         ERR("%s failed: %s\n", err, strerror(errno));
 409         return false;
 410     }
 411 #undef CHECKERR
 412
 413     if(mDevice->channelsFromFmt() != numChannels)
 414     {
 415         ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(mDevice->FmtChans),
 416             numChannels);
 417         return false;
 418     }
 419
 420     if(!((ossFormat == AFMT_S8 && mDevice->FmtType == DevFmtByte) ||
 421          (ossFormat == AFMT_U8 && mDevice->FmtType == DevFmtUByte) ||
 422          (ossFormat == AFMT_S16_NE && mDevice->FmtType == DevFmtShort)))
 423     {
 424         ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(mDevice->FmtType),
 425             ossFormat);
 426         return false;
 427     }
 428
 429     mDevice->Frequency = ossSpeed;
 430     mDevice->UpdateSize = static_cast<ALuint>(info.fragsize) / frameSize;
 431     mDevice->BufferSize = static_cast<ALuint>(info.fragments) * mDevice->UpdateSize;
 432
 433     SetDefaultChannelOrder(mDevice);
 434
 435     mMixData.resize(mDevice->UpdateSize * mDevice->frameSizeFromFmt());
 436
 437     return true;
 438 }
 439
 440 bool OSSPlayback::start()
 441 {
 442     try {
 443         mKillNow.store(false, std::memory_order_release);
 444         mThread = std::thread{std::mem_fn(&OSSPlayback::mixerProc), this};
 445         return true;
 446     }
 447     catch(std::exception& e) {
 448         ERR("Could not create playback thread: %s\n", e.what());
 449     }
 450     catch(...) {
 451     }
 452     return false;
 453 }
 454
 455 void OSSPlayback::stop()
 456 {
 457     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 458         return;
 459     mThread.join();
 460
 461     if(ioctl(mFd, SNDCTL_DSP_RESET) != 0)
 462         ERR("Error resetting device: %s\n", strerror(errno));
 463 }
 464
 465
 466 struct OSScapture final : public BackendBase {
 467     OSScapture(ALCdevice *device) noexcept : BackendBase{device} { }
 468     ~OSScapture() override;
 469
 470     int recordProc();
 471
 472     ALCenum open(const ALCchar *name) override;
 473     bool start() override;
 474     void stop() override;
 475     ALCenum captureSamples(al::byte *buffer, ALCuint samples) override;
 476     ALCuint availableSamples() override;
 477
 478     int mFd{-1};
 479
 480     RingBufferPtr mRing{nullptr};
 481
 482     std::atomic<bool> mKillNow{true};
 483     std::thread mThread;
 484
 485     DEF_NEWDEL(OSScapture)
 486 };
 487
 488 OSScapture::~OSScapture()
 489 {
 490     if(mFd != -1)
 491         close(mFd);
 492     mFd = -1;
 493 }
 494
 495
 496 int OSScapture::recordProc()
 497 {
 498     SetRTPriority();
 499     althrd_setname(RECORD_THREAD_NAME);
 500
 501     const ALuint frame_size{mDevice->frameSizeFromFmt()};
 502     while(!mKillNow.load(std::memory_order_acquire))
 503     {
 504         pollfd pollitem{};
 505         pollitem.fd = mFd;
 506         pollitem.events = POLLIN;
 507
 508         int sret{poll(&pollitem, 1, 1000)};
 509         if(sret < 0)
 510         {
 511             if(errno == EINTR || errno == EAGAIN)
 512                 continue;
 513             ERR("poll failed: %s\n", strerror(errno));
 514             aluHandleDisconnect(mDevice, "Failed to check capture samples: %s", strerror(errno));
 515             break;
 516         }
 517         else if(sret == 0)
 518         {
 519             WARN("poll timeout\n");
 520             continue;
 521         }
 522
 523         auto vec = mRing->getWriteVector();
 524         if(vec.first.len > 0)
 525         {
 526             ssize_t amt{read(mFd, vec.first.buf, vec.first.len*frame_size)};
 527             if(amt < 0)
 528             {
 529                 ERR("read failed: %s\n", strerror(errno));
 530                 aluHandleDisconnect(mDevice, "Failed reading capture samples: %s",
 531                     strerror(errno));
 532                 break;
 533             }
 534             mRing->writeAdvance(static_cast<ALuint>(amt)/frame_size);
 535         }
 536     }
 537
 538     return 0;
 539 }
 540
 541
 542 ALCenum OSScapture::open(const ALCchar *name)
 543 {
 544     const char *devname{DefaultCapture.c_str()};
 545     if(!name)
 546         name = DefaultName;
 547     else
 548     {
 549         if(CaptureDevices.empty())
 550             ALCossListPopulate(&CaptureDevices, DSP_CAP_INPUT);
 551
 552         auto iter = std::find_if(CaptureDevices.cbegin(), CaptureDevices.cend(),
 553             [&name](const DevMap &entry) -> bool
 554             { return entry.name == name; }
 555         );
 556         if(iter == CaptureDevices.cend())
 557             return ALC_INVALID_VALUE;
 558         devname = iter->device_name.c_str();
 559     }
 560
 561     mFd = ::open(devname, O_RDONLY);
 562     if(mFd == -1)
 563     {
 564         ERR("Could not open %s: %s\n", devname, strerror(errno));
 565         return ALC_INVALID_VALUE;
 566     }
 567
 568     int ossFormat{};
 569     switch(mDevice->FmtType)
 570     {
 571         case DevFmtByte:
 572             ossFormat = AFMT_S8;
 573             break;
 574         case DevFmtUByte:
 575             ossFormat = AFMT_U8;
 576             break;
 577         case DevFmtShort:
 578             ossFormat = AFMT_S16_NE;
 579             break;
 580         case DevFmtUShort:
 581         case DevFmtInt:
 582         case DevFmtUInt:
 583         case DevFmtFloat:
 584             ERR("%s capture samples not supported\n", DevFmtTypeString(mDevice->FmtType));
 585             return ALC_INVALID_VALUE;
 586     }
 587
 588     ALuint periods{4};
 589     ALuint numChannels{mDevice->channelsFromFmt()};
 590     ALuint frameSize{numChannels * mDevice->bytesFromFmt()};
 591     ALuint ossSpeed{mDevice->Frequency};
 592     /* according to the OSS spec, 16 bytes are the minimum */
 593     ALuint log2FragmentSize{maxu(log2i(mDevice->BufferSize * frameSize / periods), 4)};
 594     ALuint numFragmentsLogSize{(periods << 16) | log2FragmentSize};
 595
 596     audio_buf_info info{};
 597     const char *err;
 598 #define CHECKERR(func) if((func) < 0) {                                       \
 599     err = #func;                                                              \
 600     goto err;                                                                 \
 601 }
 602     CHECKERR(ioctl(mFd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize));
 603     CHECKERR(ioctl(mFd, SNDCTL_DSP_SETFMT, &ossFormat));
 604     CHECKERR(ioctl(mFd, SNDCTL_DSP_CHANNELS, &numChannels));
 605     CHECKERR(ioctl(mFd, SNDCTL_DSP_SPEED, &ossSpeed));
 606     CHECKERR(ioctl(mFd, SNDCTL_DSP_GETISPACE, &info));
 607     if(0)
 608     {
 609     err:
 610         ERR("%s failed: %s\n", err, strerror(errno));
 611         close(mFd);
 612         mFd = -1;
 613         return ALC_INVALID_VALUE;
 614     }
 615 #undef CHECKERR
 616
 617     if(mDevice->channelsFromFmt() != numChannels)
 618     {
 619         ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(mDevice->FmtChans),
 620             numChannels);
 621         close(mFd);
 622         mFd = -1;
 623         return ALC_INVALID_VALUE;
 624     }
 625
 626     if(!((ossFormat == AFMT_S8 && mDevice->FmtType == DevFmtByte) ||
 627          (ossFormat == AFMT_U8 && mDevice->FmtType == DevFmtUByte) ||
 628          (ossFormat == AFMT_S16_NE && mDevice->FmtType == DevFmtShort)))
 629     {
 630         ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(mDevice->FmtType), ossFormat);
 631         close(mFd);
 632         mFd = -1;
 633         return ALC_INVALID_VALUE;
 634     }
 635
 636     mRing = CreateRingBuffer(mDevice->BufferSize, frameSize, false);
 637     if(!mRing)
 638     {
 639         ERR("Ring buffer create failed\n");
 640         close(mFd);
 641         mFd = -1;
 642         return ALC_OUT_OF_MEMORY;
 643     }
 644
 645     mDevice->DeviceName = name;
 646     return ALC_NO_ERROR;
 647 }
 648
 649 bool OSScapture::start()
 650 {
 651     try {
 652         mKillNow.store(false, std::memory_order_release);
 653         mThread = std::thread{std::mem_fn(&OSScapture::recordProc), this};
 654         return true;
 655     }
 656     catch(std::exception& e) {
 657         ERR("Could not create record thread: %s\n", e.what());
 658     }
 659     catch(...) {
 660     }
 661     return false;
 662 }
 663
 664 void OSScapture::stop()
 665 {
 666     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 667         return;
 668     mThread.join();
 669
 670     if(ioctl(mFd, SNDCTL_DSP_RESET) != 0)
 671         ERR("Error resetting device: %s\n", strerror(errno));
 672 }
 673
 674 ALCenum OSScapture::captureSamples(al::byte *buffer, ALCuint samples)
 675 {
 676     mRing->read(buffer, samples);
 677     return ALC_NO_ERROR;
 678 }
 679
 680 ALCuint OSScapture::availableSamples()
 681 { return static_cast<ALCuint>(mRing->readSpace()); }
 682
 683 } // namespace
 684
 685
 686 BackendFactory &OSSBackendFactory::getFactory()
 687 {
 688     static OSSBackendFactory factory{};
 689     return factory;
 690 }
 691
 692 bool OSSBackendFactory::init()
 693 {
 694     if(auto devopt = ConfigValueStr(nullptr, "oss", "device"))
 695         DefaultPlayback = std::move(*devopt);
 696     if(auto capopt = ConfigValueStr(nullptr, "oss", "capture"))
 697         DefaultCapture = std::move(*capopt);
 698
 699     return true;
 700 }
 701
 702 bool OSSBackendFactory::querySupport(BackendType type)
 703 { return (type == BackendType::Playback || type == BackendType::Capture); }
 704
 705 void OSSBackendFactory::probe(DevProbe type, std::string *outnames)
 706 {
 707     auto add_device = [outnames](const DevMap &entry) -> void
 708     {
 709 #ifdef HAVE_STAT
 710         struct stat buf;
 711         if(stat(entry.device_name.c_str(), &buf) == 0)
 712 #endif
 713         {
 714             /* Includes null char. */
 715             outnames->append(entry.name.c_str(), entry.name.length()+1);
 716         }
 717     };
 718
 719     switch(type)
 720     {
 721         case DevProbe::Playback:
 722             PlaybackDevices.clear();
 723             ALCossListPopulate(&PlaybackDevices, DSP_CAP_OUTPUT);
 724             std::for_each(PlaybackDevices.cbegin(), PlaybackDevices.cend(), add_device);
 725             break;
 726
 727         case DevProbe::Capture:
 728             CaptureDevices.clear();
 729             ALCossListPopulate(&CaptureDevices, DSP_CAP_INPUT);
 730             std::for_each(CaptureDevices.cbegin(), CaptureDevices.cend(), add_device);
 731             break;
 732     }
 733 }
 734
 735 BackendPtr OSSBackendFactory::createBackend(ALCdevice *device, BackendType type)
 736 {
 737     if(type == BackendType::Playback)
 738         return BackendPtr{new OSSPlayback{device}};
 739     if(type == BackendType::Capture)
 740         return BackendPtr{new OSScapture{device}};
 741     return nullptr;
 742 }