Alc/backends/oss.c

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