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
  50 typedef struct {
  51     int fd;
  52     int killNow;
  53     ALvoid *thread;
  54
  55     ALubyte *mix_data;
  56     int data_size;
  57     int silence;
  58 } oss_data;
  59
  60
  61 static int log2i(ALCuint x)
  62 {
  63     int y = 0;
  64     while (x > 1)
  65     {
  66         x >>= 1;
  67         y++;
  68     }
  69     return y;
  70 }
  71
  72
  73 static ALuint OSSProc(ALvoid *ptr)
  74 {
  75     ALCdevice *pDevice = (ALCdevice*)ptr;
  76     oss_data *data = (oss_data*)pDevice->ExtraData;
  77     int remaining;
  78     int wrote;
  79
  80     while(!data->killNow)
  81     {
  82         SuspendContext(NULL);
  83         aluMixData(pDevice->Context,data->mix_data,data->data_size,pDevice->Format);
  84         ProcessContext(NULL);
  85
  86         remaining = data->data_size;
  87         while(remaining > 0)
  88         {
  89             wrote = write(data->fd, data->mix_data+data->data_size-remaining, remaining);
  90             if(wrote < 0)
  91             {
  92                 AL_PRINT("write failed: %s\n", strerror(errno));
  93                 break;
  94             }
  95             if(wrote == 0)
  96             {
  97                 usleep(1000);
  98                 continue;
  99             }
 100             remaining -= wrote;
 101         }
 102     }
 103
 104     return 0;
 105 }
 106
 107 static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName)
 108 {
 109     int numFragmentsLogSize;
 110     int log2FragmentSize;
 111     unsigned int periods;
 112     audio_buf_info info;
 113     char driver[64];
 114     int numChannels;
 115     oss_data *data;
 116     int ossFormat;
 117     int ossSpeed;
 118     char *err;
 119     int i;
 120
 121     strncpy(driver, GetConfigValue("oss", "device", "/dev/dsp"), sizeof(driver)-1);
 122     driver[sizeof(driver)-1] = 0;
 123     if(deviceName)
 124     {
 125         if(strcmp(deviceName, oss_device))
 126             return ALC_FALSE;
 127     }
 128
 129     if(deviceName)
 130         strcpy(device->szDeviceName, deviceName);
 131     else
 132         strcpy(device->szDeviceName, oss_device);
 133
 134     data = (oss_data*)calloc(1, sizeof(oss_data));
 135     data->killNow = 0;
 136
 137     data->fd = open(driver, O_WRONLY);
 138     if(data->fd == -1)
 139     {
 140         free(data);
 141         AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
 142         return ALC_FALSE;
 143     }
 144
 145     switch(device->Format)
 146     {
 147         case AL_FORMAT_MONO8:
 148         case AL_FORMAT_STEREO8:
 149         case AL_FORMAT_QUAD8:
 150             data->silence = 0x80;
 151             ossFormat = AFMT_U8;
 152             break;
 153         case AL_FORMAT_MONO16:
 154         case AL_FORMAT_STEREO16:
 155         case AL_FORMAT_QUAD16:
 156             data->silence = 0;
 157             ossFormat = AFMT_S16_NE;
 158             break;
 159         default:
 160             ossFormat = -1;
 161             AL_PRINT("Unknown format?! %x\n", device->Format);
 162     }
 163
 164     periods = GetConfigValueInt("oss", "periods", 4);
 165     if((int)periods < 0)
 166         periods = 4;
 167     numChannels = device->Channels;
 168     ossSpeed = device->Frequency;
 169     log2FragmentSize = log2i(device->UpdateFreq * device->FrameSize / periods);
 170
 171     /* according to the OSS spec, 16 bytes are the minimum */
 172     if (log2FragmentSize < 4)
 173         log2FragmentSize = 4;
 174     numFragmentsLogSize = (periods << 16) | log2FragmentSize;
 175
 176 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
 177     if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
 178           ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
 179           ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
 180           ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
 181           ok(ioctl(data->fd, SNDCTL_DSP_GETOSPACE, &info), "get space")))
 182     {
 183         AL_PRINT("%s failed: %s\n", err, strerror(i));
 184         close(data->fd);
 185         free(data);
 186         return ALC_FALSE;
 187     }
 188 #undef ok
 189
 190     device->Channels = numChannels;
 191     device->Frequency = ossSpeed;
 192     device->Format = 0;
 193     if(ossFormat == AFMT_U8)
 194     {
 195         if(device->Channels == 1)
 196         {
 197             device->Format = AL_FORMAT_MONO8;
 198             device->FrameSize = 1;
 199         }
 200         else if(device->Channels == 2)
 201         {
 202             device->Format = AL_FORMAT_STEREO8;
 203             device->FrameSize = 2;
 204         }
 205         else if(device->Channels == 4)
 206         {
 207             device->Format = AL_FORMAT_QUAD8;
 208             device->FrameSize = 4;
 209         }
 210     }
 211     else if(ossFormat == AFMT_S16_NE)
 212     {
 213         if(device->Channels == 1)
 214         {
 215             device->Format = AL_FORMAT_MONO16;
 216             device->FrameSize = 2;
 217         }
 218         else if(device->Channels == 2)
 219         {
 220             device->Format = AL_FORMAT_STEREO16;
 221             device->FrameSize = 4;
 222         }
 223         else if(device->Channels == 4)
 224         {
 225             device->Format = AL_FORMAT_QUAD16;
 226             device->FrameSize = 8;
 227         }
 228     }
 229
 230     if(!device->Format)
 231     {
 232         AL_PRINT("returned unknown format: %#x %d!\n", ossFormat, numChannels);
 233         close(data->fd);
 234         free(data);
 235         return ALC_FALSE;
 236     }
 237
 238     device->UpdateFreq = info.fragsize / device->FrameSize;
 239
 240     data->data_size = device->UpdateFreq * device->FrameSize;
 241     data->mix_data = calloc(1, data->data_size);
 242
 243     device->MaxNoOfSources = 256;
 244
 245     device->ExtraData = data;
 246     data->thread = StartThread(OSSProc, device);
 247     if(data->thread == NULL)
 248     {
 249         device->ExtraData = NULL;
 250         free(data->mix_data);
 251         free(data);
 252         return ALC_FALSE;
 253     }
 254
 255     return ALC_TRUE;
 256 }
 257
 258 static void oss_close_playback(ALCdevice *device)
 259 {
 260     oss_data *data = (oss_data*)device->ExtraData;
 261     data->killNow = 1;
 262     StopThread(data->thread);
 263
 264     close(data->fd);
 265
 266     free(data->mix_data);
 267     free(data);
 268     device->ExtraData = NULL;
 269 }
 270
 271
 272 static ALCboolean oss_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 273 {
 274     (void)pDevice;
 275     (void)deviceName;
 276     (void)frequency;
 277     (void)format;
 278     (void)SampleSize;
 279     return ALC_FALSE;
 280 }
 281
 282 static void oss_close_capture(ALCdevice *pDevice)
 283 {
 284     (void)pDevice;
 285 }
 286
 287 static void oss_start_capture(ALCdevice *pDevice)
 288 {
 289     (void)pDevice;
 290 }
 291
 292 static void oss_stop_capture(ALCdevice *pDevice)
 293 {
 294     (void)pDevice;
 295 }
 296
 297 static void oss_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 298 {
 299     (void)pDevice;
 300     (void)pBuffer;
 301     (void)lSamples;
 302 }
 303
 304 static ALCuint oss_available_samples(ALCdevice *pDevice)
 305 {
 306     (void)pDevice;
 307     return 0;
 308 }
 309
 310
 311 BackendFuncs oss_funcs = {
 312     oss_open_playback,
 313     oss_close_playback,
 314     oss_open_capture,
 315     oss_close_capture,
 316     oss_start_capture,
 317     oss_stop_capture,
 318     oss_capture_samples,
 319     oss_available_samples
 320 };
 321
 322 void alc_oss_init(BackendFuncs *func_list)
 323 {
 324     *func_list = oss_funcs;
 325
 326     oss_device = AppendDeviceList("OSS Software");
 327     AppendAllDeviceList(oss_device);
 328 }