Changeset 1908

Show
Ignore:
Timestamp:
09/14/98 15:06:30 (16 years ago)
Author:
ucacoxh
Message:

- Moved select on audio file descriptor out of network_read.

- Created audio_wait_for which blocks on audio device for both UNIX boxes and

Win32.

- Win32 CPU usage reduction of 50% in both transmitting and receiving. Load on

idle down to 5% and transmitting 10% on 266 PII which is about where the
Ultra 1 170's are.

Location:
rat/trunk
Files:
7 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/auddev_win32.c

    r1907 r1908  
    11/* 
    2  * FILE:        audwin32.c 
     2 * FILE:        auddev_win32.c 
    33 * 
    44 * Win32 audio interface for RAT. 
    55 * 
    6  * Written by Isidor Kouvelas and Orion Hodson 
     6 * Written by Orion Hodson and Isidor Kouvelas 
    77 * Portions based on the VAT Win95 port by John Brezak. 
    88 * 
     
    576576static unsigned char audio_ready = 0; 
    577577 
    578 unsigned char 
    579 is_audio_ready() 
     578int 
     579audio_is_ready() 
    580580{ 
    581581        if (audio_ready>nblks/5) { 
  • rat/trunk/audio.c

    r1901 r1908  
    454454        return (read_dur); 
    455455} 
     456 
     457void 
     458audio_wait_for(session_struct *sp) 
     459{ 
     460#ifdef WIN32 
     461        DWORD   dwPeriod; 
     462        codec_t *cp; 
     463         
     464        cp = get_codec_by_pt(sp->encodings[0]); 
     465        dwPeriod = cp->unit_len * 1000 / get_freq(sp->device_clock); 
     466        /* The blocks we are passing to the audio interface are of duration dwPeriod. 
     467         * dwPeriod is usually around 20ms (8kHz), but mmtask often doesn't give 
     468         * us audio that often, more like every 40ms. 
     469         */ 
     470        while (!audio_is_ready()) { 
     471                Sleep(dwPeriod); 
     472        } 
     473        return; 
     474#else 
     475        fd_set rfds; 
     476        FD_ZERO(&rfds); 
     477        FD_SET(sp->audio_fd,&rfds); 
     478        select(sp->audio_fd, &rfds, NULL, NULL, NULL); 
     479        return; 
     480#endif 
     481} 
  • rat/trunk/audio.h

    r1903 r1908  
    111111int     audio_get_blocksize(void); 
    112112int     audio_get_channels(void); 
    113 int audio_get_freq(void); 
     113int     audio_get_freq(void); 
     114int     audio_is_ready(void); /* Only in auddev_win32.c */ 
    114115 
    115116/* Stuff in audio.c */ 
     
    127128void    audio_device_reconfigure(struct session_tag *sp); 
    128129void    audio_unbias(struct s_bias_ctl *bc, sample *buf, int len); 
    129  
     130void    audio_wait_for(struct session_tag *sp); 
    130131#endif /* _RAT_AUDIO_H_ */ 
  • rat/trunk/config_win32.h

    r1901 r1908  
    149149int getpid(void); 
    150150int nice(int); 
     151int usleep(unsigned int); 
    151152time_t time(time_t *); 
    152153 
  • rat/trunk/main.c

    r1901 r1908  
    6666 
    6767int should_exit = FALSE; 
    68 int thread_pri  = 2;            /* Time critical */ 
     68int thread_pri  = 2; /* Time Critical */ 
    6969 
    7070#ifndef WIN32 
     
    264264                                audio_device_reconfigure(sp[i]); 
    265265                        } 
     266                         
     267                        /* Choke CPU usage */ 
     268                        if (sp[i]->have_device) { 
     269                                audio_wait_for(sp[i]); 
     270                        } else { 
     271                                usleep(20000); 
     272                        } 
    266273                } 
    267274        } 
  • rat/trunk/net.c

    r1901 r1908  
    359359                } 
    360360        } 
    361 #if !defined(WIN32) 
    362         if (sp->mode == AUDIO_TOOL) { 
    363                 sel_fd = max(sel_fd, sp->audio_fd); 
    364         } 
    365 #endif 
    366361        sel_fd++; 
    367362 
    368         for (;;) { 
    369                 FD_ZERO(&rfds); 
    370                 FD_SET(sp->rtp_fd,  &rfds); 
    371                 FD_SET(sp->rtcp_fd, &rfds); 
    372                 FD_SET(mbus_engine_fd(0), &rfds); 
    373                 if (sp->ui_on) { 
    374                         FD_SET(mbus_ui_fd(0),     &rfds); 
    375                 } 
    376                 if (sp->mbus_channel != 0) { 
    377                         FD_SET(mbus_engine_fd(TRUE), &rfds); 
    378                         if (sp->ui_on) { 
    379                                 FD_SET(mbus_ui_fd(TRUE),     &rfds); 
    380                         } 
    381                 } 
    382 #if defined(WIN32) || defined(HPUX) || defined(Linux)  
    383                 timeout.tv_sec  = 0; 
    384                 timeout.tv_usec = sp->loop_delay; 
    385                 tvp = &timeout; 
    386 #else 
    387                 if ((sp->audio_fd != -1) && (sp->mode == AUDIO_TOOL)) { 
    388                         FD_SET(sp->audio_fd, &rfds); 
    389                         tvp = NULL; 
    390                 } else { 
    391                         /* If we dont have control of the audio device then */ 
    392                         /* use select to do a timeout at 20ms               */ 
    393                         timeout.tv_sec  = 0; 
    394                         timeout.tv_usec = sp->loop_delay; 
    395                         tvp = &timeout; 
    396                 } 
    397 #endif 
    398                 if (select(sel_fd, &rfds, (fd_set *) 0, (fd_set *) 0, tvp) > 0) { 
    399                         if (FD_ISSET(sp->rtp_fd, &rfds)) { 
    400                                 read_packets_and_add_to_queue(sp->rtp_fd, cur_time, netrx_pckt_queue_ptr, PACKET_RTP); 
    401                         } 
    402                         if (FD_ISSET(sp->rtcp_fd, &rfds)) { 
    403                                 read_packets_and_add_to_queue(sp->rtcp_fd, cur_time, rtcp_pckt_queue_ptr, PACKET_RTCP); 
    404                         } 
    405                         if (FD_ISSET(mbus_engine_fd(FALSE), &rfds)) { 
    406                                 mbus_recv(mbus_engine(FALSE), (void *) sp); 
    407                         } 
    408                         if (sp->ui_on && FD_ISSET(mbus_ui_fd(FALSE), &rfds)) { 
    409                                 mbus_recv(mbus_ui(FALSE), (void *) sp); 
    410                         } 
    411                         if (sp->mbus_channel != 0) { 
    412                                 if (FD_ISSET(mbus_engine_fd(TRUE), &rfds)) { 
    413                                         mbus_recv(mbus_engine(TRUE), (void *) sp); 
    414                                 } 
    415                                 if (sp->ui_on && FD_ISSET(mbus_ui_fd(TRUE), &rfds)) { 
    416                                         mbus_recv(mbus_ui(TRUE), (void *) sp); 
    417                                 } 
    418                         } 
    419                 } 
    420 #if !defined(WIN32) && !defined(HPUX) && !defined(Linux)  
    421                 if (sp->mode == AUDIO_TOOL) { 
    422                         if (sp->audio_fd == -1 || FD_ISSET(sp->audio_fd, &rfds)) { 
    423                                 break; 
    424                         } 
    425                 } else { 
    426                         break; 
    427                 } 
    428 #else 
    429                         break; 
    430 #endif 
    431         } 
     363         
     364        FD_ZERO(&rfds); 
     365        FD_SET(sp->rtp_fd,  &rfds); 
     366        FD_SET(sp->rtcp_fd, &rfds); 
     367        FD_SET(mbus_engine_fd(0), &rfds); 
     368        if (sp->ui_on) { 
     369                FD_SET(mbus_ui_fd(0),     &rfds); 
     370        } 
     371        if (sp->mbus_channel != 0) { 
     372                FD_SET(mbus_engine_fd(TRUE), &rfds); 
     373                if (sp->ui_on) { 
     374                        FD_SET(mbus_ui_fd(TRUE),     &rfds); 
     375                } 
     376        } 
     377         
     378        timeout.tv_sec  = 0; 
     379        timeout.tv_usec = sp->loop_delay; 
     380        tvp = &timeout; 
     381         
     382        if (select(sel_fd, &rfds, (fd_set *) 0, (fd_set *) 0, tvp) > 0) { 
     383                if (FD_ISSET(sp->rtp_fd, &rfds)) { 
     384                        read_packets_and_add_to_queue(sp->rtp_fd, cur_time, netrx_pckt_queue_ptr, PACKET_RTP); 
     385                } 
     386                if (FD_ISSET(sp->rtcp_fd, &rfds)) { 
     387                        read_packets_and_add_to_queue(sp->rtcp_fd, cur_time, rtcp_pckt_queue_ptr, PACKET_RTCP); 
     388                } 
     389                if (FD_ISSET(mbus_engine_fd(FALSE), &rfds)) { 
     390                        mbus_recv(mbus_engine(FALSE), (void *) sp); 
     391                } 
     392                if (sp->ui_on && FD_ISSET(mbus_ui_fd(FALSE), &rfds)) { 
     393                        mbus_recv(mbus_ui(FALSE), (void *) sp); 
     394                } 
     395                if (sp->mbus_channel != 0) { 
     396                        if (FD_ISSET(mbus_engine_fd(TRUE), &rfds)) { 
     397                                mbus_recv(mbus_engine(TRUE), (void *) sp); 
     398                        } 
     399                        if (sp->ui_on && FD_ISSET(mbus_ui_fd(TRUE), &rfds)) { 
     400                                mbus_recv(mbus_ui(TRUE), (void *) sp); 
     401                        } 
     402                } 
     403        }        
    432404} 
    433405 
  • rat/trunk/win32.c

    r1907 r1908  
    474474} 
    475475 
     476int  
     477usleep(unsigned int usec) 
     478{ 
     479        DWORD dur = usec/1000; 
     480        if (dur) Sleep(dur); 
     481        return 0; 
     482} 
    476483#endif /* WIN32 */