arch/all-unix/libs/oss/funcs.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "oss_intern.h"
   7
   8 #include <hidd/unixio.h>
   9
  10 #include <unistd.h>
  11 #include <errno.h>
  12 /* avoid conflicts between our __unused define and the ones that might come in
  13    via fcntl.h */
  14 #undef __unused
  15 #include <fcntl.h>
  16
  17 #include <sys/ioctl.h>
  18
  19 #include <sys/soundcard.h>
  20 //#include <sys/mman.h>
  21
  22 /* Make it build on both newer and older OSS libraries */
  23 #if !defined(SNDCTL_DSP_SPEED) && defined(SOUND_PCM_WRITE_RATE)
  24 #  define SNDCTL_DSP_SPEED  SOUND_PCM_WRITE_RATE
  25 #endif
  26
  27 #include <aros/debug.h>
  28
  29 /******************************************************************************/
  30
  31 BOOL OSS_Open(char *filename, BOOL read, BOOL write, BOOL blocking)
  32 {
  33     int openflags;
  34
  35     if (!filename) filename = "/dev/dsp";
  36
  37     if (write && read)
  38     {
  39         openflags = O_RDWR;
  40     }
  41     else if (write)
  42     {
  43         openflags = O_WRONLY;
  44     }
  45     else
  46     {
  47         openflags = O_RDONLY;
  48     }
  49
  50     if (!blocking) openflags |= O_NONBLOCK;
  51
  52     audio_fd = Hidd_UnixIO_OpenFile(unixio, filename, openflags, 0, NULL);
  53
  54     return (audio_fd >= 0) ? TRUE : FALSE;
  55 }
  56
  57 /******************************************************************************/
  58
  59 void OSS_Close(void)
  60 {
  61     if (audio_fd >= 0)
  62     {
  63         Hidd_UnixIO_CloseFile(unixio, audio_fd, NULL);
  64         audio_fd = -1;
  65     }
  66 }
  67
  68 /******************************************************************************/
  69
  70 void OSS_Reset(void)
  71 {
  72     if (audio_fd >= 0)
  73     {
  74         int value = 0;
  75
  76         Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_RESET, &value, NULL);
  77     }
  78 }
  79
  80 /******************************************************************************/
  81
  82 BOOL OSS_SetFragmentSize(int num_fragments, int fragment_size)
  83 {
  84     if (audio_fd >= 0)
  85     {
  86         int value;
  87         int retval;
  88
  89         value = (num_fragments << 16) | fragment_size;
  90
  91         retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_SETFRAGMENT, &value, NULL);
  92         return (retval < 0) ? FALSE : TRUE;
  93     }
  94     else
  95     {
  96         return FALSE;
  97     }
  98 }
  99
 100 /******************************************************************************/
 101
 102 BOOL OSS_GetOutputInfo(int *num_fragments_available, int *num_fragments_allocated,
 103                        int *fragment_size, int *num_bytes_available)
 104
 105 {
 106     if (audio_fd >= 0)
 107     {
 108         audio_buf_info info;
 109
 110         Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_GETOSPACE, &info, NULL);
 111
 112         if (num_fragments_available) *num_fragments_available = info.fragments;
 113         if (num_fragments_allocated) *num_fragments_allocated = info.fragstotal;
 114         if (fragment_size) *fragment_size = info.fragsize;
 115         if (num_bytes_available) *num_bytes_available = info.bytes;
 116
 117         return TRUE;
 118     }
 119     else
 120     {
 121         return FALSE;
 122     }
 123 }
 124
 125 /******************************************************************************/
 126
 127 BOOL OSS_GetOutputPointer(int *processed_bytes, int *fragment_transitions, int *dmapointer)
 128 {
 129     if (audio_fd >= 0)
 130     {
 131         count_info info;
 132
 133         Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_GETOPTR, &info, NULL);
 134
 135         if (processed_bytes) *processed_bytes = info.bytes;
 136         if (fragment_transitions) *fragment_transitions = info.blocks;
 137         if (dmapointer) *dmapointer = info.ptr;
 138
 139         return TRUE;
 140     }
 141     else
 142     {
 143         return FALSE;
 144     }
 145
 146 }
 147
 148
 149 /******************************************************************************/
 150
 151 int audio_supported_fmts;
 152
 153 static BOOL get_supported_fmts(void)
 154 {
 155     if (audio_supported_fmts) return TRUE;
 156     if (audio_fd < 0) return FALSE;
 157
 158     Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_GETFMTS, &audio_supported_fmts, NULL);
 159
 160     return TRUE;
 161
 162 }
 163
 164 /******************************************************************************/
 165
 166 BOOL OSS_FormatSupported_S8(void)
 167 {
 168     if (!get_supported_fmts()) return FALSE;
 169
 170     return (audio_supported_fmts & AFMT_S8) ? TRUE : FALSE;
 171 }
 172
 173 /******************************************************************************/
 174
 175 BOOL OSS_FormatSupported_U8(void)
 176 {
 177     if (!get_supported_fmts()) return FALSE;
 178
 179     return (audio_supported_fmts & AFMT_U8) ? TRUE : FALSE;
 180 }
 181
 182 /******************************************************************************/
 183
 184 BOOL OSS_FormatSupported_S16LE(void)
 185 {
 186     if (!get_supported_fmts()) return FALSE;
 187
 188     return (audio_supported_fmts & AFMT_S16_LE) ? TRUE : FALSE;
 189 }
 190
 191 /******************************************************************************/
 192
 193 BOOL OSS_FormatSupported_S16BE(void)
 194 {
 195     if (!get_supported_fmts()) return FALSE;
 196
 197     return (audio_supported_fmts & AFMT_S16_BE) ? TRUE : FALSE;
 198 }
 199
 200 /******************************************************************************/
 201
 202 BOOL OSS_FormatSupported_U16LE(void)
 203 {
 204     if (!get_supported_fmts()) return FALSE;
 205
 206     return (audio_supported_fmts & AFMT_U16_LE) ? TRUE : FALSE;
 207 }
 208
 209 /******************************************************************************/
 210
 211 BOOL OSS_FormatSupported_U16BE(void)
 212 {
 213     if (!get_supported_fmts()) return FALSE;
 214
 215     return (audio_supported_fmts & AFMT_U16_BE) ? TRUE : FALSE;
 216 }
 217
 218 /******************************************************************************/
 219
 220 int audio_capabilities;
 221
 222 static BOOL get_capabilities(void)
 223 {
 224     if (audio_capabilities) return TRUE;
 225     if (audio_fd < 0) return FALSE;
 226
 227     Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_GETCAPS, &audio_capabilities, NULL);
 228
 229     return TRUE;
 230
 231 }
 232
 233 /******************************************************************************/
 234
 235 int OSS_Revision(void)
 236 {
 237     if (!get_capabilities()) return 0;
 238
 239     return audio_capabilities & DSP_CAP_REVISION;
 240 }
 241
 242 /******************************************************************************/
 243
 244 BOOL OSS_Capability_Duplex(void)
 245 {
 246     if (!get_capabilities()) return 0;
 247
 248     return (audio_capabilities & DSP_CAP_DUPLEX) ? TRUE : FALSE;
 249 }
 250
 251 /******************************************************************************/
 252
 253 BOOL OSS_Capability_Realtime(void)
 254 {
 255     if (!get_capabilities()) return 0;
 256
 257     return (audio_capabilities & DSP_CAP_REALTIME) ? TRUE : FALSE;
 258 }
 259
 260 /******************************************************************************/
 261
 262 BOOL OSS_Capability_Trigger(void)
 263 {
 264     if (!get_capabilities()) return 0;
 265
 266     return (audio_capabilities & DSP_CAP_TRIGGER) ? TRUE : FALSE;
 267 }
 268
 269 /******************************************************************************/
 270
 271 BOOL OSS_Capability_MMap(void)
 272 {
 273     if (!get_capabilities()) return 0;
 274
 275     return (audio_capabilities & DSP_CAP_MMAP) ? TRUE : FALSE;
 276 }
 277
 278 /******************************************************************************/
 279
 280 static BOOL set_format(int fmt)
 281 {
 282     if (audio_fd >= 0)
 283     {
 284         int val = fmt;
 285         int retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_SETFMT, &val, NULL);
 286
 287         if ((val != fmt) || (retval < 0))
 288         {
 289             return FALSE;
 290         }
 291
 292         return TRUE;
 293
 294     }
 295     else
 296     {
 297         return FALSE;
 298     }
 299 }
 300
 301 /******************************************************************************/
 302
 303 BOOL OSS_SetFormat_S8(void)
 304 {
 305     return set_format(AFMT_S8);
 306 }
 307
 308 /******************************************************************************/
 309
 310 BOOL OSS_SetFormat_U8(void)
 311 {
 312     return set_format(AFMT_U8);
 313 }
 314
 315 /******************************************************************************/
 316
 317 BOOL OSS_SetFormat_S16LE(void)
 318 {
 319     return set_format(AFMT_S16_LE);
 320 }
 321
 322 /******************************************************************************/
 323
 324 BOOL OSS_SetFormat_S16BE(void)
 325 {
 326     return set_format(AFMT_S16_BE);
 327 }
 328
 329 /******************************************************************************/
 330
 331 BOOL OSS_SetFormat_U16LE(void)
 332 {
 333     return set_format(AFMT_S16_LE);
 334 }
 335
 336 /******************************************************************************/
 337
 338 BOOL OSS_SetFormat_U16BE(void)
 339 {
 340     return set_format(AFMT_S16_BE);
 341 }
 342
 343 /******************************************************************************/
 344
 345 BOOL OSS_SetMono(void)
 346 {
 347     int val = 0;
 348     int retval;
 349
 350     if (audio_fd < 0) return FALSE;
 351
 352     retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_STEREO, &val, NULL);
 353
 354     if ((retval < 0) || (val != 0)) return FALSE;
 355
 356     return TRUE;
 357 }
 358
 359 /******************************************************************************/
 360
 361 BOOL OSS_SetStereo(void)
 362 {
 363     int val = 1;
 364     int retval;
 365
 366     if (audio_fd < 0) return FALSE;
 367
 368     retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_STEREO, &val, NULL);
 369
 370     if ((retval < 0) || (val != 1)) return FALSE;
 371
 372     return TRUE;
 373 }
 374
 375 /******************************************************************************/
 376
 377 BOOL OSS_SetNumChannels(int numchannels)
 378 {
 379     int val = numchannels;
 380     int retval;
 381
 382     if (audio_fd < 0) return FALSE;
 383
 384     retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_CHANNELS, &val, NULL);
 385     if (retval < 0)
 386     {
 387         return (numchannels > 1) ? OSS_SetStereo() : OSS_SetMono();
 388     }
 389
 390     return TRUE;
 391 }
 392
 393 /******************************************************************************/
 394
 395 BOOL OSS_SetWriteRate(int rate, int *used_rate)
 396 {
 397     int val = rate;
 398     int retval;
 399
 400     if (audio_fd < 0) return FALSE;
 401
 402     retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_SPEED, &val, NULL);
 403     if (retval < 0)
 404     {
 405         return FALSE;
 406     }
 407
 408     if (used_rate) *used_rate = val;
 409
 410     return TRUE;
 411 }
 412
 413 /******************************************************************************/
 414
 415 BOOL OSS_MMap(APTR *mapped_address, int len, BOOL read, BOOL write)
 416 {
 417 #if 1
 418 /* FIXME: Can't use mmap yet! */
 419     kprintf("\n=== Dont' call OSS_MMap! Not implemented yet! ===\n\n");
 420     return FALSE;
 421 #else
 422     APTR buf;
 423     int protection;
 424
 425     if (audio_fd < 0) return FALSE;
 426
 427     if (read && write)
 428     {
 429         protection = PROT_READ | PROT_WRITE;
 430     }
 431     else if (read)
 432     {
 433         protection = PROT_READ;
 434     }
 435     else
 436     {
 437         protection = PROT_WRITE;
 438     }
 439
 440     buf = (APTR)mmap(NULL, len, protection, MAP_SHARED, audio_fd, 0);
 441     if (buf == MAP_FAILED)
 442     {
 443         return FALSE;
 444     }
 445
 446     *mapped_address = buf;
 447 #endif
 448
 449     return TRUE;
 450
 451 }
 452
 453 /******************************************************************************/
 454
 455 void OSS_MUnmap(APTR mapped_address, int len)
 456 {
 457 #if 1
 458 /* FIXME: Can't use munmap yet! */
 459     kprintf("\n=== Dont' call OSS_MUnmap! Not implemented yet! ===\n\n");
 460 #else
 461     if ((audio_fd >= 0) && (mapped_address != MAP_FAILED))
 462     {
 463         munmap(mapped_address, len);
 464     }
 465 #endif
 466 }
 467
 468 /******************************************************************************/
 469
 470 BOOL OSS_SetTrigger(BOOL input, BOOL output)
 471 {
 472     int val = 0;
 473     int retval;
 474
 475     if (audio_fd < 0) return FALSE;
 476
 477     if (input) val |= PCM_ENABLE_INPUT;
 478     if (output) val |= PCM_ENABLE_OUTPUT;
 479
 480     retval = Hidd_UnixIO_IOControlFile(unixio, audio_fd, SNDCTL_DSP_SETTRIGGER, &val, NULL);
 481
 482     return (retval < 0) ? FALSE : TRUE;
 483 }
 484
 485 /******************************************************************************/
 486
 487 int OSS_Write(APTR buf, int size)
 488 {
 489     int written;
 490     int Errno;
 491
 492     if (audio_fd < 0)
 493     {
 494         return -1;
 495     }
 496
 497     written = Hidd_UnixIO_WriteFile(unixio, audio_fd, buf, size, &Errno);
 498     if (written == -1)
 499     {
 500         switch(Errno)
 501         {
 502             case EAGAIN:
 503                 written = -2; /* Retval -2. Caller should treat it like EAGAIN. */
 504                 break;
 505
 506             case EINTR:
 507                 written = -3; /* Retval -3. Caller should treat it like EINTR. */
 508                 break;
 509
 510             case 0:
 511                 written = -4; /* Retval -4. Caller should treat it like a 0-Errno.
 512                                  (but since retval of write() was -1, like EAGAIN
 513                                  maybe?) */
 514                 break;
 515         }
 516
 517     }
 518
 519     return written;
 520 }
 521
 522 /******************************************************************************/