src/audio/paudio/SDL_paudio.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Carsten Griwodz
    griff@kom.tu-darmstadt.de

    based on linux/SDL_dspaudio.c by Sam Lantinga
*/
#include "SDL_config.h"

/* Allow access to a raw mixing buffer */

#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/stat.h>

#include "SDL_timer.h"
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "../SDL_audiodev_c.h"
#include "SDL_paudio.h"

#define DEBUG_AUDIO 1

/* A conflict within AIX 4.3.3 <sys/> headers and probably others as well.
 * I guess nobody ever uses audio... Shame over AIX header files.  */
#include <sys/machine.h>
#undef BIG_ENDIAN
#include <sys/audio.h>

/* The tag name used by paud audio */
#define Paud_DRIVER_NAME         "paud"

/* Open the audio device for playback, and don't block if busy */
/* #define OPEN_FLAGS	(O_WRONLY|O_NONBLOCK) */
#define OPEN_FLAGS	O_WRONLY

/* Audio driver functions */
static int Paud_OpenAudio(_THIS, SDL_AudioSpec * spec);
static void Paud_WaitAudio(_THIS);
static void Paud_PlayAudio(_THIS);
static Uint8 *Paud_GetAudioBuf(_THIS);
static void Paud_CloseAudio(_THIS);

/* Audio driver bootstrap functions */

static int
Audio_Available(void)
{
    int fd;
    int available;

    available = 0;
    fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
    if (fd >= 0) {
        available = 1;
        close(fd);
    }
    return (available);
}

static void
Audio_DeleteDevice(SDL_AudioDevice * device)
{
    SDL_free(device->hidden);
    SDL_free(device);
}

static SDL_AudioDevice *
Audio_CreateDevice(int devindex)
{
    SDL_AudioDevice *this;

    /* Initialize all variables that we clean on shutdown */
    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
    if (this) {
        SDL_memset(this, 0, (sizeof *this));
        this->hidden = (struct SDL_PrivateAudioData *)
            SDL_malloc((sizeof *this->hidden));
    }
    if ((this == NULL) || (this->hidden == NULL)) {
        SDL_OutOfMemory();
        if (this) {
            SDL_free(this);
        }
        return (0);
    }
    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
    audio_fd = -1;

    /* Set the function pointers */
    this->OpenAudio = Paud_OpenAudio;
    this->WaitAudio = Paud_WaitAudio;
    this->PlayAudio = Paud_PlayAudio;
    this->GetAudioBuf = Paud_GetAudioBuf;
    this->CloseAudio = Paud_CloseAudio;

    this->free = Audio_DeleteDevice;

    return this;
}

AudioBootStrap Paud_bootstrap = {
    Paud_DRIVER_NAME, "AIX Paudio",
    Audio_Available, Audio_CreateDevice, 0
};

/* This function waits until it is possible to write a full sound buffer */
static void
Paud_WaitAudio(_THIS)
{
    fd_set fdset;

    /* See if we need to use timed audio synchronization */
    if (frame_ticks) {
        /* Use timer for general audio synchronization */
        Sint32 ticks;

        ticks = ((Sint32) (next_frame - SDL_GetTicks())) - FUDGE_TICKS;
        if (ticks > 0) {
            SDL_Delay(ticks);
        }
    } else {
        audio_buffer paud_bufinfo;

        /* Use select() for audio synchronization */
        struct timeval timeout;
        FD_ZERO(&fdset);
        FD_SET(audio_fd, &fdset);

        if (ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
#ifdef DEBUG_AUDIO
            fprintf(stderr, "Couldn't get audio buffer information\n");
#endif
            timeout.tv_sec = 10;
            timeout.tv_usec = 0;
        } else {
            long ms_in_buf = paud_bufinfo.write_buf_time;
            timeout.tv_sec = ms_in_buf / 1000;
            ms_in_buf = ms_in_buf - timeout.tv_sec * 1000;
            timeout.tv_usec = ms_in_buf * 1000;
#ifdef DEBUG_AUDIO
            fprintf(stderr,
                    "Waiting for write_buf_time=%ld,%ld\n",
                    timeout.tv_sec, timeout.tv_usec);
#endif
        }

#ifdef DEBUG_AUDIO
        fprintf(stderr, "Waiting for audio to get ready\n");
#endif
        if (select(audio_fd + 1, NULL, &fdset, NULL, &timeout) <= 0) {
            const char *message =
                "Audio timeout - buggy audio driver? (disabled)";
            /*
             * In general we should never print to the screen,
             * but in this case we have no other way of letting
             * the user know what happened.
             */
            fprintf(stderr, "SDL: %s - %s\n", strerror(errno), message);
            this->enabled = 0;
            /* Don't try to close - may hang */
            audio_fd = -1;
#ifdef DEBUG_AUDIO
            fprintf(stderr, "Done disabling audio\n");
#endif
        }
#ifdef DEBUG_AUDIO
        fprintf(stderr, "Ready!\n");
#endif
    }
}

static void
Paud_PlayAudio(_THIS)
{
    int written;

    /* Write the audio data, checking for EAGAIN on broken audio drivers */
    do {
        written = write(audio_fd, mixbuf, mixlen);
        if ((written < 0) && ((errno == 0) || (errno == EAGAIN))) {
            SDL_Delay(1);       /* Let a little CPU time go by */
        }
    }
    while ((written < 0) &&
           ((errno == 0) || (errno == EAGAIN) || (errno == EINTR)));

    /* If timer synchronization is enabled, set the next write frame */
    if (frame_ticks) {
        next_frame += frame_ticks;
    }

    /* If we couldn't write, assume fatal error for now */
    if (written < 0) {
        this->enabled = 0;
    }
#ifdef DEBUG_AUDIO
    fprintf(stderr, "Wrote %d bytes of audio data\n", written);
#endif
}

static Uint8 *
Paud_GetAudioBuf(_THIS)
{
    return mixbuf;
}

static void
Paud_CloseAudio(_THIS)
{
    if (mixbuf != NULL) {
        SDL_FreeAudioMem(mixbuf);
        mixbuf = NULL;
    }
    if (audio_fd >= 0) {
        close(audio_fd);
        audio_fd = -1;
    }
}

static int
Paud_OpenAudio(_THIS, SDL_AudioSpec * spec)
{
    char audiodev[1024];
    int format;
    int bytes_per_sample;
    SDL_AudioFormat test_format;
    audio_init paud_init;
    audio_buffer paud_bufinfo;
    audio_status paud_status;
    audio_control paud_control;
    audio_change paud_change;

    /* Reset the timer synchronization flag */
    frame_ticks = 0.0;

    /* Open the audio device */
    audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
    if (audio_fd < 0) {
        SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
        return -1;
    }

    /*
     * We can't set the buffer size - just ask the device for the maximum
     * that we can have.
     */
    if (ioctl(audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {
        SDL_SetError("Couldn't get audio buffer information");
        return -1;
    }

    mixbuf = NULL;

    if (spec->channels > 1)
        spec->channels = 2;
    else
        spec->channels = 1;

    /*
     * Fields in the audio_init structure:
     *
     * Ignored by us:
     *
     * paud.loadpath[LOAD_PATH]; * DSP code to load, MWave chip only?
     * paud.slot_number;         * slot number of the adapter
     * paud.device_id;           * adapter identification number
     *
     * Input:
     *
     * paud.srate;           * the sampling rate in Hz
     * paud.bits_per_sample; * 8, 16, 32, ...
     * paud.bsize;           * block size for this rate
     * paud.mode;            * ADPCM, PCM, MU_LAW, A_LAW, SOURCE_MIX
     * paud.channels;        * 1=mono, 2=stereo
     * paud.flags;           * FIXED - fixed length data
     *                       * LEFT_ALIGNED, RIGHT_ALIGNED (var len only)
     *                       * TWOS_COMPLEMENT - 2's complement data
     *                       * SIGNED - signed? comment seems wrong in sys/audio.h
     *                       * BIG_ENDIAN
     * paud.operation;       * PLAY, RECORD
     *
     * Output:
     *
     * paud.flags;           * PITCH            - pitch is supported
     *                       * INPUT            - input is supported
     *                       * OUTPUT           - output is supported
     *                       * MONITOR          - monitor is supported
     *                       * VOLUME           - volume is supported
     *                       * VOLUME_DELAY     - volume delay is supported
     *                       * BALANCE          - balance is supported
     *                       * BALANCE_DELAY    - balance delay is supported
     *                       * TREBLE           - treble control is supported
     *                       * BASS             - bass control is supported
     *                       * BESTFIT_PROVIDED - best fit returned
     *                       * LOAD_CODE        - DSP load needed
     * paud.rc;              * NO_PLAY         - DSP code can't do play requests
     *                       * NO_RECORD       - DSP code can't do record requests
     *                       * INVALID_REQUEST - request was invalid
     *                       * CONFLICT        - conflict with open's flags
     *                       * OVERLOADED      - out of DSP MIPS or memory
     * paud.position_resolution; * smallest increment for position
     */

    paud_init.srate = spec->freq;
    paud_init.mode = PCM;
    paud_init.operation = PLAY;
    paud_init.channels = spec->channels;

    /* Try for a closest match on audio format */
    format = 0;
    for (test_format = SDL_FirstAudioFormat(spec->format);
         !format && test_format;) {
#ifdef DEBUG_AUDIO
        fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
#endif
        switch (test_format) {
        case AUDIO_U8:
            bytes_per_sample = 1;
            paud_init.bits_per_sample = 8;
            paud_init.flags = TWOS_COMPLEMENT | FIXED;
            format = 1;
            break;
        case AUDIO_S8:
            bytes_per_sample = 1;
            paud_init.bits_per_sample = 8;
            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
            format = 1;
            break;
        case AUDIO_S16LSB:
            bytes_per_sample = 2;
            paud_init.bits_per_sample = 16;
            paud_init.flags = SIGNED | TWOS_COMPLEMENT | FIXED;
            format = 1;
            break;
        case AUDIO_S16MSB:
            bytes_per_sample = 2;
            paud_init.bits_per_sample = 16;
            paud_init.flags = BIG_ENDIAN | SIGNED | TWOS_COMPLEMENT | FIXED;
            format = 1;
            break;
        case AUDIO_U16LSB:
            bytes_per_sample = 2;
            paud_init.bits_per_sample = 16;
            paud_init.flags = TWOS_COMPLEMENT | FIXED;
            format = 1;
            break;
        case AUDIO_U16MSB:
            bytes_per_sample = 2;
            paud_init.bits_per_sample = 16;
            paud_init.flags = BIG_ENDIAN | TWOS_COMPLEMENT | FIXED;
            format = 1;
            break;
        default:
            break;
        }
        if (!format) {
            test_format = SDL_NextAudioFormat();
        }
    }
    if (format == 0) {
#ifdef DEBUG_AUDIO
        fprintf(stderr, "Couldn't find any hardware audio formats\n");
#endif
        SDL_SetError("Couldn't find any hardware audio formats");
        return -1;
    }
    spec->format = test_format;

    /*
     * We know the buffer size and the max number of subsequent writes
     * that can be pending. If more than one can pend, allow the application
     * to do something like double buffering between our write buffer and
     * the device's own buffer that we are filling with write() anyway.
     *
     * We calculate spec->samples like this because SDL_CalculateAudioSpec()
     * will give put paud_bufinfo.write_buf_cap (or paud_bufinfo.write_buf_cap/2)
     * into spec->size in return.
     */
    if (paud_bufinfo.request_buf_cap == 1) {
        spec->samples = paud_bufinfo.write_buf_cap
            / bytes_per_sample / spec->channels;
    } else {
        spec->samples = paud_bufinfo.write_buf_cap
            / bytes_per_sample / spec->channels / 2;
    }
    paud_init.bsize = bytes_per_sample * spec->channels;

    SDL_CalculateAudioSpec(spec);

    /*
     * The AIX paud device init can't modify the values of the audio_init
     * structure that we pass to it. So we don't need any recalculation
     * of this stuff and no reinit call as in linux dsp and dma code.
     *
     * /dev/paud supports all of the encoding formats, so we don't need
     * to do anything like reopening the device, either.
     */
    if (ioctl(audio_fd, AUDIO_INIT, &paud_init) < 0) {
        switch (paud_init.rc) {
        case 1:
            SDL_SetError
                ("Couldn't set audio format: DSP can't do play requests");
            return -1;
            break;
        case 2:
            SDL_SetError
                ("Couldn't set audio format: DSP can't do record requests");
            return -1;
            break;
        case 4:
            SDL_SetError("Couldn't set audio format: request was invalid");
            return -1;
            break;
        case 5:
            SDL_SetError
                ("Couldn't set audio format: conflict with open's flags");
            return -1;
            break;
        case 6:
            SDL_SetError
                ("Couldn't set audio format: out of DSP MIPS or memory");
            return -1;
            break;
        default:
            SDL_SetError
                ("Couldn't set audio format: not documented in sys/audio.h");
            return -1;
            break;
        }
    }

    /* Allocate mixing buffer */
    mixlen = spec->size;
    mixbuf = (Uint8 *) SDL_AllocAudioMem(mixlen);
    if (mixbuf == NULL) {
        return -1;
    }
    SDL_memset(mixbuf, spec->silence, spec->size);

    /*
     * Set some paramters: full volume, first speaker that we can find.
     * Ignore the other settings for now.
     */
    paud_change.input = AUDIO_IGNORE;   /* the new input source */
    paud_change.output = OUTPUT_1;      /* EXTERNAL_SPEAKER,INTERNAL_SPEAKER,OUTPUT_1 */
    paud_change.monitor = AUDIO_IGNORE; /* the new monitor state */
    paud_change.volume = 0x7fffffff;    /* volume level [0-0x7fffffff] */
    paud_change.volume_delay = AUDIO_IGNORE;    /* the new volume delay */
    paud_change.balance = 0x3fffffff;   /* the new balance */
    paud_change.balance_delay = AUDIO_IGNORE;   /* the new balance delay */
    paud_change.treble = AUDIO_IGNORE;  /* the new treble state */
    paud_change.bass = AUDIO_IGNORE;    /* the new bass state */
    paud_change.pitch = AUDIO_IGNORE;   /* the new pitch state */

    paud_control.ioctl_request = AUDIO_CHANGE;
    paud_control.request_info = (char *) &paud_change;
    if (ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0) {
#ifdef DEBUG_AUDIO
        fprintf(stderr, "Can't change audio display settings\n");
#endif
    }

    /*
     * Tell the device to expect data. Actual start will wait for
     * the first write() call.
     */
    paud_control.ioctl_request = AUDIO_START;
    paud_control.position = 0;
    if (ioctl(audio_fd, AUDIO_CONTROL, &paud_control) < 0) {
#ifdef DEBUG_AUDIO
        fprintf(stderr, "Can't start audio play\n");
#endif
        SDL_SetError("Can't start audio play");
        return -1;
    }

    /* Check to see if we need to use select() workaround */
    {
        char *workaround;
        workaround = SDL_getenv("SDL_DSP_NOSELECT");
        if (workaround) {
            frame_ticks = (float) (spec->samples * 1000) / spec->freq;
            next_frame = SDL_GetTicks() + frame_ticks;
        }
    }

    /* Get the parent process id (we're the parent of the audio thread) */
    parent = getpid();

    /* We're ready to rock and roll. :-) */
    return 0;
}

/* vi: set ts=4 sw=4 expandtab: */