source: trunk/third/esound/audio_solaris.c @ 17228

/*
 * Taken mainly from xmp, (C) 1996-98 Claudio Matsuoka and Hipolito Carraro Jr
 *
 * Completely untested.. so fix it
 */

#ifdef HAVE_SYS_AUDIOIO_H
#include <sys/audioio.h>
#elif defined(HAVE_SYS_AUDIO_IO_H)
#include <sys/audio.io.h>
#elif defined(HAVE_SUN_AUDIOIO_H)
#include <sun/audioio.h>
#endif
#include <stropts.h>
#include <errno.h>
#include <alloca.h>


/* if you want to confirm proper device setup, uncomment the following line */
/* #define ESDBG_DRIVER */

static char *default_device = "/dev/audio";

static char *my_ports = NULL;

static void
free_the_crap(void)
{
    if(my_ports)
        free(my_ports);
}

#define ARCH_esd_audio_devices
const char *esd_audio_devices()
{
    /*
     * I don't know what's the use for this crappy format. Are we supposed
     * to return everything the OS can possibly support or just the
     * devices we have available? If the later, shouldn't we make a difference
     * between play and record devices?
     *
     * Let's assume we want to return available devices. In that case we
     * first have to make a difference between device (something living in
     * the file system, which can be opened in order to talk to the audio
     * driver, which essentialy correspond to audio card) and audio ports
     * (which are things like speaker, lineout etc.). It seems esd uses
     * "device" for our "ports". But how does it make a difference between
     * different audio cards? They don't have to support the same ports.
     *
     * Anyway, the original code was just returning the static string.
     * We'll try to return the available ports. But we need to calculate
     * the stupid string, which means we have to free it at some point.
     * This thing is a library and it can be dlclosed() at any time. Oh, joy.
     * 
     * We could free the string at esd_audio_close() time, but it doesn't
     * make much sense, because that's not library unload and the
     * calculated string won't be different when another esd_audio_devices()
     * call comes. So we'll use atexit() to register the clean-up function.
     * On Solaris 8 that frees the string at library unload time.
     * On earlier releases it doesn't. So you'll have a small memory
     * leak. If somebody explains me what's the use for this function, I
     * might even want to fix it.  -- dave@arsdigita.com
     */

    char *device, *ctl;
    int fd, err;
    struct audio_info auinfo;
    unsigned int avail_ports;

    if (my_ports)
        return my_ports + 2;

    /* Use the control device, because opening the normal device might block */
    if (!(device = getenv("AUDIODEV")))
    {
        device = default_device;
    }
    ctl = alloca(strlen(device) + 4);
    strcpy(ctl, device);
    strcat(ctl, "ctl");

    /* Try to open non-blocking. We don't want to block on this shit. */

    do {
        fd = open(ctl, O_WRONLY | O_NONBLOCK);
    } while(fd == -1 && errno == EINTR);
    if (fd == -1)
    {
        if(errno == EBUSY)
            /* Just return some default crap. */
            goto hell;
        /* Otherwise we don't have available audio device, so no ports. */
        return "";
    }

    /* Get the available ports */
    do {
        err = ioctl(fd, AUDIO_GETINFO, &auinfo);
    } while (err == -1 && errno == EINTR);
    close(fd);
    if (err == -1)
        goto hell;
    avail_ports = auinfo.record.avail_ports | auinfo.play.avail_ports;
    if (!(my_ports = malloc(100))) /* XXX hardcoded string size */
        goto hell;
    atexit(free_the_crap);

    /* Now build the string. Everybody's returning only output ports, so... */

    my_ports[0] = 0;
    if (avail_ports & AUDIO_SPEAKER)
        strcat(my_ports, ", speaker");
    if (avail_ports & AUDIO_HEADPHONE)
        strcat(my_ports, ", headphone");
    if (avail_ports & AUDIO_LINE_OUT)
        strcat(my_ports, ", lineout");
#ifdef AUDIO_SPDIF_OUT
    if (avail_ports & AUDIO_SPDIF_OUT)
        strcat(my_ports, ", spdif");
#endif
#ifdef AUDIO_AUX1_OUT
    if (avail_ports & AUDIO_AUX1_OUT)
        strcat(my_ports, ", aux1");
#endif
#ifdef AUDIO_AUX2_OUT
    if (avail_ports & AUDIO_AUX2_OUT)
        strcat(my_ports, ", aux2");
#endif
    return my_ports + 2;

hell:
    return "speaker, lineout, headphone";
}


void dump_audio_info(audio_info_t *t, int play)
{
    if( play )
    {
        char *enc, aports[200], ports[200];

        switch( t->play.encoding )
        {
        case AUDIO_ENCODING_NONE:
            enc = "AUDIO_ENCODING_NONE";
            break;
        case AUDIO_ENCODING_ULAW:
            enc = "AUDIO_ENCODING_ULAW";
            break;
        case AUDIO_ENCODING_ALAW:
            enc = "AUDIO_ENCODING_ALAW";
            break;
        case AUDIO_ENCODING_LINEAR:
            enc = "AUDIO_ENCODING_LINEAR";
            break;
        }

        ports[0] = 0;
        if( t->play.port & AUDIO_SPEAKER )
            strcat(ports, " & AUDIO_SPEAKER");
        if( t->play.port & AUDIO_HEADPHONE )
            strcat(ports, " & AUDIO_HEADPHONE");
        if( t->play.port & AUDIO_LINE_OUT)
            strcat(ports, " & AUDIO_LINE_OUT");
#ifdef AUDIO_SPDIF_OUT
        if ( t->play.port & AUDIO_SPDIF_OUT )
            strcat(ports, " & AUDIO_SPDIF_OUT");
#endif
#ifdef AUDIO_AUX1_OUT
        if ( t->play.port & AUDIO_AUX1_OUT )
            strcat(ports, " & AUDIO_AUX1_OUT");
#endif
#ifdef AUDIO_AUX2_OUT
        if ( t->play.port & AUDIO_AUX2_OUT )
            strcat(ports, " & AUDIO_AUX2_OUT");
#endif

        aports[0] = 0;
        if( t->play.port & AUDIO_SPEAKER )
            strcat(aports, " & AUDIO_SPEAKER");
        if( t->play.port & AUDIO_HEADPHONE )
            strcat(aports, " & AUDIO_HEADPHONE");
        if( t->play.port & AUDIO_LINE_OUT)
            strcat(aports, " & AUDIO_LINE_OUT");
#ifdef AUDIO_SPDIF_OUT
        if ( t->play.port & AUDIO_SPDIF_OUT )
            strcat(aports, " & AUDIO_SPDIF_OUT");
#endif
#ifdef AUDIO_AUX1_OUT
        if ( t->play.port & AUDIO_AUX1_OUT )
            strcat(aports, " & AUDIO_AUX1_OUT");
#endif
#ifdef AUDIO_AUX2_OUT
        if ( t->play.port & AUDIO_AUX2_OUT )
            strcat(aports, " & AUDIO_AUX2_OUT");
#endif
               
        printf("Play Info:\n");
        printf(" Sample Rate: %d\n", t->play.sample_rate);
        printf(" Channels:    %d\n", t->play.channels);
        printf(" Bits/sample: %d\n", t->play.precision);
        printf(" Encoding:    %s\n", enc);
        printf(" Gain:        %d\n", t->play.gain);
        printf(" Port:        %s\n", ports + 3);
        printf(" availPorts:  %s\n", aports + 3);
        printf(" Mon Gain:    %d\n", t->monitor_gain);
        printf(" o/p Muted:   %d\n", t->output_muted);
        printf(" Balance:     %d\n", t->play.balance);
    }

    return;
}


/*
 * To anybody hacking at this:
 *
 *   return -1 means something failed, but the main library will try again
 *             with the different options
 *   return -2 means big trouble and the main library won't try again
 *
 * -2 is the appropriate value if we detected audio device we don't support
 * or if we can't even open the device or something like that.
 *
 * -1 is intended for conditions when the device doesn't support audio
 * parameters. In that case the main library can try again, but it needs
 * to call us again to open the device with another set of audio
 * parameters.
 *
 * Don't just put "return -1" at random places. If everything fails (which
 * is -2 situation), the user will get 10 or more error messages.
 * That sucks.
 *
 * -- dave@arsdigita.com
 */

#define ARCH_esd_audio_open
int esd_audio_open()
{
    int afd = -1, cafd = -1;
    audio_device_t adev;
    char *device, *devicectl;
    int err;

    /*
     * Recording code needs access to the control device, but the playing
     * code currently doesn't. Control device is the name of audio device
     * with appended "ctl". So we'll just alloca() memory for that, because
     * it can't be very large and it will allow us to just return and not
     * care about freeing the memory.  -- dave@arsdigita.com
     */

    if ((device = getenv("AUDIODEV")) == NULL)
        device = default_device;
    devicectl = alloca(strlen(device) + 4);
    strcpy(devicectl, device);
    strcat(devicectl, "ctl");
    
    if ((esd_audio_format & ESD_MASK_FUNC) == ESD_RECORD) {
        audio_info_t ainfo;
               
        AUDIO_INITINFO(&ainfo);
        do {
            cafd = open(devicectl, O_RDWR);
        } while (cafd == -1 && errno == EINTR);
        if( cafd == -1 )
        {
            fprintf(stderr,"esd: Could not open ctl device for recording\n");
            esd_audio_fd = -1;
            return -1;
        }
        do {
            err = ioctl(cafd, AUDIO_GETDEV, &adev);
        } while (err == -1 && errno == EINTR);
        if (err == -1) {
            fprintf(stderr, "esd: ioctl(\"%s\", AUDIO_GETDEV failed: %s\n",
                    devicectl, strerror(errno));
            close(cafd);
            esd_audio_fd = -1;
            return -1;
        }

        /*
         * Let's check the device name to see if we know how to handle
         * it. The problem with this is that the new audio devices will
         * become available over time and it will happen that this program
         * can use it, but the device name won't be known to it. This just
         * happened with the Blade machines which have SUNW,audiots.
         * In attempt to prevent this from happening again, we'll try
         * the following approach:
         *  - First check if it's one we know we can't handle. If so,
         *    print the error message and return.
         *  - Then check if it's one we know about. If so, everything's
         *    peachy keen.
         *  - If it's a device we don't know about, assume that we can
         *    use it and just print a warning.
         *
         *  -- dave@arsdigita.com
         */

        if ( !(strcmp(adev.name, "SUNW,am79c30")))
        {
             fprintf(stderr, "esd: Cannot handle device `%s'.\n",
                     adev.name);
             esd_audio_fd = -1;
             return -2;
        }
        if ( (strcmp(adev.name, "SUNW,CS4231") != 0) 
             && (strcmp(adev.name, "SUNW,audiots") != 0)
             && (strcmp(adev.name, "SUNW,sb16")  != 0)
             && (strcmp(adev.name, "SUNW,sbpro") != 0)
             && (strcmp(adev.name, "SUNW,dbri") != 0)  )
         {
            fprintf(stderr, "esd: Unknown device `%s', but will try anyway\n",
                    adev.name);
         }
        /* SUNW,CS4231 and most others */
        {
            int gain = 255; /* Range: 0 - 255 */
            int port = AUDIO_MICROPHONE;
            int bsize = 8180;
                       
            ainfo.record.sample_rate = esd_audio_rate;
            
            if ((esd_audio_format & ESD_MASK_CHAN) == ESD_STEREO)
                ainfo.record.channels = 2;
            else
                ainfo.record.channels = 1;
                       
            if ((esd_audio_format & ESD_MASK_BITS) == ESD_BITS16)
                ainfo.record.precision = 16;
            else
                ainfo.record.precision = 8;
                       
            ainfo.record.encoding = AUDIO_ENCODING_LINEAR;
            ainfo.record.gain = gain;
            ainfo.record.port = port;
            ainfo.record.balance = AUDIO_MID_BALANCE;
            ainfo.record.buffer_size = bsize;
            /* actually, it doesn't look like we need to set any
               settings here-- they always seem to be the default, no
               matter what else was spec.  
            fprintf( stderr, "record set up: "
                     "rate=%d, channels=%d, precision=%d, gain=%d, port=%x\n",
                     ainfo.record.sample_rate, ainfo.record.channels, 
                     ainfo.record.precision, ainfo.record.gain, ainfo.record.port); 
            */
        }
               
        do {
            afd = open(device, O_RDONLY);
        } while (afd == -1 && errno == EINTR);
        if (afd == -1) {
            fprintf(stderr, "esd: Opening %s device failed: %s\n",
                    device, strerror(errno));
            esd_audio_fd = -1;
            return -1;
        }
 
        do {
            err = ioctl(afd, AUDIO_SETINFO, &ainfo);
        } while (err == -1 && errno == EINTR);
        if (err == -1)
        {
            fprintf(stderr, "esd: ioctl(\"%s\", AUDIO_SETINFO) failed: %s\n",
                    device, strerror(errno));
            esd_audio_fd = -1;
            return -1;
        }
        esd_audio_fd = afd;
        return afd;
    }
    /* implied else: if ( (esd_audio_format & ESD_MASK_FUNC) != ESD_RECORD ) */
    
    do {
        afd = open(device, O_WRONLY);
    } while (afd == -1 && errno == EINTR);
    if (afd == -1) {
       if(errno != EACCES && errno != ENOENT)
           fprintf(stderr, "esd: Opening %s device failed: %s\n", device,
                   strerror(errno));
       /*
        * Don't spit errors in other cases; the user is likely to know
        * that he doesn't have audio device or that he doesn't have the
        * permission to use it (by default only the user logged at the
        * console can use audio device. All other users on the server can't.)
        * So every program which links to this library doesn't have to
        * tell him that.  -- dave@arsdigita.com
        */
       esd_audio_fd = -1;
       return -2;
    }

    do {
        err = ioctl(afd, AUDIO_GETDEV, &adev);
    } while (err == -1 && errno == EINTR);
    if (err == -1) {
        fprintf(stderr, "esd: ioctl(\"%s\", AUDIO_GETDEV) failed: %s\n",
                device, strerror(errno));
        close(afd);
        esd_audio_fd = -1;

        /*
         * Whatever this was, it's probably going to come again, so there's
         * no point in trying to reopen the device with another setting.
         * We didn't even come to that.  -- dave@arsdigita.com
         */

        return -2;
    }

    /*
     * Device check as above: assume that unknown devices are new hardware
     * and that we can handle them just fine.  -- dave@arsdigita.com
     */
    if ( !strcmp(adev.name, "SUNW,am79c30"))
    {
        fprintf(stderr, "esd: Cannot handle device `%s'.\n", adev.name);
        close(afd);
        esd_audio_fd = -1;
        return -1;
    }
    if ( (strcmp(adev.name, "SUNW,CS4231") != 0)
        && (strcmp(adev.name, "SUNW,audiots") != 0)
        && (strcmp(adev.name, "SUNW,sb16")  != 0)
        && (strcmp(adev.name, "SUNW,sbpro")  != 0)
        && (strcmp(adev.name, "SUNW,dbri") != 0)  ) 
    {
        fprintf(stderr, "esd: Unknown device `%s', but will try anyway.\n",
                adev.name);
    }

    {
        /*
         * Volume, balance and output device should be controlled by
         * an external program - that way the user can set his preferences
         * for all players  -- dave@arsdigita.com
         */
        /* int gain = 64;       /* Range: 0 - 255 */
        int port;
        int bsize = 8180;
        audio_info_t ainfo;
      
        if ( esd_audio_device == NULL )
            /* Don't change the output device unless specificaly requested */
            port = 0;
        else if ( !strcmp( esd_audio_device, "lineout" ) )
            port = AUDIO_LINE_OUT;
        else if ( !strcmp( esd_audio_device, "speaker" ) )
            port = AUDIO_SPEAKER;
        else if ( !strcmp( esd_audio_device, "headphone" ) )
            port = AUDIO_HEADPHONE;
        /*
         * The #ifdefs below are for the older OS releases. They won't have
         * these things defined, so the compilation would break without them.
         */
#ifdef AUDIO_SPDIF_OUT
        else if ( !strcmp( esd_audio_device, "spdif" ) )
            port = AUDIO_SPDIF_OUT;
#endif
#ifdef AUDIO_AUX1_OUT
        else if ( !strcmp( esd_audio_device, "aux1" ) )
            port = AUDIO_AUX1_OUT;
#endif
#ifdef AUDIO_AUX2_OUT
        else if ( !strcmp( esd_audio_device, "aux2" ) )
            port = AUDIO_AUX2_OUT;
#endif
        else {
            fprintf(stderr, "esd: Unknown output device `%s'.\n",
                    esd_audio_device);
            close(afd);
            esd_audio_fd = -1;
            return -1;
        }

        AUDIO_INITINFO(&ainfo);
      
        ainfo.play.sample_rate = esd_audio_rate;
      
        if ((esd_audio_format & ESD_MASK_CHAN) == ESD_STEREO)
            ainfo.play.channels = 2;
        else
            ainfo.play.channels = 1;
      
        if ((esd_audio_format & ESD_MASK_BITS) == ESD_BITS16)
            ainfo.play.precision = 16;
        else
            ainfo.play.precision = 8;
      
        ainfo.play.encoding = AUDIO_ENCODING_LINEAR;
        /* ainfo.play.gain = gain; */
        if(port)
            ainfo.play.port = port;
        /* ainfo.play.balance = AUDIO_MID_BALANCE; */
        ainfo.play.buffer_size = bsize;
        ainfo.output_muted = 0;
      
#ifdef ESDBG_DRIVER
        dump_audio_info(&ainfo,1);
#endif
      
        do {
            err = ioctl(afd, AUDIO_SETINFO, &ainfo);
        } while (err == -1 && errno == EINTR);
        if (err == -1)
        {
            fprintf(stderr, "esd: ioctl(\"%s\", AUDIO_SETINFO) failed: %s\n",
                    device, strerror(errno));
            close(afd);
            esd_audio_fd = -1;
            return -1;
        }
    }
    
    esd_audio_fd = afd;
    return afd;
}

#define ARCH_esd_audio_flush
void
esd_audio_flush()
{
    if (esd_audio_format & (ESD_PLAY | ESD_RECORD) == ESD_PLAY | ESD_RECORD)
        ioctl(esd_audio_fd, I_FLUSH, FLUSHRW);
    else
        if (esd_audio_format & ESD_PLAY == ESD_PLAY)
            ioctl(esd_audio_fd, I_FLUSH, FLUSHW);
        else
            if (esd_audio_format & ESD_RECORD == ESD_RECORD)
                ioctl(esd_audio_fd, I_FLUSH, FLUSHR);
}

#define ARCH_esd_audio_close
void
esd_audio_close()
{
    /* esd_audio_flush();  Should we flush here or not? */
    close(esd_audio_fd);
}