source: contrib/API/tools/tstmulti.c

#define INCL_DOS
#define INCL_DOSERRORS
#include <os2.h>
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <conio.h>
#include <math.h>
#include <string.h>

#include "uniaud.h"
#include "unidef.h"
#include "errno.h"

static void set_perc_vol(int card_id, char *name, int vol, int stereo)
{
    int ctl_id, min, max, new_vol;
    ctl_id = uniaud_get_id_by_name(card_id, name, 0);
    if (ctl_id > 0)
    {
        uniaud_mixer_get_min_max(card_id, ctl_id, &min, &max);
        new_vol = ((float)(max-min)/100.0f)*vol;
        uniaud_mixer_put_value(card_id,ctl_id,new_vol, 0);
        if (stereo) uniaud_mixer_put_value(card_id,ctl_id,new_vol, 1);
//        printf("set id %i to %i\n", ctl_id, new_vol);
    }
}


int main (int argc, char *argv[])
{
    int ver, err, ret;
    int bytesread, count;
    int card_id = 0;
    uniaud_pcm *pcm = NULL;
    char *Buffer;
    int readed, written, state, written1;
    int vol = 100, mute = 1;
    FILE *input_handle;
    int cards_num = 0; // number of cards

    snd_pcm_status_t status;

//    (unsigned int)*((unsigned int*)&tt1) = (unsigned int)*((unsigned int*)&tt);
//    printf("%02X%02X%02X%02X\n", tt1[0],tt1[1],tt1[2],tt1[3] );
//    return 0;

    printf("PCM test tool for UNIAUD. Version 0.01\n");
    printf("Copyright 2004 by Vlad Stelmahosky aka Vladest\n");

    ver = uniaud_get_version();

    switch (ver)
    {
    case -2:
        printf("Error: uniaud not detected\n");
        return 1;
        break;
    case -1:
        printf("Error: uniaud error\n");
        return 1;
        break;
    default:
        if (ver < 111)
        {
            printf("Error: unsupported version of uniaud\n");
            return 1;
        } else
            printf("Detected UNIAUD version %1d.%02d.%02d\n", ver/10000, (ver / 100) % 100, ver % 100 );
    }

    cards_num = uniaud_get_cards();
    if (!cards_num)
    {
        printf("No audio cards detected\n");
        return 1;
    }

    printf("Detected %i audio adapter(s)\n", cards_num);

    set_perc_vol(card_id, "PCM Playback Volume", vol, 1);
    set_perc_vol(card_id, "Wave Playback Volume", vol, 1);
    set_perc_vol(card_id, "Wave Surround Playback Volume", vol, 1);
    set_perc_vol(card_id, "Wave Center Playback Volume", vol, 0);
    set_perc_vol(card_id, "Wave LFE Playback Volume", vol, 0);
    set_perc_vol(card_id, "Playback Volume", vol, 1);
    set_perc_vol(card_id, "Surround Playback Volume", vol, 1);
    set_perc_vol(card_id, "Center Playback Volume", vol, 0);
    set_perc_vol(card_id, "LFE Playback Volume", vol, 0);
    uniaud_mixer_put_value_by_name(card_id,"PCM Playback Switch",mute, 1, 0);
    uniaud_mixer_put_value_by_name(card_id,"PCM Playback Switch",mute, 0, 0);
    uniaud_mixer_put_value_by_name(card_id,"Surround Playback Switch",mute, 1, 0);
    uniaud_mixer_put_value_by_name(card_id,"Surround Playback Switch",mute, 0, 0);
    uniaud_mixer_put_value_by_name(card_id,"LFE Playback Switch",mute, 0, 0);
    uniaud_mixer_put_value_by_name(card_id,"Center Playback Switch",mute, 0, 0);
    uniaud_mixer_put_value_by_name(card_id,"PCM Playback Switch",mute, 0, 0);

//    for (j=0; j < 2; j++)
    {
        printf("max chans: %i\n",uniaud_get_max_channels(card_id));
    readed = written = 0;
    err = uniaud_pcm_open(card_id, PCM_TYPE_WRITE, 0, 0, 48000, 6,
                          SNDRV_PCM_FORMAT_S16_LE, &pcm);
    if (pcm && err == 0)
    {
        printf("opened. pcm = %x\n", pcm);
        err = uniaud_pcm_prepare(pcm);
        printf("prepare err = %i\n", err);
        uniaud_pcm_status(pcm, &status);
        if (argc > 1)
            input_handle = fopen(argv[1], "rb");
        else
            input_handle = fopen("debug6ch.wav", "rb");
        if (!input_handle) printf("Error opening file\n");
        count = pcm->bufsize;
        //count = 528*2;

        printf("count = %i\n", count);
//        fseek(input_handle, 0L, SEEK_END);
//        fsize = ftell(input_handle);
        Buffer = malloc(count);
//        fseek(input_handle, 0L, SEEK_SET);
        //        memset(Buffer,0, count);

        while (1)
        {
            // read file and play into driver
//            if (written >= fsize) break;
        _again:
            bytesread = fread (Buffer, 1, count, input_handle);
            if (bytesread <= 0) break;

            written1 = 0;
            if (memcmp(Buffer, "RIFF",4) == 0)
            {
                /* found WAV */
                printf("Found WAV file\n");
                //written1  +=44;
                //bytesread -=44;
                /* TODO!! add parser */
                fseek(input_handle, 0x80, SEEK_SET);
                goto _again;
            }

//            if ((fsize - written) < count)
//                count = fsize - written;

            while (written1 < bytesread)
            {
                //printf("cp1\n");fflush(stdout);
                // write samples to driver
                err = uniaud_pcm_write(pcm, Buffer+written1, bytesread-written1);
                //printf("cp2\n");fflush(stdout);

                // wait while for next portion 1000 milliseconds
                ret = uniaud_pcm_wait(pcm, 100);
                if (ret < 0)
                {
                    //printf("error waiting pcm interrupt %i\n", ret);
                    DosSleep(1);
                }
                if (err > 0) // written something
                {
                    written+=err;
                    written1+=err;
                    printf("written all=%i. now = %i\r",written,err);
                }

                if (written1 >= bytesread) break;
                if (err == -EAGAIN) //
                {
                    //                printf("eagain\n");
                    continue;
                }
                if (err < 0) {
                    state = uniaud_pcm_state(pcm);
                    //printf("state after write: %i, err = %i wr: %i, br: %i\n",state, err, written, bytesread);
                    if ( (state != SND_PCM_STATE_PREPARED) &&
                         (state != SND_PCM_STATE_RUNNING) &&
                         (state != SND_PCM_STATE_DRAINING) ) {
                        printf("write:BAD STATE2, state = %d, going to try XRUN\n",state);
                        if ((ret = uniaud_pcm_prepare(pcm))<0) {
                            //                        printf("xrun: prepare error: %i", err);
                            return 0;
                        }
                    }
                }
            } // while written1
        }
        free(Buffer);
        fclose(input_handle);
        err = uniaud_pcm_close(pcm);
    }
    else
    {
        printf("open err: %i, pcm %x\n", err, pcm);
        if (err == 10005)
            err = uniaud_pcm_close(pcm);
        printf("close err: %i\n", err);
    }
    } //j
    return 0;
}