Show
Ignore:
Timestamp:
10/12/98 18:32:54 (16 years ago)
Author:
ucacoxh
Message:

- First pass at sgi audio interface (core dumps).
- Fixes for sgi compiler warnings.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/auddev_sgi.c

    r1990 r2011  
    11/* 
    2  * FILE:    sgi.c 
     2 * FILE:    auddev_sgi.c 
    33 * PROGRAM: RAT 
    4  * AUTHOR:  Isidor Kouvelas + Colin Perkins 
     4 * AUTHORS:  Isidor Kouvelas + Colin Perkins + Orion Hodson 
    55 * 
    66 * $Revision$ 
     
    4141 */ 
    4242 
     43#include <assert.h> 
     44 
    4345#include "config_unix.h" 
    4446#include "config_win32.h" 
    45 #include "audio.h" 
     47#include "auddev_sgi.h" 
     48#include "debug.h" 
    4649 
    4750#if defined(IRIX) 
    4851 
    49 #define READ_UNIT       80 
    5052#define QSIZE           16000           /* Two seconds for now... */ 
    5153#define AVG_SIZE        20000 
     
    5355#define BASEOFF         0x0a7f 
    5456 
    55 #define bat_to_device(x)        ((x) * 255 / MAX_AMP) 
    56 #define device_to_bat(x)        ((x) * MAX_AMP / 255) 
    57  
    58 static ALport   rp, wp;         /* Read and write ports */ 
     57#define RAT_TO_SGI_DEVICE(x)    ((x) * 255 / MAX_AMP) 
     58#define SGI_DEVICE_TO_RAT(x)    ((x) * MAX_AMP / 255) 
     59 
     60static int      audio_fd = -1; 
     61static ALport   rp = NULL, wp = NULL;   /* Read and write ports */ 
    5962static int      iport = AUDIO_MICROPHONE; 
    60  
     63static audio_format format; 
    6164/* 
    6265 * Try to open the audio device. 
     
    6467 */ 
    6568int 
    66 audio_open(audio_format format) 
    67 { 
    68         int             audio_fd = -1; 
     69sgi_audio_open(audio_desc_t ad, audio_format* fmt) 
     70{ 
    6971        ALconfig        c; 
    7072        long            cmd[8]; 
     73 
     74        if (audio_fd != -1) { 
     75                sgi_audio_close(ad); 
     76        } 
     77 
     78        memcpy(&format, fmt, sizeof(audio_format)); 
    7179 
    7280        if ((c = ALnewconfig()) == NULL) { 
     
    7583        } 
    7684 
    77         ALsetchannels(c, AL_MONO); 
     85        switch(fmt->num_channels) { 
     86        case 1: 
     87                ALsetchannels(c, AL_MONO); break; 
     88        case 2: 
     89                ALsetchannels(c, AL_STEREO); break; 
     90        default: 
     91                sgi_audio_close(ad); 
     92        } 
     93 
    7894        ALsetwidth(c, AL_SAMPLE_16); 
    7995        ALsetqueuesize(c, QSIZE); 
    8096        ALsetsampfmt(c, AL_SAMPFMT_TWOSCOMP); 
    81         if ((wp = ALopenport("RAT write", "w", c)) == NULL) 
     97 
     98        if ((wp = ALopenport("RAT write", "w", c)) == NULL) { 
    8299                fprintf(stderr, "ALopenport (write) error\n"); 
    83         if ((rp = ALopenport("RAT read", "r", c)) == NULL) 
     100                sgi_audio_close(ad); 
     101                return FALSE; 
     102        } 
     103 
     104        if ((rp = ALopenport("RAT read", "r", c)) == NULL) { 
    84105                fprintf(stderr, "ALopenport (read) error\n"); 
     106                sgi_audio_close(ad); 
     107                return FALSE; 
     108        } 
    85109 
    86110        cmd[0] = AL_OUTPUT_RATE; 
     
    92116        cmd[6] = AL_MONITOR_CTL; 
    93117        cmd[7] = AL_MONITOR_OFF; 
    94         if (ALsetparams(AL_DEFAULT_DEVICE, cmd, 8L) == -1) 
     118 
     119        if (ALsetparams(AL_DEFAULT_DEVICE, cmd, 8L) == -1) { 
    95120                fprintf(stderr, "audio_open/ALsetparams error\n"); 
     121                sgi_audio_close(ad); 
     122        } 
    96123 
    97124        /* Get the file descriptor to use in select */ 
    98125        audio_fd = ALgetfd(rp); 
    99126 
    100         ALsetfillpoint(rp, READ_UNIT); 
    101  
     127        if (ALsetfillpoint(rp, format.blocksize) < 0) { 
     128                debug_msg("ALsetfillpoint failed (%d samples)\n", format.blocksize); 
     129        } 
     130         
    102131        /* We probably should free the config here... */ 
    103  
    104         return audio_fd; 
     132         
     133        return TRUE; 
    105134} 
    106135 
    107136/* Close the audio device */ 
    108137void 
    109 audio_close(int audio_fd) 
    110 { 
     138sgi_audio_close(audio_desc_t ad) 
     139{ 
     140        UNUSED(ad); 
    111141        ALcloseport(rp); 
    112142        ALcloseport(wp); 
     143        audio_fd = -1; 
    113144} 
    114145 
    115146/* Flush input buffer */ 
    116147void 
    117 audio_drain(int audio_fd) 
     148sgi_audio_drain(audio_desc_t ad) 
    118149{ 
    119150        sample  buf[QSIZE]; 
    120         while(audio_read(audio_fd, buf, QSIZE) == QSIZE); 
     151 
     152        UNUSED(ad); assert(audio_fd > 0); 
     153 
     154        while(sgi_audio_read(audio_fd, buf, QSIZE) == QSIZE); 
    121155} 
    122156 
     
    124158 
    125159void 
    126 audio_set_gain(int audio_fd, int gain) 
     160sgi_audio_set_gain(audio_desc_t ad, int gain) 
    127161{ 
    128162        long    cmd[4]; 
    129163 
    130         if (audio_fd == 0) 
    131                 return; 
     164        UNUSED(ad); assert(audio_fd > 0); 
    132165 
    133166        cmd[0] = AL_LEFT_INPUT_ATTEN; 
    134         cmd[1] = 255 - bat_to_device(gain); 
     167        cmd[1] = 255 - RAT_TO_SGI_DEVICE(gain); 
    135168        cmd[2] = AL_RIGHT_INPUT_ATTEN; 
    136169        cmd[3] = cmd[1]; 
     
    139172 
    140173int 
    141 audio_get_gain(int audio_fd) 
     174sgi_audio_get_gain(audio_desc_t ad) 
    142175{ 
    143176        long    cmd[2]; 
    144177 
    145         if (audio_fd == 0) 
    146                 return 50; 
     178        UNUSED(ad); assert(audio_fd > 0); 
    147179 
    148180        cmd[0] = AL_LEFT_INPUT_ATTEN; 
    149181        ALgetparams(AL_DEFAULT_DEVICE, cmd, 2L); 
    150         return (255 - device_to_bat(cmd[1])); 
    151 } 
    152  
    153 void 
    154 audio_set_volume(int audio_fd, int vol) 
     182        return (255 - SGI_DEVICE_TO_RAT(cmd[1])); 
     183} 
     184 
     185void 
     186sgi_audio_set_volume(audio_desc_t ad, int vol) 
    155187{ 
    156188        long    cmd[4]; 
    157189 
    158         if (audio_fd == 0) 
    159                 return; 
     190        UNUSED(ad); assert(audio_fd > 0); 
    160191 
    161192        cmd[0] = AL_LEFT_SPEAKER_GAIN; 
    162         cmd[1] = bat_to_device(vol); 
     193        cmd[1] = RAT_TO_SGI_DEVICE(vol); 
    163194        cmd[2] = AL_RIGHT_SPEAKER_GAIN; 
    164195        cmd[3] = cmd[1]; 
     
    167198 
    168199int 
    169 audio_get_volume(int audio_fd) 
     200sgi_audio_get_volume(audio_desc_t ad) 
    170201{ 
    171202        long    cmd[2]; 
    172203 
    173         if (audio_fd == 0) 
    174                 return 50; 
     204        UNUSED(ad); assert(audio_fd > 0); 
    175205 
    176206        cmd[0] = AL_LEFT_SPEAKER_GAIN; 
    177207        ALgetparams(AL_DEFAULT_DEVICE, cmd, 2L); 
    178         return (device_to_bat(cmd[1])); 
     208        return (SGI_DEVICE_TO_RAT(cmd[1])); 
    179209} 
    180210 
     
    182212 
    183213int 
    184 audio_read(int audio_fd, sample *buf, int samples) 
     214sgi_audio_read(audio_desc_t ad, sample *buf, int samples) 
    185215{ 
    186216        long            len; 
     217 
     218        UNUSED(ad); assert(audio_fd > 0); 
    187219         
    188220        if (non_block) { 
    189221                if ((len = ALgetfilled(rp)) <= 0) 
    190222                        return (0); 
    191                 len -= len % READ_UNIT; 
     223                len -= len % format.blocksize; 
    192224                if (len <= 0) 
    193                         len = READ_UNIT; 
     225                        len = format.blocksize; 
    194226                if (len > samples) 
    195227                        len = samples; 
     
    208240 
    209241int 
    210 audio_write(int audio_fd, sample *buf, int samples) 
    211 { 
     242sgi_audio_write(audio_desc_t ad, sample *buf, int samples) 
     243{ 
     244        UNUSED(ad); assert(audio_fd > 0); 
     245 
    212246        if (samples > QSIZE) { 
    213247                fprintf(stderr, "audio_write: too big!\n"); 
     
    222256/* Set ops on audio device to be non-blocking */ 
    223257void 
    224 audio_non_block(int audio_fd) 
    225 { 
     258sgi_audio_non_block(audio_desc_t ad) 
     259{ 
     260        UNUSED(ad); assert(audio_fd > 0); 
     261 
    226262        non_block = 1; 
    227263} 
     
    229265/* Set ops on audio device to block */ 
    230266void 
    231 audio_block(int audio_fd) 
    232 { 
     267sgi_audio_block(audio_desc_t ad) 
     268{ 
     269        UNUSED(ad); assert(audio_fd > 0); 
     270 
    233271        non_block = 0; 
    234272} 
    235273 
    236274void 
    237 audio_set_oport(int audio_fd, int port) 
    238 { 
    239         /* Not possible? */ 
    240 } 
    241  
    242 int 
    243 audio_get_oport(int audio_fd) 
    244 { 
     275sgi_audio_set_oport(audio_desc_t ad, int port) 
     276{ 
     277        UNUSED(ad); assert(audio_fd > 0); 
     278} 
     279 
     280int 
     281sgi_audio_get_oport(audio_desc_t ad) 
     282{ 
     283        UNUSED(ad); assert(audio_fd > 0); 
     284 
    245285        return (AUDIO_SPEAKER); 
    246286} 
    247287 
    248288int 
    249 audio_next_oport(int audio_fd) 
    250 { 
     289sgi_audio_next_oport(audio_desc_t ad) 
     290{ 
     291        UNUSED(ad); assert(audio_fd > 0); 
     292 
    251293        return (AUDIO_SPEAKER); 
    252294} 
    253295 
    254296void 
    255 audio_set_iport(int audio_fd, int port) 
     297sgi_audio_set_iport(audio_desc_t ad, int port) 
    256298{ 
    257299        long pvbuf[2]; 
    258300 
    259         if (audio_fd > 0) { 
    260                 switch(port) { 
    261                 case AUDIO_MICROPHONE : pvbuf[0] = AL_INPUT_SOURCE; 
    262                                         pvbuf[1] = AL_INPUT_MIC; 
    263                                         ALsetparams(AL_DEFAULT_DEVICE, pvbuf, 2); 
    264                                         iport = AUDIO_MICROPHONE; 
    265                                         break; 
    266                 case AUDIO_LINE_IN    : pvbuf[0] = AL_INPUT_SOURCE; 
    267                                         pvbuf[1] = AL_INPUT_LINE; 
    268                                         ALsetparams(AL_DEFAULT_DEVICE, pvbuf, 2); 
    269                                         iport = AUDIO_LINE_IN; 
    270                                         break; 
    271                 default               : printf("Illegal input port!\n"); 
    272                                         abort(); 
    273                 } 
    274         } 
    275 } 
    276  
    277 int 
    278 audio_get_iport(int audio_fd) 
    279 { 
     301        UNUSED(ad); assert(audio_fd > 0); 
     302 
     303        switch(port) { 
     304        case AUDIO_MICROPHONE:  
     305                pvbuf[0] = AL_INPUT_SOURCE; 
     306                pvbuf[1] = AL_INPUT_MIC; 
     307                ALsetparams(AL_DEFAULT_DEVICE, pvbuf, 2); 
     308                iport = AUDIO_MICROPHONE; 
     309                break; 
     310        case AUDIO_LINE_IN:  
     311                pvbuf[0] = AL_INPUT_SOURCE; 
     312                pvbuf[1] = AL_INPUT_LINE; 
     313                ALsetparams(AL_DEFAULT_DEVICE, pvbuf, 2); 
     314                iport = AUDIO_LINE_IN; 
     315                break; 
     316        default: 
     317                printf("Illegal input port!\n"); 
     318                abort(); 
     319        } 
     320} 
     321 
     322int 
     323sgi_audio_get_iport(audio_desc_t ad) 
     324{ 
     325        UNUSED(ad); assert(audio_fd > 0); 
     326 
    280327        return iport; 
    281328} 
    282329 
    283330int 
    284 audio_next_iport(int audio_fd) 
    285 { 
    286   switch (iport) { 
    287     case AUDIO_MICROPHONE : audio_set_iport(audio_fd, AUDIO_LINE_IN); 
    288                             break; 
    289     case AUDIO_LINE_IN    : audio_set_iport(audio_fd, AUDIO_MICROPHONE); 
    290                             break; 
    291     default               : printf("Unknown audio source!\n"); 
    292   } 
    293   return iport; 
    294 } 
    295  
    296 void 
    297 audio_switch_out(int audio_fd, struct s_cushion_struct *ap) 
    298 { 
    299         /* Full duplex device: do nothing! */ 
    300 } 
    301     
    302 void 
    303 audio_switch_in(int audio_fd) 
    304 { 
    305         /* Full duplex device: do nothing! */ 
    306 } 
    307  
    308 int 
    309 audio_duplex(int audio_fd) 
    310 { 
    311   return 1; 
    312 } 
    313  
    314 int 
    315 audio_get_channels(void) 
    316 { 
     331sgi_audio_next_iport(audio_desc_t ad) 
     332{ 
     333        UNUSED(ad); assert(audio_fd > 0); 
     334 
     335        switch (iport) { 
     336        case AUDIO_MICROPHONE: 
     337                sgi_audio_set_iport(ad, AUDIO_LINE_IN); 
     338                break; 
     339        case AUDIO_LINE_IN: 
     340                sgi_audio_set_iport(ad, AUDIO_MICROPHONE); 
     341                break; 
     342        default: 
     343                printf("Unknown audio source!\n"); 
     344        } 
     345        return iport; 
     346} 
     347 
     348void sgi_audio_loopback(audio_desc_t ad, int gain) 
     349{ 
     350        long pvbuf[4]; 
     351        int  pvcnt; 
     352 
     353        UNUSED(ad); assert(audio_fd > 0); 
     354 
     355        pvcnt = 2; 
     356        pvbuf[0] = AL_MONITOR_CTL; 
     357        pvbuf[1] = AL_MONITOR_OFF; 
     358 
     359        if (gain) { 
     360                pvcnt = 6; 
     361                pvbuf[1] = AL_MONITOR_ON; 
     362                pvbuf[2] = AL_LEFT_MONITOR_ATTEN; 
     363                pvbuf[3] = 255 - RAT_TO_SGI_DEVICE(gain); 
     364                pvbuf[4] = AL_RIGHT_MONITOR_ATTEN; 
     365                pvbuf[5] = pvbuf[3]; 
     366        } 
     367         
     368        if (ALsetparams(AL_DEFAULT_DEVICE, pvbuf, pvcnt) != 0) { 
     369                debug_msg("loopback failed\n"); 
     370        } 
     371} 
     372 
     373int 
     374sgi_audio_duplex(audio_desc_t ad) 
     375{ 
     376        UNUSED(ad); assert(audio_fd > 0); 
     377        return 1; 
     378} 
     379 
     380int 
     381sgi_audio_get_channels(audio_desc_t ad) 
     382{ 
     383        UNUSED(ad); assert(audio_fd > 0); 
    317384        return ALgetchannels(ALgetconfig(rp)); 
    318385} 
    319386 
     387int 
     388sgi_audio_get_blocksize(audio_desc_t ad) 
     389{ 
     390        UNUSED(ad); assert(audio_fd > 0); 
     391        return format.blocksize; /* Could use ALgetfillpoint */ 
     392} 
     393 
     394int 
     395sgi_audio_get_freq(audio_desc_t ad) 
     396{ 
     397        long pvbuf[2]; 
     398        UNUSED(ad); assert(audio_fd > 0); 
     399         
     400        pvbuf[0] = AL_INPUT_RATE; 
     401 
     402        if (ALqueryparams(AL_DEFAULT_DEVICE, pvbuf, 2) == -1) { 
     403                debug_msg("Could not get freq"); 
     404        } 
     405        return (int)pvbuf[1]; 
     406} 
     407 
     408int   
     409sgi_audio_is_ready(audio_desc_t ad) 
     410{ 
     411        UNUSED(ad); assert(audio_fd > 0); 
     412         
     413        if (ALgetfilled(rp) >= format.blocksize) { 
     414                return TRUE; 
     415        } else { 
     416                return FALSE; 
     417        } 
     418} 
     419 
     420void  
     421sgi_audio_wait_for(audio_desc_t ad, int delay_ms) 
     422{ 
     423        struct timeval tv; 
     424        fd_set rfds; 
     425        UNUSED(ad); assert(audio_fd > 0); 
     426 
     427        tv.tv_sec  = 0; 
     428        tv.tv_usec = delay_ms * 1000; 
     429 
     430        FD_ZERO(&rfds); 
     431        FD_SET(audio_fd, &rfds); 
     432         
     433        select(audio_fd + 1, &rfds, NULL, NULL, &tv); 
     434} 
     435 
    320436#endif 
    321437