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