Changeset 2107

Show
Ignore:
Timestamp:
11/11/98 12:45:41 (15 years ago)
Author:
ucacoxh
Message:

- First stab at oss audio interface update. No Linux machine to test
it on for the moment :-(

Location:
rat/trunk
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/auddev_oss.c

    r2103 r2107  
    5252#include "memory.h" 
    5353#include "audio_types.h" 
     54#include "audio_fmt.h" 
    5455#include "auddev_oss.h" 
    5556 
    56 int     can_read  = FALSE; 
    57 int     can_write = FALSE; 
    5857int     iport     = AUDIO_MICROPHONE; 
    59 int     is_duplex = FALSE; 
    60 int     done_test = FALSE; 
    6158int     bytes_per_block; 
    6259 
     
    6966 
    7067static char the_dev[] = "/dev/audioX"; 
    71 static int audio_fd = -1; 
     68static int audio_fd[OSS_MAX_DEVICES]; 
    7269 
    7370audio_format format; 
     
    7673#define device_to_bat(x)  ((x) * MAX_AMP / 100) 
    7774 
    78 static int  
    79 oss_audio_open_rw(audio_desc_t ad, char rw) 
    80 { 
    81         int  mode     = AFMT_S16_LE;                    /* 16bit linear, little-endian */ 
    82         int  stereo   = format.channels - 1;    /* 0=mono, 1=stereo            */ 
    83         int  speed    = format.sample_rate; 
     75static int 
     76deve2oss(deve_e encoding) 
     77{ 
     78        switch(encoding) { 
     79        case DEV_PCMU: return AFMT_MU_LAW; 
     80        case DEV_S8:   return AFMT_S8; 
     81        case DEV_S16:  return AFMT_S16_LE; 
     82        } 
     83        abort(); 
     84} 
     85 
     86 
     87/* Try to open the audio device.              */ 
     88/* Return TRUE if successful FALSE otherwise. */ 
     89int 
     90oss_audio_open(audio_desc_t ad, audio_format *ifmt, audio_format *ofmt) 
     91{ 
     92        int  mode, stereo, speed; 
    8493        int  volume   = (100<<8)|100; 
    8594        int  frag     = 0x7fff0000;                     /* unlimited number of fragments */ 
     
    8796        char buffer[128];                               /* sigh. */ 
    8897 
    89         /* Calculate the size of the fragments we want... 20ms worth of audio data... */ 
    90         bytes_per_block = DEVICE_BUF_UNIT * (format.sample_rate / 8000) * (format.bits_per_sample / 8); 
    91         /* Round to the nearest legal frag size (next power of two lower...) */ 
    92         frag |= (int) (log(bytes_per_block)/log(2)); 
    93         debug_msg("frag=%x bytes_per_block=%d\n", frag, bytes_per_block); 
    94  
    95         switch (rw) { 
    96         case O_RDONLY:  
    97                 can_read  = TRUE; 
    98                 can_write = FALSE; 
    99                 break; 
    100         case O_WRONLY:  
    101                 can_read  = FALSE; 
    102                 can_write = TRUE; 
    103                 break; 
    104         case O_RDWR  :  
    105                 can_read  = TRUE; 
    106                 can_write = TRUE; 
    107                 break; 
    108         default :  
    109                 printf("Unknown r/w mode!\n"); 
    110                 abort(); 
    111         } 
    112  
    113         audio_fd = open(the_dev, rw); 
    114         if (audio_fd > 0) { 
    115                 /* Note: The order in which the device is set up is important! Don't */ 
    116                 /*       reorder this code unless you really know what you're doing! */ 
    117                 if ((rw == O_RDWR) && ioctl(audio_fd, SNDCTL_DSP_SETDUPLEX, 0) == -1) { 
    118                         printf("ERROR: Cannot enable full-duplex mode!\n"); 
    119                         abort(); 
    120                 } 
    121                 if ((ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag) == -1)) { 
    122                         printf("ERROR: Cannot set the fragement size\n"); 
    123                         abort(); 
    124                 } 
    125                 if ((ioctl(audio_fd, SNDCTL_DSP_SETFMT, &mode) == -1) || (mode != AFMT_S16_LE)) {  
    126                         printf("ERROR: Audio device doesn't support 16bit linear format!\n"); 
    127                         abort(); 
    128                 } 
    129                 if ((ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo) == -1) || (stereo != (format.channels - 1))) { 
    130                         printf("ERROR: Audio device doesn't support %d channels!\n", format.channels); 
    131                         abort(); 
    132                 } 
    133                 if ((ioctl(audio_fd, SNDCTL_DSP_SPEED, &speed) == -1) || (speed != format.sample_rate)) { 
    134                         printf("ERROR: Audio device doesn't support %d sampling rate!\n", format.sample_rate); 
    135                         abort(); 
    136                 } 
    137                 /* Set global gain/volume to maximum values. This may fail on */ 
    138                 /* some cards, but shouldn't cause any harm when it does..... */  
    139                 ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_VOLUME), &volume); 
    140                 ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_RECLEV), &volume); 
    141                 /* Select microphone input. We can't select output source...  */ 
    142                 oss_audio_set_iport(audio_fd, iport); 
    143                 /* Turn off loopback from input to output... This only works  */ 
    144                 /* on a few cards, but shouldn't cause problems on the others */ 
    145                 ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_IMIX), &reclb); 
    146                 /* Device driver bug: we must read some data before the ioctl */ 
    147                 /* to tell us how much data is waiting works....              */ 
    148                 read(audio_fd, buffer, 128);     
    149                 /* Okay, now we're done...                                    */ 
    150                 UNUSED(ad); 
    151                 return audio_fd; 
    152         } else { 
    153                 close(audio_fd); 
    154                 can_read  = FALSE; 
    155                 can_write = FALSE; 
    156                 return -1; 
    157         } 
    158 } 
    159  
    160 /* Try to open the audio device.              */ 
    161 /* Return TRUE if successful FALSE otherwise. */ 
    162 int 
    163 oss_audio_open(audio_desc_t ad, audio_format *fmt) 
    164 { 
    165         int mode; 
    166  
    167         UNUSED(ad);  
    168  
    169         memcpy(&format, fmt, sizeof(audio_format)); 
    170  
    17198        if (ad <0 || ad>OSS_MAX_DEVICES) { 
    17299                debug_msg("Invalid audio descriptor (%d)", ad); 
     
    176103        sprintf(the_dev, "/dev/audio%d", ad); 
    177104 
    178         if (oss_audio_duplex(-1)) { 
    179                 mode = O_RDWR; 
    180         } else { 
    181                 perror("Half duplex cards not supported\n"); 
    182                 exit(-1); 
    183                 mode = O_WRONLY; 
    184         } 
    185         audio_fd = oss_audio_open_rw(ad, mode); 
    186         return (audio_fd > 0) ? TRUE : FALSE; 
     105        audio_fd[ad] = open(the_dev, O_RDWR | O_NDELAY); 
     106        if (audio_fd[ad] > 0) { 
     107                /* Note: The order in which the device is set up is important! Don't */ 
     108                /*       reorder this code unless you really know what you're doing! */ 
     109                if (ioctl(audio_fd[ad], SNDCTL_DSP_SETDUPLEX, 0) == -1) { 
     110                        fprintf(stderr, "ERROR: Cannot enable full-duplex mode!\n"); 
     111                        return FALSE; 
     112                } 
     113 
     114                mode = deve2oss(ifmt->encoding); 
     115                 
     116                if ((ioctl(audio_fd[ad], SNDCTL_DSP_SETFMT, &mode) == -1)) { 
     117                        if (ifmt->encoding == DEV_S16) { 
     118                                audio_format_change_encoding(ifmt, DEV_PCMU); 
     119                                audio_format_change_encoding(ofmt, DEV_PCMU); 
     120                                if ((ioctl(audio_fd[ad], SNDCTL_DSP_SETFMT, &mode) == -1)) { 
     121                                        oss_audio_close(ad); 
     122                                        return FALSE; 
     123                                } 
     124                                debug_msg("Using mu-law\n"); 
     125                        } 
     126                } 
     127                /* 20 ms blocksize - only modulates read sizes */ 
     128                bytes_per_block = 20 * (ifmt->sample_rate / 8000) * (ifmt->bits_per_sample / 8); 
     129                /* Round to the nearest legal frag size (next power of two lower...) */ 
     130                frag |= (int) (log(bytes_per_block)/log(2)); 
     131                debug_msg("frag=%x bytes_per_block=%d\n", frag, bytes_per_block); 
     132                if ((ioctl(audio_fd[ad], SNDCTL_DSP_SETFRAGMENT, &frag) == -1)) { 
     133                        fprintf(stderr, "ERROR: Cannot set the fragement size\n"); 
     134                } 
     135 
     136                stereo = ifmt->channels - 1;  
     137                assert(stereo == 0 || stereo == 1); 
     138                if ((ioctl(audio_fd[ad], SNDCTL_DSP_STEREO, &stereo) == -1) || (stereo != (ifmt->channels - 1))) { 
     139                        printf("ERROR: Audio device doesn't support %d channels!\n", ifmt->channels); 
     140                        oss_audio_close(ad); 
     141                        return FALSE; 
     142                } 
     143 
     144                speed = ifmt->sample_rate; 
     145                if ((ioctl(audio_fd[ad], SNDCTL_DSP_SPEED, &speed) == -1) || (speed != ifmt->sample_rate)) { 
     146                        printf("ERROR: Audio device doesn't support %d sampling rate!\n", ifmt->sample_rate); 
     147                        oss_audio_close(ad); 
     148                        return FALSE; 
     149                } 
     150 
     151                /* Set global gain/volume to maximum values. This may fail on */ 
     152                /* some cards, but shouldn't cause any harm when it does..... */  
     153                ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_VOLUME), &volume); 
     154                ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_RECLEV), &volume); 
     155                /* Select microphone input. We can't select output source...  */ 
     156                oss_audio_set_iport(audio_fd[ad], iport); 
     157                /* Turn off loopback from input to output... This only works  */ 
     158                /* on a few cards, but shouldn't cause problems on the others */ 
     159                ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_IMIX), &reclb); 
     160                /* Device driver bug: we must read some data before the ioctl */ 
     161                /* to tell us how much data is waiting works....              */ 
     162                read(audio_fd[ad], buffer, 128);         
     163                /* Okay, now we're done...                                    */ 
     164                UNUSED(ad); 
     165                return audio_fd[ad]; 
     166        } else { 
     167                oss_audio_close(ad); 
     168                return -1; 
     169        } 
    187170} 
    188171 
     
    191174oss_audio_close(audio_desc_t ad) 
    192175{ 
    193         UNUSED(ad); assert(audio_fd > 0); 
    194         oss_audirain(audio_fd); 
    195         close(audio_fd); 
    196         audio_fd = -1; 
     176        assert(audio_fd[ad] > 0); 
     177        oss_audio_drain(ad); 
     178        close(audio_fd[ad]); 
     179        audio_fd[ad] = -1; 
    197180} 
    198181 
     
    201184oss_audio_drain(audio_desc_t ad) 
    202185{ 
    203         sample buf[160]; 
    204  
    205         UNUSED(ad); assert(audio_fd > 0); 
    206  
    207         while(oss_audio_read(audio_fd, buf, 160) == 160); 
     186        u_char buf[160]; 
     187 
     188        assert(audio_fd[ad] > 0); 
     189 
     190        while(oss_audio_read(audio_fd[ad], buf, 160) == 160); 
    208191} 
    209192 
     
    211194oss_audio_duplex(audio_desc_t ad) 
    212195{ 
    213         /* Find out if the device supports full-duplex operation. The device must 
    214          * be open to do this, so if we're passed -1 as a file-descriptor we open 
    215          * the device, do the ioctl, and then close it again... 
    216          */ 
    217         int info; 
    218         int did_open = FALSE; 
    219  
    220         UNUSED(ad);  
    221  
    222         if (done_test) return is_duplex; 
    223  
    224         if (ad == -1) { 
    225                 audio_fd = open(the_dev, O_RDWR | O_NDELAY); 
    226                 did_open = TRUE; 
    227         } 
    228  
    229         if (ioctl(audio_fd, SNDCTL_DSP_SETDUPLEX, 0) == -1) { 
    230                 if (did_open) close(audio_fd); 
    231                 is_duplex = FALSE; 
    232                 done_test = TRUE; 
    233                 return FALSE; 
    234         } 
    235         if (ioctl(audio_fd, SNDCTL_DSP_GETCAPS, &info) == -1) { 
    236                 if (did_open) close(audio_fd); 
    237                 is_duplex = FALSE; 
    238                 done_test = TRUE; 
    239                 return FALSE; 
    240         } 
    241  
    242         if (did_open) { 
    243                 close(audio_fd); 
    244         } 
    245  
    246         is_duplex = info & DSP_CAP_DUPLEX; 
    247         done_test = TRUE; 
    248         debug_msg("%s duplex audio\n", is_duplex?"Full":"Half"); 
    249         return is_duplex; 
     196        /* We don't open device if not full duplex. */ 
     197        UNUSED(ad); 
     198        return TRUE; 
    250199} 
    251200 
     
    256205        int volume = bat_to_device(gain) << 8 | bat_to_device(gain); 
    257206 
    258         UNUSED(ad); assert(audio_fd > 0); 
     207        assert(audio_fd[ad] > 0); 
    259208 
    260209        switch (iport) { 
    261210        case AUDIO_MICROPHONE :  
    262                 if (ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_MIC), &volume) == -1) { 
     211                if (ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_MIC), &volume) == -1) { 
    263212                        perror("Setting gain"); 
    264213                } 
    265214                return; 
    266215        case AUDIO_LINE_IN :  
    267                 if (ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_LINE), &volume) == -1) { 
     216                if (ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_LINE), &volume) == -1) { 
    268217                        perror("Setting gain"); 
    269218                } 
    270219                return; 
    271220        case AUDIO_CD: 
    272                 if (ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_CD), &volume) < 0) { 
     221                if (ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_CD), &volume) < 0) { 
    273222                        perror("Setting gain"); 
    274223                } 
     
    284233        int volume; 
    285234 
    286         UNUSED(ad); assert(audio_fd > 0); 
     235        UNUSED(ad); assert(audio_fd[ad] > 0); 
    287236 
    288237        switch (iport) { 
    289238        case AUDIO_MICROPHONE :  
    290                 if (ioctl(audio_fd, MIXER_READ(SOUND_MIXER_MIC), &volume) == -1) { 
     239                if (ioctl(audio_fd[ad], MIXER_READ(SOUND_MIXER_MIC), &volume) == -1) { 
    291240                        perror("Getting gain"); 
    292241                } 
    293242                break; 
    294243        case AUDIO_LINE_IN :  
    295                 if (ioctl(audio_fd, MIXER_READ(SOUND_MIXER_LINE), &volume) == -1) { 
     244                if (ioctl(audio_fd[ad], MIXER_READ(SOUND_MIXER_LINE), &volume) == -1) { 
    296245                        perror("Getting gain"); 
    297246                } 
    298247                break; 
    299248        case AUDIO_CD: 
    300                 if (ioctl(audio_fd, MIXER_READ(SOUND_MIXER_CD), &volume) < 0) { 
     249                if (ioctl(audio_fd[ad], MIXER_READ(SOUND_MIXER_CD), &volume) < 0) { 
    301250                        perror("Getting gain"); 
    302251                } 
     
    314263        int volume; 
    315264 
    316         UNUSED(ad); assert(audio_fd > 0); 
     265        UNUSED(ad); assert(audio_fd[ad] > 0); 
    317266 
    318267        volume = vol << 8 | vol; 
    319         if (ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_PCM), &volume) == -1) { 
     268        if (ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_PCM), &volume) == -1) { 
    320269                perror("Setting volume"); 
    321270        } 
     
    325274oss_audio_loopback(audio_desc_t ad, int gain) 
    326275{ 
    327         UNUSED(ad); assert(audio_fd > 0); 
     276        UNUSED(ad); assert(audio_fd[ad] > 0); 
    328277 
    329278        gain = gain << 8 | gain; 
    330         if (ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_IMIX), &gain) == -1) { 
     279        if (ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_IMIX), &gain) == -1) { 
    331280                perror("loopback"); 
    332281        } 
     
    338287        int volume; 
    339288 
    340         UNUSED(ad); assert(audio_fd > 0); 
    341  
    342         if (ioctl(audio_fd, MIXER_READ(SOUND_MIXER_PCM), &volume) == -1) { 
     289        UNUSED(ad); assert(audio_fd[ad] > 0); 
     290 
     291        if (ioctl(audio_fd[ad], MIXER_READ(SOUND_MIXER_PCM), &volume) == -1) { 
    343292                perror("Getting volume"); 
    344293        } 
     
    347296 
    348297int 
    349 oss_audio_read(audio_desc_t ad, sample *buf, int samples) 
    350 { 
    351         UNUSED(ad); assert(audio_fd > 0); 
    352  
    353         if (can_read) { 
    354                 int            len, read_len; 
    355                 audio_buf_info info; 
    356  
    357                 /* Figure out how many bytes we can read before blocking... */ 
    358                 ioctl(audio_fd, SNDCTL_DSP_GETISPACE, &info); 
    359                 if (info.bytes > (int) (samples * BYTES_PER_SAMPLE)) { 
    360                         read_len = (samples * BYTES_PER_SAMPLE); 
    361                 } else { 
    362                         read_len = info.bytes; 
    363                 } 
    364                 if ((len = read(audio_fd, (char *)buf, read_len)) < 0) { 
    365                         perror("audio_read"); 
     298oss_audio_read(audio_desc_t ad, u_char *buf, int read_bytes) 
     299{ 
     300        int read_len; 
     301        audio_buf_info info; 
     302 
     303        assert(audio_fd[ad] > 0);         
     304 
     305        /* Figure out how many bytes we can read before blocking... */ 
     306        ioctl(audio_fd[ad], SNDCTL_DSP_GETISPACE, &info); 
     307 
     308        read_len = min(info.bytes, read_bytes); 
     309        if ((read_len = read(audio_fd[ad], (char *)buf, read_len)) < 0) { 
     310                perror("audio_read"); 
    366311                        return 0; 
    367                 } 
    368                 return len / BYTES_PER_SAMPLE; 
    369         } else { 
    370                 /* The value returned should indicate the time (in audio samples) */ 
    371                 /* since the last time read was called.                           */ 
    372                 int                   i; 
    373                 int                   diff; 
    374                 static struct timeval last_time; 
    375                 static struct timeval curr_time; 
    376                 static int            first_time = 0; 
    377  
    378                 if (first_time == 0) { 
    379                         gettimeofday(&last_time, NULL); 
    380                         first_time = 1; 
    381                 } 
    382                 gettimeofday(&curr_time, NULL); 
    383                 diff = (((curr_time.tv_sec - last_time.tv_sec) * 1e6) + (curr_time.tv_usec - last_time.tv_usec)) / 125; 
    384                 if (diff > samples) diff = samples; 
    385                 if (diff <      80) diff = 80; 
    386                 xmemchk(); 
    387                 for (i=0; i<diff; i++) { 
    388                         buf[i] = L16_AUDIO_ZERO; 
    389                 } 
    390                 xmemchk(); 
    391                 last_time = curr_time; 
    392                 return diff; 
    393         } 
    394 } 
    395  
    396 int 
    397 oss_audio_write(audio_desc_t ad, sample *buf, int samples) 
    398 { 
    399         UNUSED(ad); assert(audio_fd > 0); 
    400          
    401         if (can_write) { 
    402                 int              done, len; 
    403                 char            *p; 
    404  
    405                 p   = (char *) buf; 
    406                 len = samples * BYTES_PER_SAMPLE; 
    407                 while (1) { 
    408                         if ((done = write(audio_fd, p, len)) = len) { 
    409                                 break; 
    410                         } 
    411                         if (errno != EINTR) { 
     312        } 
     313        return read_len; 
     314} 
     315 
     316int 
     317oss_audio_write(audio_desc_t ad, u_char *buf, int write_bytes) 
     318{ 
     319        int              done, len; 
     320        char            *p; 
     321 
     322        assert(audio_fd[ad] > 0); 
     323         
     324        p   = (char *) buf; 
     325        len = write_bytes; 
     326        while (1) { 
     327                if ((done = write(audio_fd[ad], p, len)) == len) { 
     328                        break; 
     329                } 
     330                if (errno != EINTR) { 
    412331                                perror("Error writing device"); 
    413                                 return samples - ((len - done) / BYTES_PER_SAMPLE); 
    414                         } 
    415                         len -= done; 
    416                         p   += done; 
    417                 } 
    418                 return samples; 
    419         } else { 
    420                 return samples; 
    421         } 
     332                                return write_bytes - (len - done); 
     333                } 
     334                len -= done; 
     335                p   += done; 
     336        } 
     337        return write_bytes; 
    422338} 
    423339 
     
    428344        int  on = 1; 
    429345 
    430         UNUSED(ad); assert(audio_fd > 0); 
    431  
    432         if (ioctl(audio_fd, FIONBIO, (char *)&on) < 0) { 
     346        UNUSED(ad); assert(audio_fd[ad] > 0); 
     347 
     348        if (ioctl(audio_fd[ad], FIONBIO, (char *)&on) < 0) { 
    433349                debug_msg("Failed to set non-blocking mode on audio device!\n"); 
    434350        } 
     
    441357        int  on = 0; 
    442358 
    443         UNUSED(ad); assert(audio_fd > 0); 
    444  
    445         if (ioctl(audio_fd, FIONBIO, (char *)&on) < 0) { 
     359        UNUSED(ad); assert(audio_fd[ad] > 0); 
     360 
     361        if (ioctl(audio_fd[ad], FIONBIO, (char *)&on) < 0) { 
    446362                debug_msg("Failed to set blocking mode on audio device!\n"); 
    447363        } 
     
    452368{ 
    453369        /* There appears to be no-way to select this with OSS... */ 
    454         UNUSED(ad); assert(audio_fd > 0); 
     370        UNUSED(ad); assert(audio_fd[ad] > 0); 
    455371        UNUSED(port); 
    456372        return; 
     
    461377{ 
    462378        /* There appears to be no-way to select this with OSS... */ 
    463         UNUSED(ad); assert(audio_fd > 0); 
     379        UNUSED(ad); assert(audio_fd[ad] > 0); 
    464380        return AUDIO_HEADPHONE; 
    465381} 
     
    469385{ 
    470386        /* There appears to be no-way to select this with OSS... */ 
    471         UNUSED(ad); assert(audio_fd > 0); 
     387        UNUSED(ad); assert(audio_fd[ad] > 0); 
    472388        return AUDIO_HEADPHONE; 
    473389} 
     
    480396        int gain; 
    481397 
    482         UNUSED(ad); assert(audio_fd > 0); 
    483  
    484         if (ioctl(audio_fd, MIXER_READ(SOUND_MIXER_RECMASK), &recmask) == -1) { 
     398        UNUSED(ad); assert(audio_fd[ad] > 0); 
     399 
     400        if (ioctl(audio_fd[ad], MIXER_READ(SOUND_MIXER_RECMASK), &recmask) == -1) { 
    485401                debug_msg("WARNING: Unable to read recording mask!\n"); 
    486402                return; 
     
    490406                if (recmask & SOUND_MASK_MIC) { 
    491407                        recsrc = SOUND_MASK_MIC; 
    492                         if ((ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_RECSRC), &recsrc) == -1) && !(recsrc & SOUND_MASK_MIC)) { 
     408                        if ((ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_RECSRC), &recsrc) == -1) && !(recsrc & SOUND_MASK_MIC)) { 
    493409                                debug_msg("WARNING: Unable to select recording source!\n"); 
    494410                                return; 
    495411                        } 
    496                         gain = oss_audio_get_gain(audio_fd); 
     412                        gain = oss_audio_get_gain(audio_fd[ad]); 
    497413                        iport = port; 
    498                         oss_audio_set_gain(audio_fd, gain); 
     414                        oss_audio_set_gain(audio_fd[ad], gain); 
    499415                } else { 
    500416                        debug_msg("Audio device doesn't support recording from microphone\n"); 
     
    504420                if (recmask & SOUND_MASK_LINE) { 
    505421                        recsrc = SOUND_MASK_LINE; 
    506                         if ((ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_RECSRC), &recsrc) == -1) && !(recsrc & SOUND_MASK_LINE)){ 
     422                        if ((ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_RECSRC), &recsrc) == -1) && !(recsrc & SOUND_MASK_LINE)){ 
    507423                                debug_msg("WARNING: Unable to select recording source!\n"); 
    508424                                return; 
    509425                        } 
    510                         gain = oss_audio_get_gain(audio_fd); 
     426                        gain = oss_audio_get_gain(audio_fd[ad]); 
    511427                        iport = port; 
    512                         oss_audio_set_gain(audio_fd, gain); 
     428                        oss_audio_set_gain(audio_fd[ad], gain); 
    513429                } else { 
    514430                        debug_msg("Audio device doesn't support recording from line-input\n"); 
     
    518434                if (recmask & SOUND_MASK_CD) { 
    519435                        recsrc = SOUND_MASK_CD; 
    520                         if ((ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_RECSRC), &recsrc) == -1) && !(recsrc & SOUND_MASK_LINE)){ 
     436                        if ((ioctl(audio_fd[ad], MIXER_WRITE(SOUND_MIXER_RECSRC), &recsrc) == -1) && !(recsrc & SOUND_MASK_LINE)){ 
    521437                                debug_msg("WARNING: Unable to select recording source!\n"); 
    522438                                return; 
    523439                        } 
    524                         gain = oss_audio_get_gain(audio_fd); 
     440                        gain = oss_audio_get_gain(audio_fd[ad]); 
    525441                        iport = port; 
    526                         oss_audio_set_gain(audio_fd, gain); 
     442                        oss_audio_set_gain(audio_fd[ad], gain); 
    527443                } else { 
    528444                        debug_msg("Audio device doesn't support recording from CD\n"); 
     
    539455oss_audio_get_iport(audio_desc_t ad) 
    540456{ 
    541         UNUSED(ad); assert(audio_fd > 0); 
     457        UNUSED(ad); assert(audio_fd[ad] > 0); 
    542458        return iport; 
    543459} 
     
    546462oss_audio_next_iport(audio_desc_t ad) 
    547463{ 
    548         UNUSED(ad); assert(audio_fd > 0); 
     464        UNUSED(ad); assert(audio_fd[ad] > 0); 
    549465 
    550466        switch (iport) { 
    551467        case AUDIO_MICROPHONE :  
    552                 oss_audio_set_iport(audio_fd, AUDIO_LINE_IN); 
     468                oss_audio_set_iport(audio_fd[ad], AUDIO_LINE_IN); 
    553469                break; 
    554470        case AUDIO_LINE_IN :  
    555                 oss_audio_set_iport(audio_fd, AUDIO_CD); 
     471                oss_audio_set_iport(audio_fd[ad], AUDIO_CD); 
    556472                break; 
    557473        case AUDIO_CD :  
    558                 oss_audio_set_iport(audio_fd, AUDIO_MICROPHONE); 
     474                oss_audio_set_iport(audio_fd[ad], AUDIO_MICROPHONE); 
    559475                break; 
    560476        default :  
     
    565481} 
    566482 
    567 int 
    568 oss_audio_get_bytes_per_block(audio_desc_t ad) 
    569 { 
    570         UNUSED(ad); assert(audio_fd > 0); 
    571         return bytes_per_block; 
    572 } 
    573  
    574 int 
    575 oss_audio_get_channels(audio_desc_t ad) 
    576 { 
    577         UNUSED(ad); assert(audio_fd > 0); 
    578         return format.channels; 
    579 } 
    580  
    581 int 
    582 oss_audio_get_freq(audio_desc_t ad) 
    583 { 
    584         UNUSED(ad); assert(audio_fd > 0); 
    585         return format.sample_rate; 
    586 } 
    587  
    588483static int 
    589484oss_audio_select(audio_desc_t ad, int delay_us) 
     
    592487        struct timeval tv; 
    593488 
    594         UNUSED(ad); assert(audio_fd > 0); 
     489        UNUSED(ad); assert(audio_fd[ad] > 0); 
    595490         
    596491        tv.tv_sec = 0; 
     
    598493 
    599494        FD_ZERO(&rfds); 
    600         FD_SET(audio_fd, &rfds); 
    601  
    602         select(audio_fd+1, &rfds, NULL, NULL, &tv); 
    603  
    604         return FD_ISSET(audio_fd, &rfds); 
     495        FD_SET(audio_fd[ad], &rfds); 
     496 
     497        select(audio_fd[ad]+1, &rfds, NULL, NULL, &tv); 
     498 
     499        return FD_ISSET(audio_fd[ad], &rfds); 
    605500} 
    606501 
  • rat/trunk/auddev_oss.h

    r2105 r2107  
    4444#define _AUDDEV_OSS_H_ 
    4545 
    46 int  oss_audio_open       (audio_desc_t ad, audio_format* format); 
     46int  oss_audio_open       (audio_desc_t ad, audio_format* ifmt, audio_format *ofmt); 
    4747void oss_audio_close      (audio_desc_t ad); 
    4848void oss_audio_drain      (audio_desc_t ad); 
     
    5353int  oss_audio_get_volume (audio_desc_t ad); 
    5454void oss_audio_loopback   (audio_desc_t ad, int gain); 
    55 int  oss_audio_read       (audio_desc_t ad, sample *buf, int samples); 
    56 int  oss_audio_write      (audio_desc_t ad, sample *buf, int samples); 
     55int  oss_audio_read       (audio_desc_t ad, u_char *buf, int buf_bytes); 
     56int  oss_audio_write      (audio_desc_t ad, u_char *buf, int buf_bytes); 
    5757void oss_audio_non_block  (audio_desc_t ad); 
    5858void oss_audio_block      (audio_desc_t ad);