Alc/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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include <sys/ioctl.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <memory.h>
  28 #include <unistd.h>
  29 #include <errno.h>
  30 #include <math.h>
  31 #include "alMain.h"
  32 #include "AL/al.h"
  33 #include "AL/alc.h"
  34
  35 #include <sys/soundcard.h>
  36
  37 /*
  38  * The OSS documentation talks about SOUND_MIXER_READ, but the header
  39  * only contains MIXER_READ. Play safe. Same for WRITE.
  40  */
  41 #ifndef SOUND_MIXER_READ
  42 #define SOUND_MIXER_READ MIXER_READ
  43 #endif
  44 #ifndef SOUND_MIXER_WRITE
  45 #define SOUND_MIXER_WRITE MIXER_WRITE
  46 #endif
  47
  48 static char *oss_device;
  49 static char *oss_device_capture;
  50
  51 typedef struct {
  52     int fd;
  53     int killNow;
  54     ALvoid *thread;
  55
  56     ALubyte *mix_data;
  57     int data_size;
  58     int silence;
  59
  60     RingBuffer *ring;
  61     int doCapture;
  62 } oss_data;
  63
  64
  65 static int log2i(ALCuint x)
  66 {
  67     int y = 0;
  68     while (x > 1)
  69     {
  70         x >>= 1;
  71         y++;
  72     }
  73     return y;
  74 }
  75
  76
  77 static ALuint OSSProc(ALvoid *ptr)
  78 {
  79     ALCdevice *pDevice = (ALCdevice*)ptr;
  80     oss_data *data = (oss_data*)pDevice->ExtraData;
  81     int remaining;
  82     int wrote;
  83
  84     while(!data->killNow)
  85     {
  86         SuspendContext(NULL);
  87         aluMixData(pDevice->Context,data->mix_data,data->data_size,pDevice->Format);
  88         ProcessContext(NULL);
  89
  90         remaining = data->data_size;
  91         while(remaining > 0)
  92         {
  93             wrote = write(data->fd, data->mix_data+data->data_size-remaining, remaining);
  94             if(wrote < 0)
  95             {
  96                 AL_PRINT("write failed: %s\n", strerror(errno));
  97                 break;
  98             }
  99             if(wrote == 0)
 100             {
 101                 usleep(1000);
 102                 continue;
 103             }
 104             remaining -= wrote;
 105         }
 106     }
 107
 108     return 0;
 109 }
 110
 111 static ALuint OSSCaptureProc(ALvoid *ptr)
 112 {
 113     ALCdevice *pDevice = (ALCdevice*)ptr;
 114     oss_data *data = (oss_data*)pDevice->ExtraData;
 115     int frameSize;
 116     int amt;
 117
 118     frameSize  = aluBytesFromFormat(pDevice->Format);
 119     frameSize *= aluChannelsFromFormat(pDevice->Format);
 120
 121     while(!data->killNow)
 122     {
 123         amt = read(data->fd, data->mix_data, data->data_size);
 124         if(amt < 0)
 125         {
 126             AL_PRINT("read failed: %s\n", strerror(errno));
 127             break;
 128         }
 129         if(amt == 0)
 130         {
 131             usleep(1000);
 132             continue;
 133         }
 134         if(data->doCapture)
 135             WriteRingBuffer(data->ring, data->mix_data, amt/frameSize);
 136     }
 137
 138     return 0;
 139 }
 140
 141 static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName)
 142 {
 143     int numFragmentsLogSize;
 144     int log2FragmentSize;
 145     unsigned int periods;
 146     audio_buf_info info;
 147     char driver[64];
 148     int numChannels;
 149     oss_data *data;
 150     int ossFormat;
 151     int ossSpeed;
 152     char *err;
 153     int i;
 154
 155     strncpy(driver, GetConfigValue("oss", "device", "/dev/dsp"), sizeof(driver)-1);
 156     driver[sizeof(driver)-1] = 0;
 157     if(deviceName)
 158     {
 159         if(strcmp(deviceName, oss_device))
 160             return ALC_FALSE;
 161         device->szDeviceName = oss_device;
 162     }
 163     else
 164         device->szDeviceName = oss_device;
 165
 166     data = (oss_data*)calloc(1, sizeof(oss_data));
 167     data->killNow = 0;
 168
 169     data->fd = open(driver, O_WRONLY);
 170     if(data->fd == -1)
 171     {
 172         free(data);
 173         AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
 174         return ALC_FALSE;
 175     }
 176
 177     switch(device->Format)
 178     {
 179         case AL_FORMAT_MONO8:
 180         case AL_FORMAT_STEREO8:
 181         case AL_FORMAT_QUAD8:
 182             data->silence = 0x80;
 183             ossFormat = AFMT_U8;
 184             break;
 185         case AL_FORMAT_MONO16:
 186         case AL_FORMAT_STEREO16:
 187         case AL_FORMAT_QUAD16:
 188             data->silence = 0;
 189             ossFormat = AFMT_S16_NE;
 190             break;
 191         default:
 192             ossFormat = -1;
 193             AL_PRINT("Unknown format?! %x\n", device->Format);
 194     }
 195
 196     periods = GetConfigValueInt("oss", "periods", 4);
 197     if((int)periods < 0)
 198         periods = 4;
 199     numChannels = device->Channels;
 200     ossSpeed = device->Frequency;
 201     log2FragmentSize = log2i(device->UpdateFreq * device->FrameSize / periods);
 202
 203     /* according to the OSS spec, 16 bytes are the minimum */
 204     if (log2FragmentSize < 4)
 205         log2FragmentSize = 4;
 206     numFragmentsLogSize = (periods << 16) | log2FragmentSize;
 207
 208 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 209     if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
 210           ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
 211           ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
 212           ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
 213           ok(ioctl(data->fd, SNDCTL_DSP_GETOSPACE, &info), "get space")))
 214     {
 215         AL_PRINT("%s failed: %s\n", err, strerror(errno));
 216         close(data->fd);
 217         free(data);
 218         return ALC_FALSE;
 219     }
 220 #undef ok
 221
 222     device->Channels = numChannels;
 223     device->Frequency = ossSpeed;
 224     device->Format = 0;
 225     if(ossFormat == AFMT_U8)
 226     {
 227         if(device->Channels == 1)
 228         {
 229             device->Format = AL_FORMAT_MONO8;
 230             device->FrameSize = 1;
 231         }
 232         else if(device->Channels == 2)
 233         {
 234             device->Format = AL_FORMAT_STEREO8;
 235             device->FrameSize = 2;
 236         }
 237         else if(device->Channels == 4)
 238         {
 239             device->Format = AL_FORMAT_QUAD8;
 240             device->FrameSize = 4;
 241         }
 242     }
 243     else if(ossFormat == AFMT_S16_NE)
 244     {
 245         if(device->Channels == 1)
 246         {
 247             device->Format = AL_FORMAT_MONO16;
 248             device->FrameSize = 2;
 249         }
 250         else if(device->Channels == 2)
 251         {
 252             device->Format = AL_FORMAT_STEREO16;
 253             device->FrameSize = 4;
 254         }
 255         else if(device->Channels == 4)
 256         {
 257             device->Format = AL_FORMAT_QUAD16;
 258             device->FrameSize = 8;
 259         }
 260     }
 261
 262     if(!device->Format)
 263     {
 264         AL_PRINT("returned unknown format: %#x %d!\n", ossFormat, numChannels);
 265         close(data->fd);
 266         free(data);
 267         return ALC_FALSE;
 268     }
 269
 270     device->UpdateFreq = info.fragsize / device->FrameSize;
 271
 272     data->data_size = device->UpdateFreq * device->FrameSize;
 273     data->mix_data = calloc(1, data->data_size);
 274
 275     device->MaxNoOfSources = 256;
 276
 277     device->ExtraData = data;
 278     data->thread = StartThread(OSSProc, device);
 279     if(data->thread == NULL)
 280     {
 281         device->ExtraData = NULL;
 282         free(data->mix_data);
 283         free(data);
 284         return ALC_FALSE;
 285     }
 286
 287     return ALC_TRUE;
 288 }
 289
 290 static void oss_close_playback(ALCdevice *device)
 291 {
 292     oss_data *data = (oss_data*)device->ExtraData;
 293     data->killNow = 1;
 294     StopThread(data->thread);
 295
 296     close(data->fd);
 297
 298     free(data->mix_data);
 299     free(data);
 300     device->ExtraData = NULL;
 301 }
 302
 303
 304 static ALCboolean oss_open_capture(ALCdevice *device, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 305 {
 306     int numFragmentsLogSize;
 307     int log2FragmentSize;
 308     unsigned int periods;
 309     audio_buf_info info;
 310     int numChannels;
 311     char driver[64];
 312     oss_data *data;
 313     int ossFormat;
 314     int ossSpeed;
 315     char *err;
 316     int i;
 317
 318     strncpy(driver, GetConfigValue("oss", "capture", "/dev/dsp"), sizeof(driver)-1);
 319     driver[sizeof(driver)-1] = 0;
 320     if(deviceName)
 321     {
 322         if(strcmp(deviceName, oss_device_capture))
 323             return ALC_FALSE;
 324         device->szDeviceName = oss_device_capture;
 325     }
 326     else
 327         device->szDeviceName = oss_device_capture;
 328
 329     data = (oss_data*)calloc(1, sizeof(oss_data));
 330     data->killNow = 0;
 331
 332     data->fd = open(driver, O_RDONLY);
 333     if(data->fd == -1)
 334     {
 335         free(data);
 336         AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
 337         return ALC_FALSE;
 338     }
 339
 340     switch(format)
 341     {
 342         case AL_FORMAT_MONO8:
 343         case AL_FORMAT_STEREO8:
 344         case AL_FORMAT_QUAD8:
 345             data->silence = 0x80;
 346             ossFormat = AFMT_U8;
 347             break;
 348         case AL_FORMAT_MONO16:
 349         case AL_FORMAT_STEREO16:
 350         case AL_FORMAT_QUAD16:
 351             data->silence = 0;
 352             ossFormat = AFMT_S16_NE;
 353             break;
 354         default:
 355             ossFormat = -1;
 356             AL_PRINT("Unknown format?! %x\n", device->Format);
 357     }
 358
 359     periods = 4;
 360     numChannels = device->Channels;
 361     ossSpeed = frequency;
 362     log2FragmentSize = log2i(device->UpdateFreq * device->FrameSize / periods);
 363
 364     /* according to the OSS spec, 16 bytes are the minimum */
 365     if (log2FragmentSize < 4)
 366         log2FragmentSize = 4;
 367     numFragmentsLogSize = (periods << 16) | log2FragmentSize;
 368
 369 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 370     if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
 371           ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
 372           ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
 373           ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
 374           ok(ioctl(data->fd, SNDCTL_DSP_GETISPACE, &info), "get space")))
 375     {
 376         AL_PRINT("%s failed: %s\n", err, strerror(errno));
 377         close(data->fd);
 378         free(data);
 379         return ALC_FALSE;
 380     }
 381 #undef ok
 382
 383     device->Channels = numChannels;
 384     device->Frequency = ossSpeed;
 385     device->Format = 0;
 386     if(ossFormat == AFMT_U8)
 387     {
 388         if(device->Channels == 1)
 389         {
 390             device->Format = AL_FORMAT_MONO8;
 391             device->FrameSize = 1;
 392         }
 393         else if(device->Channels == 2)
 394         {
 395             device->Format = AL_FORMAT_STEREO8;
 396             device->FrameSize = 2;
 397         }
 398         else if(device->Channels == 4)
 399         {
 400             device->Format = AL_FORMAT_QUAD8;
 401             device->FrameSize = 4;
 402         }
 403     }
 404     else if(ossFormat == AFMT_S16_NE)
 405     {
 406         if(device->Channels == 1)
 407         {
 408             device->Format = AL_FORMAT_MONO16;
 409             device->FrameSize = 2;
 410         }
 411         else if(device->Channels == 2)
 412         {
 413             device->Format = AL_FORMAT_STEREO16;
 414             device->FrameSize = 4;
 415         }
 416         else if(device->Channels == 4)
 417         {
 418             device->Format = AL_FORMAT_QUAD16;
 419             device->FrameSize = 8;
 420         }
 421     }
 422
 423     if(!device->Format)
 424     {
 425         AL_PRINT("returned unknown format: %#x %d!\n", ossFormat, numChannels);
 426         close(data->fd);
 427         free(data);
 428         return ALC_FALSE;
 429     }
 430
 431     data->ring = CreateRingBuffer(device->FrameSize, SampleSize);
 432     if(!data->ring)
 433     {
 434         AL_PRINT("ring buffer create failed\n");
 435         close(data->fd);
 436         free(data);
 437         return ALC_FALSE;
 438     }
 439
 440     device->UpdateFreq = info.fragsize / device->FrameSize;
 441
 442     data->data_size = device->UpdateFreq * device->FrameSize;
 443     data->mix_data = calloc(1, data->data_size);
 444
 445     device->ExtraData = data;
 446     data->thread = StartThread(OSSCaptureProc, device);
 447     if(data->thread == NULL)
 448     {
 449         device->ExtraData = NULL;
 450         free(data->mix_data);
 451         free(data);
 452         return ALC_FALSE;
 453     }
 454
 455     return ALC_TRUE;
 456 }
 457
 458 static void oss_close_capture(ALCdevice *device)
 459 {
 460     oss_data *data = (oss_data*)device->ExtraData;
 461     data->killNow = 1;
 462     StopThread(data->thread);
 463
 464     close(data->fd);
 465
 466     DestroyRingBuffer(data->ring);
 467
 468     free(data->mix_data);
 469     free(data);
 470     device->ExtraData = NULL;
 471 }
 472
 473 static void oss_start_capture(ALCdevice *pDevice)
 474 {
 475     oss_data *data = (oss_data*)pDevice->ExtraData;
 476     data->doCapture = 1;
 477 }
 478
 479 static void oss_stop_capture(ALCdevice *pDevice)
 480 {
 481     oss_data *data = (oss_data*)pDevice->ExtraData;
 482     data->doCapture = 0;
 483 }
 484
 485 static void oss_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 486 {
 487     oss_data *data = (oss_data*)pDevice->ExtraData;
 488     if(lSamples <= (ALCuint)RingBufferSize(data->ring))
 489         ReadRingBuffer(data->ring, pBuffer, lSamples);
 490     else
 491         SetALCError(ALC_INVALID_VALUE);
 492 }
 493
 494 static ALCuint oss_available_samples(ALCdevice *pDevice)
 495 {
 496     oss_data *data = (oss_data*)pDevice->ExtraData;
 497     return RingBufferSize(data->ring);
 498 }
 499
 500
 501 BackendFuncs oss_funcs = {
 502     oss_open_playback,
 503     oss_close_playback,
 504     oss_open_capture,
 505     oss_close_capture,
 506     oss_start_capture,
 507     oss_stop_capture,
 508     oss_capture_samples,
 509     oss_available_samples
 510 };
 511
 512 void alc_oss_init(BackendFuncs *func_list)
 513 {
 514     *func_list = oss_funcs;
 515
 516     oss_device = AppendDeviceList("OSS Software");
 517     AppendAllDeviceList(oss_device);
 518
 519     oss_device_capture = AppendCaptureDeviceList("OSS Capture");
 520 }