ossaudio.c 23.9 KB
Newer Older
bellard's avatar
bellard committed
1
/*
2 3 4 5
 * QEMU OSS audio driver
 *
 * Copyright (c) 2003-2005 Vassili Karpov (malc)
 *
bellard's avatar
bellard committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
24
#include <stdlib.h>
bellard's avatar
bellard committed
25 26 27
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/ioctl.h>
28 29 30
#ifdef __OpenBSD__
#include <soundcard.h>
#else
bellard's avatar
bellard committed
31
#include <sys/soundcard.h>
32
#endif
pbrook's avatar
pbrook committed
33
#include "qemu-common.h"
34
#include "host-utils.h"
malc's avatar
malc committed
35
#include "qemu-char.h"
pbrook's avatar
pbrook committed
36
#include "audio.h"
37

38 39
#define AUDIO_CAP "oss"
#include "audio_int.h"
40

41 42 43 44
#if defined OSS_GETVERSION && defined SNDCTL_DSP_POLICY
#define USE_DSP_POLICY
#endif

45 46
typedef struct OSSVoiceOut {
    HWVoiceOut hw;
47 48
    void *pcm_buf;
    int fd;
malc's avatar
malc committed
49
    int wpos;
50 51 52
    int nfrags;
    int fragsize;
    int mmapped;
malc's avatar
malc committed
53
    int pending;
54
} OSSVoiceOut;
bellard's avatar
bellard committed
55

56 57 58 59 60 61 62
typedef struct OSSVoiceIn {
    HWVoiceIn hw;
    void *pcm_buf;
    int fd;
    int nfrags;
    int fragsize;
} OSSVoiceIn;
bellard's avatar
bellard committed
63 64 65 66 67

static struct {
    int try_mmap;
    int nfrags;
    int fragsize;
68 69
    const char *devpath_out;
    const char *devpath_in;
70
    int debug;
malc's avatar
malc committed
71 72
    int exclusive;
    int policy;
bellard's avatar
bellard committed
73 74 75 76
} conf = {
    .try_mmap = 0,
    .nfrags = 4,
    .fragsize = 4096,
77
    .devpath_out = "/dev/dsp",
78
    .devpath_in = "/dev/dsp",
malc's avatar
malc committed
79 80 81
    .debug = 0,
    .exclusive = 0,
    .policy = 5
bellard's avatar
bellard committed
82 83 84 85 86 87 88 89 90 91
};

struct oss_params {
    int freq;
    audfmt_e fmt;
    int nchannels;
    int nfrags;
    int fragsize;
};

92
static void GCC_FMT_ATTR (2, 3) oss_logerr (int err, const char *fmt, ...)
bellard's avatar
bellard committed
93
{
94 95
    va_list ap;

bellard's avatar
bellard committed
96
    va_start (ap, fmt);
97
    AUD_vlog (AUDIO_CAP, fmt, ap);
bellard's avatar
bellard committed
98
    va_end (ap);
99 100

    AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
bellard's avatar
bellard committed
101 102
}

103 104 105 106 107 108 109 110 111
static void GCC_FMT_ATTR (3, 4) oss_logerr2 (
    int err,
    const char *typ,
    const char *fmt,
    ...
    )
{
    va_list ap;

bellard's avatar
bellard committed
112
    AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
113 114 115 116 117 118 119 120 121 122

    va_start (ap, fmt);
    AUD_vlog (AUDIO_CAP, fmt, ap);
    va_end (ap);

    AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
}

static void oss_anal_close (int *fdp)
{
123 124 125 126
    int err;

    qemu_set_fd_handler (*fdp, NULL, NULL, NULL);
    err = close (*fdp);
127 128 129 130 131 132
    if (err) {
        oss_logerr (errno, "Failed to close file(fd=%d)\n", *fdp);
    }
    *fdp = -1;
}

malc's avatar
malc committed
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
static void oss_helper_poll_out (void *opaque)
{
    (void) opaque;
    audio_run ("oss_poll_out");
}

static void oss_helper_poll_in (void *opaque)
{
    (void) opaque;
    audio_run ("oss_poll_in");
}

static int oss_poll_out (HWVoiceOut *hw)
{
    OSSVoiceOut *oss = (OSSVoiceOut *) hw;

    return qemu_set_fd_handler (oss->fd, NULL, oss_helper_poll_out, NULL);
}

static int oss_poll_in (HWVoiceIn *hw)
{
    OSSVoiceIn *oss = (OSSVoiceIn *) hw;

    return qemu_set_fd_handler (oss->fd, oss_helper_poll_in, NULL, NULL);
}

159 160 161 162 163
static int oss_write (SWVoiceOut *sw, void *buf, int len)
{
    return audio_pcm_sw_write (sw, buf, len);
}

164
static int aud_to_ossfmt (audfmt_e fmt, int endianness)
bellard's avatar
bellard committed
165 166
{
    switch (fmt) {
167 168 169 170 171 172 173
    case AUD_FMT_S8:
        return AFMT_S8;

    case AUD_FMT_U8:
        return AFMT_U8;

    case AUD_FMT_S16:
174 175 176 177 178 179
        if (endianness) {
            return AFMT_S16_BE;
        }
        else {
            return AFMT_S16_LE;
        }
180 181

    case AUD_FMT_U16:
182 183 184 185 186 187
        if (endianness) {
            return AFMT_U16_BE;
        }
        else {
            return AFMT_U16_LE;
        }
188

bellard's avatar
bellard committed
189
    default:
190 191 192 193 194
        dolog ("Internal logic error: Bad audio format %d\n", fmt);
#ifdef DEBUG_AUDIO
        abort ();
#endif
        return AFMT_U8;
bellard's avatar
bellard committed
195 196 197
    }
}

198
static int oss_to_audfmt (int ossfmt, audfmt_e *fmt, int *endianness)
bellard's avatar
bellard committed
199
{
200 201
    switch (ossfmt) {
    case AFMT_S8:
202
        *endianness = 0;
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
        *fmt = AUD_FMT_S8;
        break;

    case AFMT_U8:
        *endianness = 0;
        *fmt = AUD_FMT_U8;
        break;

    case AFMT_S16_LE:
        *endianness = 0;
        *fmt = AUD_FMT_S16;
        break;

    case AFMT_U16_LE:
        *endianness = 0;
        *fmt = AUD_FMT_U16;
        break;

    case AFMT_S16_BE:
        *endianness = 1;
        *fmt = AUD_FMT_S16;
        break;

    case AFMT_U16_BE:
        *endianness = 1;
        *fmt = AUD_FMT_U16;
        break;

bellard's avatar
bellard committed
231
    default:
232 233
        dolog ("Unrecognized audio format %d\n", ossfmt);
        return -1;
bellard's avatar
bellard committed
234
    }
235 236

    return 0;
bellard's avatar
bellard committed
237 238
}

bellard's avatar
bellard committed
239
#if defined DEBUG_MISMATCHES || defined DEBUG
240
static void oss_dump_info (struct oss_params *req, struct oss_params *obt)
bellard's avatar
bellard committed
241 242 243
{
    dolog ("parameter | requested value | obtained value\n");
    dolog ("format    |      %10d |     %10d\n", req->fmt, obt->fmt);
244 245
    dolog ("channels  |      %10d |     %10d\n",
           req->nchannels, obt->nchannels);
bellard's avatar
bellard committed
246 247
    dolog ("frequency |      %10d |     %10d\n", req->freq, obt->freq);
    dolog ("nfrags    |      %10d |     %10d\n", req->nfrags, obt->nfrags);
248 249
    dolog ("fragsize  |      %10d |     %10d\n",
           req->fragsize, obt->fragsize);
bellard's avatar
bellard committed
250 251 252
}
#endif

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
#ifdef USE_DSP_POLICY
static int oss_get_version (int fd, int *version, const char *typ)
{
    if (ioctl (fd, OSS_GETVERSION, &version)) {
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
        /*
         * Looks like atm (20100109) FreeBSD knows OSS_GETVERSION
         * since 7.x, but currently only on the mixer device (or in
         * the Linuxolator), and in the native version that part of
         * the code is in fact never reached so the ioctl fails anyway.
         * Until this is fixed, just check the errno and if its what
         * FreeBSD's sound drivers return atm assume they are new enough.
         */
        if (errno == EINVAL) {
            *version = 0x040000;
            return 0;
        }
#endif
        oss_logerr2 (errno, typ, "Failed to get OSS version\n");
        return -1;
    }
    return 0;
}
#endif

278 279
static int oss_open (int in, struct oss_params *req,
                     struct oss_params *obt, int *pfd)
bellard's avatar
bellard committed
280 281
{
    int fd;
malc's avatar
malc committed
282
    int oflags = conf.exclusive ? O_EXCL : 0;
bellard's avatar
bellard committed
283 284
    audio_buf_info abinfo;
    int fmt, freq, nchannels;
malc's avatar
malc committed
285
    int setfragment = 1;
286 287
    const char *dspname = in ? conf.devpath_in : conf.devpath_out;
    const char *typ = in ? "ADC" : "DAC";
bellard's avatar
bellard committed
288

289
    /* Kludge needed to have working mmap on Linux */
malc's avatar
malc committed
290 291
    oflags |= conf.try_mmap ? O_RDWR : (in ? O_RDONLY : O_WRONLY);

292
    fd = open (dspname, oflags | O_NONBLOCK);
bellard's avatar
bellard committed
293
    if (-1 == fd) {
294
        oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname);
bellard's avatar
bellard committed
295 296 297 298 299 300 301 302
        return -1;
    }

    freq = req->freq;
    nchannels = req->nchannels;
    fmt = req->fmt;

    if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &fmt)) {
303
        oss_logerr2 (errno, typ, "Failed to set sample size %d\n", req->fmt);
bellard's avatar
bellard committed
304 305 306 307
        goto err;
    }

    if (ioctl (fd, SNDCTL_DSP_CHANNELS, &nchannels)) {
308 309
        oss_logerr2 (errno, typ, "Failed to set number of channels %d\n",
                     req->nchannels);
bellard's avatar
bellard committed
310 311 312 313
        goto err;
    }

    if (ioctl (fd, SNDCTL_DSP_SPEED, &freq)) {
314
        oss_logerr2 (errno, typ, "Failed to set frequency %d\n", req->freq);
bellard's avatar
bellard committed
315 316 317
        goto err;
    }

318
    if (ioctl (fd, SNDCTL_DSP_NONBLOCK, NULL)) {
319
        oss_logerr2 (errno, typ, "Failed to set non-blocking mode\n");
bellard's avatar
bellard committed
320 321 322
        goto err;
    }

323
#ifdef USE_DSP_POLICY
324 325
    if (conf.policy >= 0) {
        int version;
malc's avatar
malc committed
326

327
        if (!oss_get_version (fd, &version, typ)) {
malc's avatar
malc committed
328 329 330
            if (conf.debug) {
                dolog ("OSS version = %#x\n", version);
            }
331

malc's avatar
malc committed
332 333 334 335 336 337 338 339 340
            if (version >= 0x040000) {
                int policy = conf.policy;
                if (ioctl (fd, SNDCTL_DSP_POLICY, &policy)) {
                    oss_logerr2 (errno, typ,
                                 "Failed to set timing policy to %d\n",
                                 conf.policy);
                    goto err;
                }
                setfragment = 0;
341
            }
malc's avatar
malc committed
342 343 344
        }
    }
#endif
malc's avatar
malc committed
345 346

    if (setfragment) {
malc's avatar
malc committed
347 348 349 350 351 352
        int mmmmssss = (req->nfrags << 16) | ctz32 (req->fragsize);
        if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) {
            oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n",
                         req->nfrags, req->fragsize);
            goto err;
        }
bellard's avatar
bellard committed
353 354
    }

355 356
    if (ioctl (fd, in ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE, &abinfo)) {
        oss_logerr2 (errno, typ, "Failed to get buffer length\n");
bellard's avatar
bellard committed
357 358 359
        goto err;
    }

360 361 362 363 364 365
    if (!abinfo.fragstotal || !abinfo.fragsize) {
        AUD_log (AUDIO_CAP, "Returned bogus buffer information(%d, %d) for %s\n",
                 abinfo.fragstotal, abinfo.fragsize, typ);
        goto err;
    }

bellard's avatar
bellard committed
366 367 368 369 370 371 372
    obt->fmt = fmt;
    obt->nchannels = nchannels;
    obt->freq = freq;
    obt->nfrags = abinfo.fragstotal;
    obt->fragsize = abinfo.fragsize;
    *pfd = fd;

bellard's avatar
bellard committed
373
#ifdef DEBUG_MISMATCHES
bellard's avatar
bellard committed
374 375 376 377 378 379
    if ((req->fmt != obt->fmt) ||
        (req->nchannels != obt->nchannels) ||
        (req->freq != obt->freq) ||
        (req->fragsize != obt->fragsize) ||
        (req->nfrags != obt->nfrags)) {
        dolog ("Audio parameters mismatch\n");
380
        oss_dump_info (req, obt);
bellard's avatar
bellard committed
381
    }
bellard's avatar
bellard committed
382
#endif
bellard's avatar
bellard committed
383

384 385
#ifdef DEBUG
    oss_dump_info (req, obt);
bellard's avatar
bellard committed
386 387 388
#endif
    return 0;

389 390
 err:
    oss_anal_close (&fd);
bellard's avatar
bellard committed
391 392 393
    return -1;
}

malc's avatar
malc committed
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
static void oss_write_pending (OSSVoiceOut *oss)
{
    HWVoiceOut *hw = &oss->hw;

    if (oss->mmapped) {
        return;
    }

    while (oss->pending) {
        int samples_written;
        ssize_t bytes_written;
        int samples_till_end = hw->samples - oss->wpos;
        int samples_to_write = audio_MIN (oss->pending, samples_till_end);
        int bytes_to_write = samples_to_write << hw->info.shift;
        void *pcm = advance (oss->pcm_buf, oss->wpos << hw->info.shift);

        bytes_written = write (oss->fd, pcm, bytes_to_write);
        if (bytes_written < 0) {
            if (errno != EAGAIN) {
                oss_logerr (errno, "failed to write %d bytes\n",
                            bytes_to_write);
            }
            break;
        }

        if (bytes_written & hw->info.align) {
            dolog ("misaligned write asked for %d, but got %zd\n",
                   bytes_to_write, bytes_written);
            return;
        }

        samples_written = bytes_written >> hw->info.shift;
        oss->pending -= samples_written;
        oss->wpos = (oss->wpos + samples_written) % hw->samples;
        if (bytes_written - bytes_to_write) {
            break;
        }
    }
}

malc's avatar
malc committed
434
static int oss_run_out (HWVoiceOut *hw, int live)
bellard's avatar
bellard committed
435
{
436
    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
malc's avatar
malc committed
437
    int err, decr;
bellard's avatar
bellard committed
438 439
    struct audio_buf_info abinfo;
    struct count_info cntinfo;
bellard's avatar
bellard committed
440
    int bufsize;
bellard's avatar
bellard committed
441

bellard's avatar
bellard committed
442 443
    bufsize = hw->samples << hw->info.shift;

bellard's avatar
bellard committed
444
    if (oss->mmapped) {
malc's avatar
malc committed
445
        int bytes, pos;
bellard's avatar
bellard committed
446 447 448

        err = ioctl (oss->fd, SNDCTL_DSP_GETOPTR, &cntinfo);
        if (err < 0) {
449 450
            oss_logerr (errno, "SNDCTL_DSP_GETOPTR failed\n");
            return 0;
bellard's avatar
bellard committed
451 452
        }

malc's avatar
malc committed
453 454
        pos = hw->rpos << hw->info.shift;
        bytes = audio_ring_dist (cntinfo.ptr, pos, bufsize);
455
        decr = audio_MIN (bytes >> hw->info.shift, live);
bellard's avatar
bellard committed
456 457 458 459
    }
    else {
        err = ioctl (oss->fd, SNDCTL_DSP_GETOSPACE, &abinfo);
        if (err < 0) {
460 461 462 463
            oss_logerr (errno, "SNDCTL_DSP_GETOPTR failed\n");
            return 0;
        }

464 465 466
        if (abinfo.bytes > bufsize) {
            if (conf.debug) {
                dolog ("warning: Invalid available size, size=%d bufsize=%d\n"
malc's avatar
malc committed
467
                       "please report your OS/audio hw to av1474@comtv.ru\n",
468 469 470 471 472 473 474 475 476 477
                       abinfo.bytes, bufsize);
            }
            abinfo.bytes = bufsize;
        }

        if (abinfo.bytes < 0) {
            if (conf.debug) {
                dolog ("warning: Invalid available size, size=%d bufsize=%d\n",
                       abinfo.bytes, bufsize);
            }
478
            return 0;
bellard's avatar
bellard committed
479 480
        }

481 482 483 484
        decr = audio_MIN (abinfo.bytes >> hw->info.shift, live);
        if (!decr) {
            return 0;
        }
bellard's avatar
bellard committed
485 486
    }

malc's avatar
malc committed
487 488 489
    decr = audio_pcm_hw_clip_out (hw, oss->pcm_buf, decr, oss->pending);
    oss->pending += decr;
    oss_write_pending (oss);
bellard's avatar
bellard committed
490

491
    return decr;
bellard's avatar
bellard committed
492 493
}

494
static void oss_fini_out (HWVoiceOut *hw)
bellard's avatar
bellard committed
495 496
{
    int err;
497
    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
bellard's avatar
bellard committed
498

499 500
    ldebug ("oss_fini\n");
    oss_anal_close (&oss->fd);
bellard's avatar
bellard committed
501 502 503

    if (oss->pcm_buf) {
        if (oss->mmapped) {
bellard's avatar
bellard committed
504
            err = munmap (oss->pcm_buf, hw->samples << hw->info.shift);
bellard's avatar
bellard committed
505
            if (err) {
506
                oss_logerr (errno, "Failed to unmap buffer %p, size %d\n",
bellard's avatar
bellard committed
507
                            oss->pcm_buf, hw->samples << hw->info.shift);
bellard's avatar
bellard committed
508 509 510
            }
        }
        else {
511
            g_free (oss->pcm_buf);
bellard's avatar
bellard committed
512 513 514 515 516
        }
        oss->pcm_buf = NULL;
    }
}

malc's avatar
malc committed
517
static int oss_init_out (HWVoiceOut *hw, struct audsettings *as)
bellard's avatar
bellard committed
518
{
519
    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
bellard's avatar
bellard committed
520
    struct oss_params req, obt;
521 522 523 524
    int endianness;
    int err;
    int fd;
    audfmt_e effective_fmt;
malc's avatar
malc committed
525
    struct audsettings obt_as;
bellard's avatar
bellard committed
526

bellard's avatar
bellard committed
527 528
    oss->fd = -1;

529
    req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
bellard's avatar
bellard committed
530 531
    req.freq = as->freq;
    req.nchannels = as->nchannels;
bellard's avatar
bellard committed
532 533 534
    req.fragsize = conf.fragsize;
    req.nfrags = conf.nfrags;

535
    if (oss_open (0, &req, &obt, &fd)) {
bellard's avatar
bellard committed
536
        return -1;
537
    }
bellard's avatar
bellard committed
538

539 540 541 542 543
    err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
    if (err) {
        oss_anal_close (&fd);
        return -1;
    }
bellard's avatar
bellard committed
544

bellard's avatar
bellard committed
545 546 547
    obt_as.freq = obt.freq;
    obt_as.nchannels = obt.nchannels;
    obt_as.fmt = effective_fmt;
548
    obt_as.endianness = endianness;
bellard's avatar
bellard committed
549

550
    audio_pcm_init_info (&hw->info, &obt_as);
bellard's avatar
bellard committed
551 552
    oss->nfrags = obt.nfrags;
    oss->fragsize = obt.fragsize;
bellard's avatar
bellard committed
553 554 555 556 557 558 559

    if (obt.nfrags * obt.fragsize & hw->info.align) {
        dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n",
               obt.nfrags * obt.fragsize, hw->info.align + 1);
    }

    hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift;
bellard's avatar
bellard committed
560 561 562

    oss->mmapped = 0;
    if (conf.try_mmap) {
bellard's avatar
bellard committed
563
        oss->pcm_buf = mmap (
564
            NULL,
bellard's avatar
bellard committed
565 566 567 568 569 570
            hw->samples << hw->info.shift,
            PROT_READ | PROT_WRITE,
            MAP_SHARED,
            fd,
            0
            );
bellard's avatar
bellard committed
571
        if (oss->pcm_buf == MAP_FAILED) {
572
            oss_logerr (errno, "Failed to map %d bytes of DAC\n",
bellard's avatar
bellard committed
573
                        hw->samples << hw->info.shift);
malc's avatar
malc committed
574 575
        }
        else {
bellard's avatar
bellard committed
576 577
            int err;
            int trig = 0;
578 579
            if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
                oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
bellard's avatar
bellard committed
580
            }
bellard's avatar
bellard committed
581 582
            else {
                trig = PCM_ENABLE_OUTPUT;
583 584 585 586 587
                if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
                    oss_logerr (
                        errno,
                        "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"
                        );
bellard's avatar
bellard committed
588 589 590 591
                }
                else {
                    oss->mmapped = 1;
                }
bellard's avatar
bellard committed
592 593
            }

bellard's avatar
bellard committed
594
            if (!oss->mmapped) {
bellard's avatar
bellard committed
595
                err = munmap (oss->pcm_buf, hw->samples << hw->info.shift);
bellard's avatar
bellard committed
596
                if (err) {
597
                    oss_logerr (errno, "Failed to unmap buffer %p size %d\n",
bellard's avatar
bellard committed
598
                                oss->pcm_buf, hw->samples << hw->info.shift);
bellard's avatar
bellard committed
599
                }
bellard's avatar
bellard committed
600 601 602 603 604
            }
        }
    }

    if (!oss->mmapped) {
bellard's avatar
bellard committed
605 606 607 608 609
        oss->pcm_buf = audio_calloc (
            AUDIO_FUNC,
            hw->samples,
            1 << hw->info.shift
            );
bellard's avatar
bellard committed
610
        if (!oss->pcm_buf) {
bellard's avatar
bellard committed
611 612 613 614 615
            dolog (
                "Could not allocate DAC buffer (%d samples, each %d bytes)\n",
                hw->samples,
                1 << hw->info.shift
                );
616
            oss_anal_close (&fd);
bellard's avatar
bellard committed
617 618 619 620
            return -1;
        }
    }

621
    oss->fd = fd;
bellard's avatar
bellard committed
622 623 624
    return 0;
}

625
static int oss_ctl_out (HWVoiceOut *hw, int cmd, ...)
bellard's avatar
bellard committed
626 627
{
    int trig;
628
    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
bellard's avatar
bellard committed
629 630 631

    switch (cmd) {
    case VOICE_ENABLE:
632 633 634
        {
            va_list ap;
            int poll_mode;
malc's avatar
malc committed
635

636 637 638
            va_start (ap, cmd);
            poll_mode = va_arg (ap, int);
            va_end (ap);
malc's avatar
malc committed
639

640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
            ldebug ("enabling voice\n");
            if (poll_mode && oss_poll_out (hw)) {
                poll_mode = 0;
            }
            hw->poll_mode = poll_mode;

            if (!oss->mmapped) {
                return 0;
            }

            audio_pcm_info_clear_buf (&hw->info, oss->pcm_buf, hw->samples);
            trig = PCM_ENABLE_OUTPUT;
            if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
                oss_logerr (
                    errno,
                    "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"
                    );
                return -1;
            }
bellard's avatar
bellard committed
659 660 661 662
        }
        break;

    case VOICE_DISABLE:
malc's avatar
malc committed
663 664 665 666 667 668 669 670 671
        if (hw->poll_mode) {
            qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
            hw->poll_mode = 0;
        }

        if (!oss->mmapped) {
            return 0;
        }

bellard's avatar
bellard committed
672 673 674
        ldebug ("disabling voice\n");
        trig = 0;
        if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
675
            oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
bellard's avatar
bellard committed
676 677 678 679 680 681 682
            return -1;
        }
        break;
    }
    return 0;
}

malc's avatar
malc committed
683
static int oss_init_in (HWVoiceIn *hw, struct audsettings *as)
684 685 686 687 688 689 690
{
    OSSVoiceIn *oss = (OSSVoiceIn *) hw;
    struct oss_params req, obt;
    int endianness;
    int err;
    int fd;
    audfmt_e effective_fmt;
malc's avatar
malc committed
691
    struct audsettings obt_as;
692

bellard's avatar
bellard committed
693 694
    oss->fd = -1;

695
    req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
bellard's avatar
bellard committed
696 697
    req.freq = as->freq;
    req.nchannels = as->nchannels;
698 699 700 701 702 703 704 705 706 707 708 709
    req.fragsize = conf.fragsize;
    req.nfrags = conf.nfrags;
    if (oss_open (1, &req, &obt, &fd)) {
        return -1;
    }

    err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
    if (err) {
        oss_anal_close (&fd);
        return -1;
    }

bellard's avatar
bellard committed
710 711 712
    obt_as.freq = obt.freq;
    obt_as.nchannels = obt.nchannels;
    obt_as.fmt = effective_fmt;
713
    obt_as.endianness = endianness;
bellard's avatar
bellard committed
714

715
    audio_pcm_init_info (&hw->info, &obt_as);
716 717
    oss->nfrags = obt.nfrags;
    oss->fragsize = obt.fragsize;
bellard's avatar
bellard committed
718 719 720 721 722 723 724 725

    if (obt.nfrags * obt.fragsize & hw->info.align) {
        dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
               obt.nfrags * obt.fragsize, hw->info.align + 1);
    }

    hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift;
    oss->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
726
    if (!oss->pcm_buf) {
bellard's avatar
bellard committed
727 728
        dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
               hw->samples, 1 << hw->info.shift);
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
        oss_anal_close (&fd);
        return -1;
    }

    oss->fd = fd;
    return 0;
}

static void oss_fini_in (HWVoiceIn *hw)
{
    OSSVoiceIn *oss = (OSSVoiceIn *) hw;

    oss_anal_close (&oss->fd);

    if (oss->pcm_buf) {
744
        g_free (oss->pcm_buf);
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
        oss->pcm_buf = NULL;
    }
}

static int oss_run_in (HWVoiceIn *hw)
{
    OSSVoiceIn *oss = (OSSVoiceIn *) hw;
    int hwshift = hw->info.shift;
    int i;
    int live = audio_pcm_hw_get_live_in (hw);
    int dead = hw->samples - live;
    size_t read_samples = 0;
    struct {
        int add;
        int len;
    } bufs[2] = {
malc's avatar
malc committed
761 762
        { .add = hw->wpos, .len = 0 },
        { .add = 0,        .len = 0 }
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
    };

    if (!dead) {
        return 0;
    }

    if (hw->wpos + dead > hw->samples) {
        bufs[0].len = (hw->samples - hw->wpos) << hwshift;
        bufs[1].len = (dead - (hw->samples - hw->wpos)) << hwshift;
    }
    else {
        bufs[0].len = dead << hwshift;
    }

    for (i = 0; i < 2; ++i) {
        ssize_t nread;

        if (bufs[i].len) {
            void *p = advance (oss->pcm_buf, bufs[i].add << hwshift);
            nread = read (oss->fd, p, bufs[i].len);

            if (nread > 0) {
                if (nread & hw->info.align) {
bellard's avatar
bellard committed
786
                    dolog ("warning: Misaligned read %zd (requested %d), "
787 788 789 790
                           "alignment %d\n", nread, bufs[i].add << hwshift,
                           hw->info.align + 1);
                }
                read_samples += nread >> hwshift;
791
                hw->conv (hw->conv_buf + bufs[i].add, p, nread >> hwshift);
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
            }

            if (bufs[i].len - nread) {
                if (nread == -1) {
                    switch (errno) {
                    case EINTR:
                    case EAGAIN:
                        break;
                    default:
                        oss_logerr (
                            errno,
                            "Failed to read %d bytes of audio (to %p)\n",
                            bufs[i].len, p
                            );
                        break;
                    }
                }
                break;
            }
        }
    }

    hw->wpos = (hw->wpos + read_samples) % hw->samples;
    return read_samples;
}

static int oss_read (SWVoiceIn *sw, void *buf, int size)
{
    return audio_pcm_sw_read (sw, buf, size);
}

static int oss_ctl_in (HWVoiceIn *hw, int cmd, ...)
{
malc's avatar
malc committed
825 826 827 828
    OSSVoiceIn *oss = (OSSVoiceIn *) hw;

    switch (cmd) {
    case VOICE_ENABLE:
829 830 831 832 833 834 835 836 837 838 839 840
        {
            va_list ap;
            int poll_mode;

            va_start (ap, cmd);
            poll_mode = va_arg (ap, int);
            va_end (ap);

            if (poll_mode && oss_poll_in (hw)) {
                poll_mode = 0;
            }
            hw->poll_mode = poll_mode;
malc's avatar
malc committed
841 842 843 844 845 846 847 848 849 850
        }
        break;

    case VOICE_DISABLE:
        if (hw->poll_mode) {
            hw->poll_mode = 0;
            qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
        }
        break;
    }
851 852 853
    return 0;
}

bellard's avatar
bellard committed
854 855 856 857 858 859 860
static void *oss_audio_init (void)
{
    return &conf;
}

static void oss_audio_fini (void *opaque)
{
861
    (void) opaque;
bellard's avatar
bellard committed
862 863
}

864
static struct audio_option oss_options[] = {
malc's avatar
malc committed
865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
    {
        .name  = "FRAGSIZE",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.fragsize,
        .descr = "Fragment size in bytes"
    },
    {
        .name  = "NFRAGS",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.nfrags,
        .descr = "Number of fragments"
    },
    {
        .name  = "MMAP",
        .tag   = AUD_OPT_BOOL,
        .valp  = &conf.try_mmap,
        .descr = "Try using memory mapped access"
    },
    {
        .name  = "DAC_DEV",
        .tag   = AUD_OPT_STR,
        .valp  = &conf.devpath_out,
        .descr = "Path to DAC device"
    },
    {
        .name  = "ADC_DEV",
        .tag   = AUD_OPT_STR,
        .valp  = &conf.devpath_in,
        .descr = "Path to ADC device"
    },
malc's avatar
malc committed
895 896 897 898 899 900
    {
        .name  = "EXCLUSIVE",
        .tag   = AUD_OPT_BOOL,
        .valp  = &conf.exclusive,
        .descr = "Open device in exclusive mode (vmix wont work)"
    },
901
#ifdef USE_DSP_POLICY
malc's avatar
malc committed
902 903 904 905 906 907 908
    {
        .name  = "POLICY",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.policy,
        .descr = "Set the timing policy of the device, -1 to use fragment mode",
    },
#endif
malc's avatar
malc committed
909 910 911 912 913 914
    {
        .name  = "DEBUG",
        .tag   = AUD_OPT_BOOL,
        .valp  = &conf.debug,
        .descr = "Turn on some debugging messages"
    },
915
    { /* End of list */ }
916 917
};

918
static struct audio_pcm_ops oss_pcm_ops = {
919 920 921 922 923 924 925 926 927 928 929
    .init_out = oss_init_out,
    .fini_out = oss_fini_out,
    .run_out  = oss_run_out,
    .write    = oss_write,
    .ctl_out  = oss_ctl_out,

    .init_in  = oss_init_in,
    .fini_in  = oss_fini_in,
    .run_in   = oss_run_in,
    .read     = oss_read,
    .ctl_in   = oss_ctl_in
bellard's avatar
bellard committed
930 931
};

932
struct audio_driver oss_audio_driver = {
933 934 935 936 937 938 939 940 941 942 943
    .name           = "oss",
    .descr          = "OSS http://www.opensound.com",
    .options        = oss_options,
    .init           = oss_audio_init,
    .fini           = oss_audio_fini,
    .pcm_ops        = &oss_pcm_ops,
    .can_be_default = 1,
    .max_voices_out = INT_MAX,
    .max_voices_in  = INT_MAX,
    .voice_size_out = sizeof (OSSVoiceOut),
    .voice_size_in  = sizeof (OSSVoiceIn)
bellard's avatar
bellard committed
944
};