source: downloads/openal-0.0.8/src/backends/alc_backend_bsd.c @ 17

/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
 * vi:set ts=8:
 *
 * bsd_dsp.c
 *
 * functions related to the aquisition and management of /dev/dsp under
 * bsd.
 *
 */
#include "al_siteconfig.h"

#include <AL/al.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/soundcard.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#include "backends/alc_backend.h"

/* is this right? */
#define _AL_DEF_BUFSIZ _ALC_DEF_BUFSIZ

#include "al_main.h"
#include "al_debug.h"
#include "alc/alc_context.h"

#ifdef WORDS_BIGENDIAN
#define AFMT_S16 AFMT_S16_BE
#else
#define AFMT_S16 AFMT_S16_LE
#endif /* WORDS_BIGENDIAN */

static int grab_mixerfd(void);
static int alcChannel_to_dsp_channel(ALuint alcc);

/* /dev/dsp variables */
static fd_set dsp_fd_set;
static int dsp_fd      = -1; /* /dev/dsp file descriptor */
static int mixer_fd    = -1; /* /dev/mixer file descriptor */

/* convert the format channel from /dev/dsp to openal format */
static int BSD2ALFMT(int fmt, int channels) {
        switch(fmt) {
                case AFMT_U8:
                        switch(channels)
                        {
                                case 1: return AL_FORMAT_MONO8;
                                case 2: return AL_FORMAT_STEREO8;
                                default: return -1;
                        }
                        break;
                case AFMT_S16:
                        switch(channels)
                        {
                                case 1: return AL_FORMAT_MONO16;
                                case 2: return AL_FORMAT_STEREO16;
                                default: return -1;
                        }
                        break;
                default:
#ifdef DEBUG_MAXIMUS
                        fprintf(stderr, "unsupported dsp format\n");
#endif
                        return -1;
                        break;
        }

        return -1;
}

/* convert the format channel from openal to /dev/dsp format */
static int AL2BSDFMT(int fmt)
{
        switch(fmt)
        {
                case AL_FORMAT_MONO16:
                case AL_FORMAT_STEREO16:
                        return AFMT_S16;
                        break;
                case AL_FORMAT_MONO8:
                case AL_FORMAT_STEREO8:
                        return AFMT_U8;
                        break;
                default:
#ifdef DEBUG_MAXIMUS
                  fprintf(stderr, "unknown format 0x%x\n", fmt);
#endif
                  break;
        }

        return -1;
}

/*
 *
 *  Format of divisor is bit field where:
 *
 *
 *         MSHW          LSHW
 *  [ some big value |     x  ]
 *
 *  where x is translated into 2^x, and used as the
 *  dma buffer size.
 *
 */
static void *grab_write_native(void) {
        const char *dsppath = "/dev/dsp";
        int divisor = _alSpot(_AL_DEF_BUFSIZ) | (2<<16);

        dsp_fd = open(dsppath, O_WRONLY | O_NONBLOCK);

        if(dsp_fd < 0) {
                perror("open /dev/dsp");
                return NULL;
        }

        if(fcntl(dsp_fd, F_SETFL, ~O_NONBLOCK) == -1) {
                perror("fcntl");
        }

        if(ioctl(dsp_fd, SNDCTL_DSP_SETFRAGMENT, &divisor) < 0) {
                perror("ioctl SETFRAGMENT");
        }

        FD_ZERO(&dsp_fd_set);
        FD_SET(dsp_fd, &dsp_fd_set);

        /* now get mixer_fd */
        mixer_fd = grab_mixerfd();

#ifdef DEBUG
        fprintf(stderr, "Got /dev/dsp\n");
#endif
        return &dsp_fd;
}

int grab_mixerfd(void) {
        mixer_fd = open("/dev/mixer", O_WRONLY | O_NONBLOCK);

        if(mixer_fd > 0) {
                if(fcntl(mixer_fd, F_SETFL, ~O_NONBLOCK) == -1) {
                        perror("fcntl");
                }

                return mixer_fd;
        } else {
                perror("open /dev/mixer");
        }

        return -1;
}

void native_blitbuffer(void *handle, void *dataptr, int bytes_to_write) {
        struct timeval tv = { 1, 0 }; /* wait 1 sec max */
        int iterator = 0;
        int err;
        int fd;

        if(handle == NULL) {
                return;
        }

        fd = *(int *) handle;

        for(iterator = bytes_to_write; iterator > 0; ) {
                if(select(fd + 1, NULL, &dsp_fd_set, NULL, &tv) == 0) {
                        /* timeout occured, don't try and write */
#ifdef DEBUG_MAXIMUS
                        fprintf(stderr, "native_blitbuffer: timeout occured\n");
#endif
                        return;
                }

                FD_ZERO(&dsp_fd_set);
                FD_SET(fd, &dsp_fd_set);

                assert(iterator > 0);
                assert(iterator <= bytes_to_write);

                err = write(fd,
                            (char *) dataptr + bytes_to_write - iterator,
                            iterator);
                if(err < 0) {
#ifdef DEBUG_MAXIMUS
                        perror("write");
#endif
                        return;
                }

                iterator -= err;
        };

        return;
}

void release_native(void *handle) {
        int handle_fd;

        if(handle == NULL) {
                return;
        }

        handle_fd = *(int *) handle;

        if(ioctl(handle_fd, SNDCTL_DSP_RESET) < 0) {
#ifdef DEBUG_MAXIMUS
                fprintf(stderr, "Couldn't reset dsp\n");
#endif
        }

        ioctl(handle_fd, SNDCTL_DSP_SYNC, NULL);
        if((close(handle_fd) < 0) || (close(mixer_fd) < 0)) {
                return;
        }

        *(int *) handle = -1;
        mixer_fd        = -1;

        return;
}

ALfloat get_nativechannel(UNUSED(void *handle), ALuint channel) {
        int retval = 0;

        channel = alcChannel_to_dsp_channel(channel);

        if(ioctl(mixer_fd, MIXER_READ(channel), &retval) < 0) {
                return -1;
        }

        return (retval >> 8) / 100.0;
}


/*
 * Okay:
 *
 * Set audio channel expects an integer, in the range of
 * 0 - 100.  But wait!  It expects the integer to be
 * partitioned into a 16bit empty, L/R channel pair (high bits left,
 * low bits right), each 8 bit pair in the range 0 - 100.
 *
 * Kludgey, and obviously not the right way to do this
 */
int set_nativechannel(UNUSED(void *handle), ALuint channel, ALfloat volume) {
        int unnormalizedvolume;

        unnormalizedvolume = volume * 100;
        unnormalizedvolume <<= 8;
        unnormalizedvolume += (volume * 100);

        channel = alcChannel_to_dsp_channel(channel);

        if(ioctl(mixer_fd, MIXER_WRITE(channel), &unnormalizedvolume) < 0) {
                return -1;
        }

        return 0;
}

/* convert the mixer channel from ALC to /dev/mixer format */
static int alcChannel_to_dsp_channel(ALuint alcc) {
        switch(alcc) {
                case ALC_CHAN_MAIN_LOKI: return SOUND_MIXER_VOLUME;
                case ALC_CHAN_CD_LOKI:   return SOUND_MIXER_CD;
                case ALC_CHAN_PCM_LOKI:  return SOUND_MIXER_PCM;
                default: return -1;
        }

        return -1;
}

void pause_nativedevice(void *handle) {
        int fd;

        if(handle == NULL) {
                return;
        }

        fd = *(int *) handle;

        if(ioctl(fd, SNDCTL_DSP_POST, 0) == -1) {
                perror("ioctl");
        }

        return;
}

void resume_nativedevice(void *handle) {
        int fd;

        if(handle == NULL) {
                return;
        }

        fd = *(int *) handle;

        if(ioctl(fd, SNDCTL_DSP_POST, 0) == -1) {
                perror("ioctl");
        }

        return;
}

ALsizei capture_nativedevice(UNUSED(void *handle),
                          UNUSED(void *capture_buffer),
                          UNUSED(int bufsiz)) {
        /* unimplemented */
        return 0;
}

static ALboolean set_write_native(UNUSED(void *handle),
                                  UNUSED(unsigned int *bufsiz),
                                  ALenum *fmt,
                                  unsigned int *speed) {
        ALuint channels = _alGetChannelsFromFormat(*fmt);

        if(dsp_fd < 0) {
                return AL_FALSE;
        }

        *fmt  = AL2BSDFMT(*fmt);

        /* reset card defaults */
        if(ioctl(dsp_fd, SNDCTL_DSP_RESET, NULL) < 0) {
#ifdef DEBUG_MAXIMUS
                perror("set_devsp reset ioctl");
#endif
                return AL_FALSE;
        }

        if(ioctl(dsp_fd, SNDCTL_DSP_SPEED, speed) < 0) {
#ifdef DEBUG_MAXIMUS
                fprintf(stderr, "speed %d\n", *speed);
                perror("set_devsp speed ioctl");
#endif
                return AL_FALSE;
        }

        if(ioctl(dsp_fd, SNDCTL_DSP_SETFMT, fmt) < 0) {
#ifdef DEBUG_MAXIMUS
                fprintf(stderr, "fmt %d\n", *fmt);
                perror("set_devsp format ioctl");
#endif
                return AL_FALSE;
        }

        if(ioctl(dsp_fd, SOUND_PCM_WRITE_CHANNELS, &channels)) {
#ifdef DEBUG_MAXIMUS
                fprintf(stderr, "channels %d\n", channels);
                perror("set_devsp channels ioctl");
#endif
                return AL_FALSE;
        }


        *fmt = BSD2ALFMT(*fmt, channels);

        return AL_TRUE;
}

static ALboolean set_read_native(UNUSED(void *handle),
                                 UNUSED(unsigned int *bufsiz),
                                 UNUSED(ALenum *fmt),
                                 UNUSED(unsigned int *speed)) {
        return AL_FALSE;
}

ALboolean
alcBackendSetAttributesNative_(ALC_OpenMode mode, void *handle, ALuint *bufsiz, ALenum *fmt, ALuint *speed)
{
        return mode == ALC_OPEN_INPUT_ ?
                set_read_native(handle, bufsiz, fmt, speed) :
                set_write_native(handle, bufsiz, fmt, speed);
}

static void *grab_read_native(void)
{
        fprintf(stderr,"grab_read_native Not implemented! (%s:%d)\n",__FILE__,__LINE__);
        return;
}

void *
alcBackendOpenNative_( ALC_OpenMode mode )
{
        return mode == ALC_OPEN_INPUT_ ? grab_read_native() : grab_write_native();
}