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         ERR("Could not open /dev/mixer\n");
 167         return;
 168     }
 169     if(ioctl(fd, SNDCTL_SYSINFO, &si) == -1)
 170     {
 171         ERR("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);
 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);
 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) != 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(device->FmtChans, device->FmtType);
 475     self->mix_data = calloc(1, self->data_size);
 476
 477     ATOMIC_STORE_SEQ(&self->killNow, AL_FALSE);
 478     if(althrd_create(&self->thread, ALCplaybackOSS_mixerProc, self) != althrd_success)
 479     {
 480         free(self->mix_data);
 481         self->mix_data = NULL;
 482         return ALC_FALSE;
 483     }
 484
 485     return ALC_TRUE;
 486 }
 487
 488 static void ALCplaybackOSS_stop(ALCplaybackOSS *self)
 489 {
 490     int res;
 491
 492     if(ATOMIC_EXCHANGE_SEQ(ALenum, &self->killNow, AL_TRUE))
 493         return;
 494     althrd_join(self->thread, &res);
 495
 496     if(ioctl(self->fd, SNDCTL_DSP_RESET) != 0)
 497         ERR("Error resetting device: %s\n", strerror(errno));
 498
 499     free(self->mix_data);
 500     self->mix_data = NULL;
 501 }
 502
 503
 504 typedef struct ALCcaptureOSS {
 505     DERIVE_FROM_TYPE(ALCbackend);
 506
 507     int fd;
 508
 509     ll_ringbuffer_t *ring;
 510
 511     ATOMIC(ALenum) killNow;
 512     althrd_t thread;
 513 } ALCcaptureOSS;
 514
 515 static int ALCcaptureOSS_recordProc(void *ptr);
 516
 517 static void ALCcaptureOSS_Construct(ALCcaptureOSS *self, ALCdevice *device);
 518 static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, void, Destruct)
 519 static ALCenum ALCcaptureOSS_open(ALCcaptureOSS *self, const ALCchar *name);
 520 static void ALCcaptureOSS_close(ALCcaptureOSS *self);
 521 static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, ALCboolean, reset)
 522 static ALCboolean ALCcaptureOSS_start(ALCcaptureOSS *self);
 523 static void ALCcaptureOSS_stop(ALCcaptureOSS *self);
 524 static ALCenum ALCcaptureOSS_captureSamples(ALCcaptureOSS *self, ALCvoid *buffer, ALCuint samples);
 525 static ALCuint ALCcaptureOSS_availableSamples(ALCcaptureOSS *self);
 526 static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, ClockLatency, getClockLatency)
 527 static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, void, lock)
 528 static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, void, unlock)
 529 DECLARE_DEFAULT_ALLOCATORS(ALCcaptureOSS)
 530 DEFINE_ALCBACKEND_VTABLE(ALCcaptureOSS);
 531
 532
 533 static int ALCcaptureOSS_recordProc(void *ptr)
 534 {
 535     ALCcaptureOSS *self = (ALCcaptureOSS*)ptr;
 536     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 537     struct timeval timeout;
 538     int frame_size;
 539     fd_set rfds;
 540     ssize_t amt;
 541     int sret;
 542
 543     SetRTPriority();
 544     althrd_setname(althrd_current(), RECORD_THREAD_NAME);
 545
 546     frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 547
 548     while(!ATOMIC_LOAD_SEQ(&self->killNow))
 549     {
 550         ll_ringbuffer_data_t vec[2];
 551
 552         FD_ZERO(&rfds);
 553         FD_SET(self->fd, &rfds);
 554         timeout.tv_sec = 1;
 555         timeout.tv_usec = 0;
 556
 557         sret = select(self->fd+1, &rfds, NULL, NULL, &timeout);
 558         if(sret < 0)
 559         {
 560             if(errno == EINTR)
 561                 continue;
 562             ERR("select failed: %s\n", strerror(errno));
 563             aluHandleDisconnect(device);
 564             break;
 565         }
 566         else if(sret == 0)
 567         {
 568             WARN("select timeout\n");
 569             continue;
 570         }
 571
 572         ll_ringbuffer_get_write_vector(self->ring, vec);
 573         if(vec[0].len > 0)
 574         {
 575             amt = read(self->fd, vec[0].buf, vec[0].len*frame_size);
 576             if(amt < 0)
 577             {
 578                 ERR("read failed: %s\n", strerror(errno));
 579                 ALCcaptureOSS_lock(self);
 580                 aluHandleDisconnect(device);
 581                 ALCcaptureOSS_unlock(self);
 582                 break;
 583             }
 584             ll_ringbuffer_write_advance(self->ring, amt/frame_size);
 585         }
 586     }
 587
 588     return 0;
 589 }
 590
 591
 592 static void ALCcaptureOSS_Construct(ALCcaptureOSS *self, ALCdevice *device)
 593 {
 594     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 595     SET_VTABLE2(ALCcaptureOSS, ALCbackend, self);
 596
 597     ATOMIC_INIT(&self->killNow, AL_FALSE);
 598 }
 599
 600 static ALCenum ALCcaptureOSS_open(ALCcaptureOSS *self, const ALCchar *name)
 601 {
 602     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 603     struct oss_device *dev = &oss_capture;
 604     int numFragmentsLogSize;
 605     int log2FragmentSize;
 606     unsigned int periods;
 607     audio_buf_info info;
 608     ALuint frameSize;
 609     int numChannels;
 610     int ossFormat;
 611     int ossSpeed;
 612     char *err;
 613
 614     if(!name || strcmp(name, dev->handle) == 0)
 615         name = dev->handle;
 616     else
 617     {
 618         if(!dev->next)
 619         {
 620             ALCossListPopulate(&oss_capture, DSP_CAP_INPUT);
 621             dev = &oss_capture;
 622         }
 623         while(dev != NULL)
 624         {
 625             if (strcmp(dev->handle, name) == 0)
 626                 break;
 627             dev = dev->next;
 628         }
 629         if(dev == NULL)
 630         {
 631             WARN("Could not find \"%s\" in device list\n", name);
 632             return ALC_INVALID_VALUE;
 633         }
 634     }
 635
 636     self->fd = open(dev->path, O_RDONLY);
 637     if(self->fd == -1)
 638     {
 639         ERR("Could not open %s: %s\n", dev->path, strerror(errno));
 640         return ALC_INVALID_VALUE;
 641     }
 642
 643     switch(device->FmtType)
 644     {
 645         case DevFmtByte:
 646             ossFormat = AFMT_S8;
 647             break;
 648         case DevFmtUByte:
 649             ossFormat = AFMT_U8;
 650             break;
 651         case DevFmtShort:
 652             ossFormat = AFMT_S16_NE;
 653             break;
 654         case DevFmtUShort:
 655         case DevFmtInt:
 656         case DevFmtUInt:
 657         case DevFmtFloat:
 658             ERR("%s capture samples not supported\n", DevFmtTypeString(device->FmtType));
 659             return ALC_INVALID_VALUE;
 660     }
 661
 662     periods = 4;
 663     numChannels = ChannelsFromDevFmt(device->FmtChans);
 664     frameSize = numChannels * BytesFromDevFmt(device->FmtType);
 665     ossSpeed = device->Frequency;
 666     log2FragmentSize = log2i(device->UpdateSize * device->NumUpdates *
 667                              frameSize / periods);
 668
 669     /* according to the OSS spec, 16 bytes are the minimum */
 670     if (log2FragmentSize < 4)
 671         log2FragmentSize = 4;
 672     numFragmentsLogSize = (periods << 16) | log2FragmentSize;
 673
 674 #define CHECKERR(func) if((func) < 0) {                                       \
 675     err = #func;                                                              \
 676     goto err;                                                                 \
 677 }
 678     CHECKERR(ioctl(self->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize));
 679     CHECKERR(ioctl(self->fd, SNDCTL_DSP_SETFMT, &ossFormat));
 680     CHECKERR(ioctl(self->fd, SNDCTL_DSP_CHANNELS, &numChannels));
 681     CHECKERR(ioctl(self->fd, SNDCTL_DSP_SPEED, &ossSpeed));
 682     CHECKERR(ioctl(self->fd, SNDCTL_DSP_GETISPACE, &info));
 683     if(0)
 684     {
 685     err:
 686         ERR("%s failed: %s\n", err, strerror(errno));
 687         close(self->fd);
 688         self->fd = -1;
 689         return ALC_INVALID_VALUE;
 690     }
 691 #undef CHECKERR
 692
 693     if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
 694     {
 695         ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device->FmtChans), numChannels);
 696         close(self->fd);
 697         self->fd = -1;
 698         return ALC_INVALID_VALUE;
 699     }
 700
 701     if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
 702          (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
 703          (ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
 704     {
 705         ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device->FmtType), ossFormat);
 706         close(self->fd);
 707         self->fd = -1;
 708         return ALC_INVALID_VALUE;
 709     }
 710
 711     self->ring = ll_ringbuffer_create(device->UpdateSize*device->NumUpdates + 1, frameSize);
 712     if(!self->ring)
 713     {
 714         ERR("Ring buffer create failed\n");
 715         close(self->fd);
 716         self->fd = -1;
 717         return ALC_OUT_OF_MEMORY;
 718     }
 719
 720     alstr_copy_cstr(&device->DeviceName, name);
 721
 722     return ALC_NO_ERROR;
 723 }
 724
 725 static void ALCcaptureOSS_close(ALCcaptureOSS *self)
 726 {
 727     close(self->fd);
 728     self->fd = -1;
 729
 730     ll_ringbuffer_free(self->ring);
 731     self->ring = NULL;
 732 }
 733
 734 static ALCboolean ALCcaptureOSS_start(ALCcaptureOSS *self)
 735 {
 736     ATOMIC_STORE_SEQ(&self->killNow, AL_FALSE);
 737     if(althrd_create(&self->thread, ALCcaptureOSS_recordProc, self) != althrd_success)
 738         return ALC_FALSE;
 739     return ALC_TRUE;
 740 }
 741
 742 static void ALCcaptureOSS_stop(ALCcaptureOSS *self)
 743 {
 744     int res;
 745
 746     if(ATOMIC_EXCHANGE_SEQ(ALenum, &self->killNow, AL_TRUE))
 747         return;
 748
 749     althrd_join(self->thread, &res);
 750
 751     if(ioctl(self->fd, SNDCTL_DSP_RESET) != 0)
 752         ERR("Error resetting device: %s\n", strerror(errno));
 753 }
 754
 755 static ALCenum ALCcaptureOSS_captureSamples(ALCcaptureOSS *self, ALCvoid *buffer, ALCuint samples)
 756 {
 757     ll_ringbuffer_read(self->ring, buffer, samples);
 758     return ALC_NO_ERROR;
 759 }
 760
 761 static ALCuint ALCcaptureOSS_availableSamples(ALCcaptureOSS *self)
 762 {
 763     return ll_ringbuffer_read_space(self->ring);
 764 }
 765
 766
 767 typedef struct ALCossBackendFactory {
 768     DERIVE_FROM_TYPE(ALCbackendFactory);
 769 } ALCossBackendFactory;
 770 #define ALCOSSBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCossBackendFactory, ALCbackendFactory) } }
 771
 772 ALCbackendFactory *ALCossBackendFactory_getFactory(void);
 773
 774 static ALCboolean ALCossBackendFactory_init(ALCossBackendFactory *self);
 775 static void ALCossBackendFactory_deinit(ALCossBackendFactory *self);
 776 static ALCboolean ALCossBackendFactory_querySupport(ALCossBackendFactory *self, ALCbackend_Type type);
 777 static void ALCossBackendFactory_probe(ALCossBackendFactory *self, enum DevProbe type);
 778 static ALCbackend* ALCossBackendFactory_createBackend(ALCossBackendFactory *self, ALCdevice *device, ALCbackend_Type type);
 779 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCossBackendFactory);
 780
 781
 782 ALCbackendFactory *ALCossBackendFactory_getFactory(void)
 783 {
 784     static ALCossBackendFactory factory = ALCOSSBACKENDFACTORY_INITIALIZER;
 785     return STATIC_CAST(ALCbackendFactory, &factory);
 786 }
 787
 788
 789 ALCboolean ALCossBackendFactory_init(ALCossBackendFactory* UNUSED(self))
 790 {
 791     ConfigValueStr(NULL, "oss", "device", &oss_playback.path);
 792     ConfigValueStr(NULL, "oss", "capture", &oss_capture.path);
 793
 794     return ALC_TRUE;
 795 }
 796
 797 void  ALCossBackendFactory_deinit(ALCossBackendFactory* UNUSED(self))
 798 {
 799     ALCossListFree(&oss_playback);
 800     ALCossListFree(&oss_capture);
 801 }
 802
 803
 804 ALCboolean ALCossBackendFactory_querySupport(ALCossBackendFactory* UNUSED(self), ALCbackend_Type type)
 805 {
 806     if(type == ALCbackend_Playback || type == ALCbackend_Capture)
 807         return ALC_TRUE;
 808     return ALC_FALSE;
 809 }
 810
 811 void ALCossBackendFactory_probe(ALCossBackendFactory* UNUSED(self), enum DevProbe type)
 812 {
 813     struct oss_device *cur;
 814     switch(type)
 815     {
 816         case ALL_DEVICE_PROBE:
 817             ALCossListFree(&oss_playback);
 818             ALCossListPopulate(&oss_playback, DSP_CAP_OUTPUT);
 819             cur = &oss_playback;
 820             while(cur != NULL)
 821             {
 822                 AppendAllDevicesList(cur->handle);
 823                 cur = cur->next;
 824             }
 825             break;
 826
 827         case CAPTURE_DEVICE_PROBE:
 828             ALCossListFree(&oss_capture);
 829             ALCossListPopulate(&oss_capture, DSP_CAP_INPUT);
 830             cur = &oss_capture;
 831             while(cur != NULL)
 832             {
 833                 AppendCaptureDeviceList(cur->handle);
 834                 cur = cur->next;
 835             }
 836             break;
 837     }
 838 }
 839
 840 ALCbackend* ALCossBackendFactory_createBackend(ALCossBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
 841 {
 842     if(type == ALCbackend_Playback)
 843     {
 844         ALCplaybackOSS *backend;
 845         NEW_OBJ(backend, ALCplaybackOSS)(device);
 846         if(!backend) return NULL;
 847         return STATIC_CAST(ALCbackend, backend);
 848     }
 849     if(type == ALCbackend_Capture)
 850     {
 851         ALCcaptureOSS *backend;
 852         NEW_OBJ(backend, ALCcaptureOSS)(device);
 853         if(!backend) return NULL;
 854         return STATIC_CAST(ALCbackend, backend);
 855     }
 856
 857     return NULL;
 858 }