コード例 #1
0
ファイル: ossaudiodev.c プロジェクト: Anzumana/cpython
static PyObject *
oss_reset(oss_audio_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_0(self->fd, args, "reset", SNDCTL_DSP_RESET);
}
コード例 #2
0
ファイル: ossaudiodev.c プロジェクト: Anzumana/cpython
static PyObject *
oss_post(oss_audio_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_0(self->fd, args, "post", SNDCTL_DSP_POST);
}
コード例 #3
0
ファイル: ossaudiodev.c プロジェクト: Anzumana/cpython
static PyObject *
oss_sync(oss_audio_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_0(self->fd, args, "sync", SNDCTL_DSP_SYNC);
}
コード例 #4
0
ファイル: ossaudiodev.c プロジェクト: Anzumana/cpython
static PyObject *
oss_speed(oss_audio_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1(self->fd, args, "speed", SNDCTL_DSP_SPEED);
}
コード例 #5
0
ファイル: ossaudiodev.c プロジェクト: Anzumana/cpython
static PyObject *
oss_channels(oss_audio_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1(self->fd, args, "channels", SNDCTL_DSP_CHANNELS);
}
コード例 #6
0
ファイル: ossaudiodev.c プロジェクト: Anzumana/cpython
static PyObject *
oss_setfmt(oss_audio_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1(self->fd, args, "setfmt", SNDCTL_DSP_SETFMT);
}
コード例 #7
0
ファイル: ossaudiodev.c プロジェクト: 524777134/cpython
static PyObject *
oss_mixer_fileno(oss_mixer_t *self, PyObject *unused)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return PyLong_FromLong(self->fd);
}
コード例 #8
0
ファイル: ossaudiodev.c プロジェクト: jadore/cpython
static PyObject *
oss_setparameters(oss_audio_t *self, PyObject *args)
{
    int wanted_fmt, wanted_channels, wanted_rate, strict=0;
    int fmt, channels, rate;
    PyObject * rv;                    /* return tuple (fmt, channels, rate) */

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (!PyArg_ParseTuple(args, "iii|i:setparameters",
                          &wanted_fmt, &wanted_channels, &wanted_rate,
                          &strict))
        return NULL;

    fmt = wanted_fmt;
    if (ioctl(self->fd, SNDCTL_DSP_SETFMT, &fmt) == -1) {
        return PyErr_SetFromErrno(PyExc_IOError);
    }
    if (strict && fmt != wanted_fmt) {
        return PyErr_Format
            (OSSAudioError,
             "unable to set requested format (wanted %d, got %d)",
             wanted_fmt, fmt);
    }

    channels = wanted_channels;
    if (ioctl(self->fd, SNDCTL_DSP_CHANNELS, &channels) == -1) {
        return PyErr_SetFromErrno(PyExc_IOError);
    }
    if (strict && channels != wanted_channels) {
        return PyErr_Format
            (OSSAudioError,
             "unable to set requested channels (wanted %d, got %d)",
             wanted_channels, channels);
    }

    rate = wanted_rate;
    if (ioctl(self->fd, SNDCTL_DSP_SPEED, &rate) == -1) {
        return PyErr_SetFromErrno(PyExc_IOError);
    }
    if (strict && rate != wanted_rate) {
        return PyErr_Format
            (OSSAudioError,
             "unable to set requested rate (wanted %d, got %d)",
             wanted_rate, rate);
    }

    /* Construct the return value: a (fmt, channels, rate) tuple that
       tells what the audio hardware was actually set to. */
    rv = PyTuple_New(3);
    if (rv == NULL)
        return NULL;
    PyTuple_SET_ITEM(rv, 0, PyLong_FromLong(fmt));
    PyTuple_SET_ITEM(rv, 1, PyLong_FromLong(channels));
    PyTuple_SET_ITEM(rv, 2, PyLong_FromLong(rate));
    return rv;
}
コード例 #9
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_mixer_set_recsrc(oss_mixer_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1(self->fd, args, "set_recsrc",
        SOUND_MIXER_WRITE_RECSRC);
}
コード例 #10
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_mixer_get_recsrc(oss_mixer_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1_internal(self->fd, args, "get_recsrc",
        SOUND_MIXER_READ_RECSRC);
}
コード例 #11
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_mixer_reccontrols(oss_mixer_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1_internal(self->fd, args, "reccontrols",
        SOUND_MIXER_READ_RECMASK);
}
コード例 #12
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_mixer_stereocontrols(oss_mixer_t *self, PyObject *args)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    return _do_ioctl_1_internal(self->fd, args, "stereocontrols",
        SOUND_MIXER_READ_STEREODEVS);
}
コード例 #13
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_writeall(oss_audio_t *self, PyObject *args)
{
    char *cp;
    int rv, size;
    fd_set write_set_fds;
    int select_rv;

    /* NB. writeall() is only useful in non-blocking mode: according to
       Guenter Geiger <*****@*****.**> on the linux-audio-dev list
       (http://eca.cx/lad/2002/11/0380.html), OSS guarantees that
       write() in blocking mode consumes the whole buffer.  In blocking
       mode, the behaviour of write() and writeall() from Python is
       indistinguishable. */

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (!PyArg_ParseTuple(args, "y#:write", &cp, &size))
        return NULL;

    if (!_PyIsSelectable_fd(self->fd)) {
        PyErr_SetString(PyExc_ValueError,
                        "file descriptor out of range for select");
        return NULL;
    }
    /* use select to wait for audio device to be available */
    FD_ZERO(&write_set_fds);
    FD_SET(self->fd, &write_set_fds);

    while (size > 0) {
        Py_BEGIN_ALLOW_THREADS
        select_rv = select(self->fd+1, NULL, &write_set_fds, NULL, NULL);
        Py_END_ALLOW_THREADS
        assert(select_rv != 0);         /* no timeout, can't expire */
        if (select_rv == -1)
            return PyErr_SetFromErrno(PyExc_IOError);

        Py_BEGIN_ALLOW_THREADS
        rv = write(self->fd, cp, size);
        Py_END_ALLOW_THREADS
        if (rv == -1) {
            if (errno == EAGAIN) {      /* buffer is full, try again */
                errno = 0;
                continue;
            } else                      /* it's a real error */
                return PyErr_SetFromErrno(PyExc_IOError);
        } else {                        /* wrote rv bytes */
            self->ocount += rv;
            size -= rv;
            cp += rv;
        }
    }
    Py_INCREF(Py_None);
    return Py_None;
}
コード例 #14
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_getfmts(oss_audio_t *self, PyObject *unused)
{
    int mask;

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (ioctl(self->fd, SNDCTL_DSP_GETFMTS, &mask) == -1)
        return PyErr_SetFromErrno(PyExc_IOError);
    return PyLong_FromLong(mask);
}
コード例 #15
0
ファイル: ossaudiodev.c プロジェクト: M31MOTH/cpython
static PyObject *
oss_nonblock(oss_audio_t *self, PyObject *unused)
{
    if (!_is_fd_valid(self->fd))
        return NULL;

    /* Hmmm: it doesn't appear to be possible to return to blocking
       mode once we're in non-blocking mode! */
    if (ioctl(self->fd, SNDCTL_DSP_NONBLOCK, NULL) == -1)
        return PyErr_SetFromErrno(PyExc_OSError);
    Py_RETURN_NONE;
}
コード例 #16
0
ファイル: ossaudiodev.c プロジェクト: M31MOTH/cpython
/* bufsize returns the size of the hardware audio buffer in number
   of samples */
static PyObject *
oss_bufsize(oss_audio_t *self, PyObject *unused)
{
    audio_buf_info ai;
    int nchannels=0, ssize=0;

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (_ssize(self, &nchannels, &ssize) < 0 || !nchannels || !ssize) {
        PyErr_SetFromErrno(PyExc_OSError);
        return NULL;
    }
    if (ioctl(self->fd, SNDCTL_DSP_GETOSPACE, &ai) < 0) {
        PyErr_SetFromErrno(PyExc_OSError);
        return NULL;
    }
    return PyLong_FromLong((ai.fragstotal * ai.fragsize) / (nchannels * ssize));
}
コード例 #17
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_getptr(oss_audio_t *self, PyObject *unused)
{
    count_info info;
    int req;

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (self->mode == O_RDONLY)
        req = SNDCTL_DSP_GETIPTR;
    else
        req = SNDCTL_DSP_GETOPTR;
    if (ioctl(self->fd, req, &info) == -1) {
        PyErr_SetFromErrno(PyExc_IOError);
        return NULL;
    }
    return Py_BuildValue("iii", info.bytes, info.blocks, info.ptr);
}
コード例 #18
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
/* obufcount returns the number of samples that can be played without
   blocking */
static PyObject *
oss_obuffree(oss_audio_t *self, PyObject *unused)
{
    audio_buf_info ai;
    int nchannels=0, ssize=0;

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (_ssize(self, &nchannels, &ssize) < 0 || !nchannels || !ssize) {
        PyErr_SetFromErrno(PyExc_IOError);
        return NULL;
    }
    if (ioctl(self->fd, SNDCTL_DSP_GETOSPACE, &ai) < 0) {
        PyErr_SetFromErrno(PyExc_IOError);
        return NULL;
    }
    return PyLong_FromLong(ai.bytes / (ssize * nchannels));
}
コード例 #19
0
ファイル: ossaudiodev.c プロジェクト: M31MOTH/cpython
static PyObject *
oss_write(oss_audio_t *self, PyObject *args)
{
    Py_buffer data;
    Py_ssize_t rv;

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (!PyArg_ParseTuple(args, "y*:write", &data)) {
        return NULL;
    }

    rv = _Py_write(self->fd, data.buf, data.len);
    PyBuffer_Release(&data);
    if (rv == -1)
        return NULL;

    self->ocount += rv;
    return PyLong_FromLong(rv);
}
コード例 #20
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_mixer_get(oss_mixer_t *self, PyObject *args)
{
    int channel, volume;

    if (!_is_fd_valid(self->fd))
        return NULL;

    /* Can't use _do_ioctl_1 because of encoded arg thingy. */
    if (!PyArg_ParseTuple(args, "i:get", &channel))
        return NULL;

    if (channel < 0 || channel > SOUND_MIXER_NRDEVICES) {
        PyErr_SetString(OSSAudioError, "Invalid mixer channel specified.");
        return NULL;
    }

    if (ioctl(self->fd, MIXER_READ(channel), &volume) == -1)
        return PyErr_SetFromErrno(PyExc_IOError);

    return Py_BuildValue("(ii)", volume & 0xff, (volume & 0xff00) >> 8);
}
コード例 #21
0
ファイル: ossaudiodev.c プロジェクト: 1564143452/kbengine
static PyObject *
oss_write(oss_audio_t *self, PyObject *args)
{
    char *cp;
    int rv, size;

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (!PyArg_ParseTuple(args, "y#:write", &cp, &size)) {
        return NULL;
    }

    Py_BEGIN_ALLOW_THREADS
    rv = write(self->fd, cp, size);
    Py_END_ALLOW_THREADS

    if (rv == -1) {
        return PyErr_SetFromErrno(PyExc_IOError);
    } else {
        self->ocount += rv;
    }
    return PyLong_FromLong(rv);
}
コード例 #22
0
ファイル: ossaudiodev.c プロジェクト: M31MOTH/cpython
static PyObject *
oss_writeall(oss_audio_t *self, PyObject *args)
{
    Py_buffer data;
    const char *cp;
    Py_ssize_t size;
    Py_ssize_t rv;
    fd_set write_set_fds;
    int select_rv;

    /* NB. writeall() is only useful in non-blocking mode: according to
       Guenter Geiger <*****@*****.**> on the linux-audio-dev list
       (http://eca.cx/lad/2002/11/0380.html), OSS guarantees that
       write() in blocking mode consumes the whole buffer.  In blocking
       mode, the behaviour of write() and writeall() from Python is
       indistinguishable. */

    if (!_is_fd_valid(self->fd))
        return NULL;

    if (!PyArg_ParseTuple(args, "y*:writeall", &data))
        return NULL;

    if (!_PyIsSelectable_fd(self->fd)) {
        PyErr_SetString(PyExc_ValueError,
                        "file descriptor out of range for select");
        PyBuffer_Release(&data);
        return NULL;
    }
    /* use select to wait for audio device to be available */
    FD_ZERO(&write_set_fds);
    FD_SET(self->fd, &write_set_fds);
    cp = (const char *)data.buf;
    size = data.len;

    while (size > 0) {
        Py_BEGIN_ALLOW_THREADS
        select_rv = select(self->fd+1, NULL, &write_set_fds, NULL, NULL);
        Py_END_ALLOW_THREADS

        assert(select_rv != 0);   /* no timeout, can't expire */
        if (select_rv == -1) {
            PyBuffer_Release(&data);
            return PyErr_SetFromErrno(PyExc_OSError);
        }

        rv = _Py_write(self->fd, cp, Py_MIN(size, INT_MAX));
        if (rv == -1) {
            /* buffer is full, try again */
            if (errno == EAGAIN) {
                PyErr_Clear();
                continue;
            }
            /* it's a real error */
            PyBuffer_Release(&data);
            return NULL;
        }

        /* wrote rv bytes */
        self->ocount += rv;
        size -= rv;
        cp += rv;
    }
    PyBuffer_Release(&data);
    Py_RETURN_NONE;
}