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);

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;

    Paud_DRIVER_NAME, "AIX Paudio",

    Audio_Available, Audio_CreateDevice

static void

Paud_WaitAudio (_THIS)

    if (frame_ticks) {

        ticks = ((Sint32) (next_frame - SDL_GetTicks ())) - FUDGE_TICKS;

        if (ticks > 0) {

            SDL_Delay (ticks);

        audio_buffer paud_bufinfo;

        FD_ZERO (&fdset);

        FD_SET (audio_fd, &fdset);

        if (ioctl (audio_fd, AUDIO_BUFFER, &paud_bufinfo) < 0) {

            fprintf (stderr, "Couldn't get audio buffer information\n");

            timeout.tv_sec = 10;

            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;

            fprintf (stderr,

                     "Waiting for write_buf_time=%ld,%ld\n",

                     timeout.tv_sec, timeout.tv_usec);

        }

        fprintf (stderr, "Waiting for audio to get ready\n");

        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,

            fprintf (stderr, "SDL: %s - %s\n", strerror (errno), message);

            fprintf (stderr, "Done disabling audio\n");

        fprintf (stderr, "Ready!\n");

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;

    }

    fprintf (stderr, "Wrote %d bytes of audio data\n", written);

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;

    Uint16 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;) {

        fprintf (stderr, "Trying format 0x%4.4x\n", test_format);

        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) {

        fprintf (stderr, "Couldn't find any hardware audio formats\n");

        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) {

        fprintf (stderr, "Can't change audio display settings\n");

    }

    /*

     * 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) {

        fprintf (stderr, "Can't start audio play\n");

        SDL_SetError ("Can't start audio play");

        return -1;