Changeset 3969

Show
Ignore:
Timestamp:
03/02/07 19:18:26 (7 years ago)
Author:
piers
Message:

Updates for to bring the code into line with AG sources
- Site app extension
- Per participant volume sliders
- Added a new card defination to auddev_oss

Location:
rat/trunk
Files:
17 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/Makefile.in

    r3695 r3969  
    8686INSTALL_OBJS = ui_installer.o installer.o binaries.o 
    8787 
    88 all: version.h sdr2.plugin.S02.audio.rtp.-.$(RATVER) $(RATVER).spec $(RATVER) $(RATVER)-ui $(RATVER)-media rat Makefile 
     88all: version.h sdr2.plugin.S02.audio.rtp.-.$(RATVER) $(RATVER).spec $(RATVER) $(RATVER)-ui $(RATVER)-media $(RATVER)-kill rat Makefile 
    8989 
    9090libuclaudio.a: $(AUDIO_OBJS) 
     
    9999        $(AR) r $@ $(SNDFILE_OBJS) 
    100100        $(RANLIB) $@ 
     101 
     102$(RATVER)-kill: rat-kill.o 
     103        $(CC) $(CFLAGS) rat-kill.o $(COMMON_LIB) $(LIBS) -o $(RATVER)-kill 
    101104 
    102105$(RATVER)-media: $(CHANNEL_OBJS) $(TOY_OBJS) $(MEDIA_OBJS) $(MEDIALIBS) $(EXTERNAL_DEP) 
     
    165168        ./install-sh -m 555 -c rat             $(bindir) 
    166169        ./install-sh -m 555 -c $(RATVER)       $(bindir) 
     170        ./install-sh -m 555 -c $(RATVER)-kill  $(bindir)/rat-kill 
    167171        ./install-sh -m 555 -c $(RATVER)-media $(bindir) 
    168172        ./install-sh -m 555 -c $(RATVER)-ui    $(bindir) 
     
    203207tgz: $(RATVER)-$(OSTYPE).tar.gz 
    204208 
    205 rpm: tgz 
     209rpm: clean tgz  
    206210        @${ECHO} "Building $(RATVER).rpm -- this almost certainly needs to run as root on RedHat Linux" 
    207         install -m 644 $(RATVER)-$(OSTYPE).tar.gz /usr/src/redhat/SOURCES/rat-4.1.2.tar.gz 
     211#       install -m 644 $(RATVER)-$(OSTYPE).tar.gz /usr/src/redhat/SOURCES/rat-4.1.2.tar.gz 
     212        install -m 644 AccessGrid-rat.spec /usr/src/redhat/SPECS/AccessGrid-rat.spec 
     213        install -m 644 $(RATVER)-$(OSTYPE).tar.gz /usr/src/redhat/SOURCES/$(RATVER)-$(OSTYPE).tar.gz 
    208214        rpm -bb $(RATVER).spec 
     215 
     216agrpm: clean 
     217        @${ECHO} "Building AG $(RATVER).rpm -- this almost certainly needs to run as root on RedHat Linux" 
     218        ( cd ../.. ; ln -s ag-rat $(RATVER) ; tar cvfh /usr/src/redhat/SOURCES/$(RATVER).tar.gz $(RATVER) ; rm $(RATVER) ) 
     219        install -m 644 AccessGrid-rat.spec /usr/src/redhat/SPECS/AccessGrid-rat.spec 
     220        rpm -ba AccessGrid-rat.spec 
    209221 
    210222Makefile: Makefile.in VERSION 
  • rat/trunk/auddev_oss.c

    r3822 r3969  
    9898        "OSS: AudioPCI 97 (CS4297A)", 
    9999        "OSS: Realtek ALC650E", 
     100        "OSS: Analog Devices AD1981B", 
     101        "OSS: Asahi Kasei AK4531", 
    100102        0 
    101103}; 
     
    892894                p   += done; 
    893895        } 
     896        debug_msg("OSS wrote %d bytes\n",write_bytes); 
    894897        return write_bytes; 
    895898} 
  • rat/trunk/auddev_win32.c

    r3869 r3969  
    14501450        UNUSED(ad); 
    14511451 
     1452        debug_msg("set audio_loopback gain to %d\n", gain); 
    14521453        nLoopGain = gain; 
    14531454} 
  • rat/trunk/cmd_parser.c

    r3642 r3969  
    5959 
    6060static int 
     61cmd_logdebug(struct mbus *m, char *addr, int argc, char *argv[]) 
     62{ 
     63        assert(argc == 1); 
     64        printf("cmdparser logdebug\n"); 
     65        mbus_qmsgf(m, addr, TRUE, "tool.rat.logdebug", "1 %s", mbus_encode_str(argv[0])); 
     66        UNUSED(argc); 
     67        UNUSED(argv); 
     68        return TRUE; 
     69} 
     70 
     71static int  
    6172cmd_layers(struct mbus *m, char *addr, int argc, char *argv[]) 
    6273{ 
     
    274285} 
    275286 
     287static int 
     288cmd_app_site(struct mbus *m, char *addr, int argc, char *argv[]) { 
     289        char *app_value, *local_user; 
     290        assert(argc == 1); 
     291        UNUSED(argc); 
     292        local_user = mbus_encode_str("localuser"); 
     293        app_value = mbus_encode_str(argv[0]); 
     294        mbus_qmsgf(m, 
     295                   addr, 
     296                   TRUE, 
     297                   "rtp.source.app.site", 
     298                   "%s %s", 
     299                   local_user, 
     300                   app_value); 
     301        xfree(local_user); 
     302        xfree(app_value); 
     303        return TRUE; 
     304} 
     305   
    276306static args_handler late_args[] = { 
    277307        { "-logstats",       cmd_logstats,     0 }, 
     308        { "-logdebug",       cmd_logdebug,     1 }, 
    278309        { "-l",              cmd_layers,       1 }, 
    279310        { "-allowloopback",  cmd_allowloop,    0 }, 
     
    287318        { "-N",              cmd_sdes_name,    1 }, 
    288319        { "-P",              cmd_sdes_phone,   1 }, 
     320        { "-S",              cmd_app_site,     1 }, 
    289321        { "-agc",            cmd_agc,          1 }, 
    290322        { "-silence",        cmd_silence,      1 }, 
  • rat/trunk/configure.in

    r3691 r3969  
    188188        ]) 
    189189        # Do we have ALSA? 
    190         AC_CHECK_HEADER(sys/asoundlib.h,[ 
     190        AC_CHECK_HEADER(alsa/asoundlib.h,[ 
    191191                AUD_OBJ="$AUD_OBJ auddev_alsa.o" 
    192192                AUD_LIB="$AUD_LIB -lasound" 
  • rat/trunk/main_engine.c

    r3967 r3969  
    22 * FILE:    main-engine.c 
    33 * PROGRAM: RAT 
    4  * AUTHOR:  Colin Perkins 
     4 * AUTHOR:  Colin Perkins  
    55 * 
    66 * Copyright (c) 1995-2001 University College London 
    77 * All rights reserved. 
    88 */ 
    9  
     9  
    1010#ifndef HIDE_SOURCE_STRINGS 
    11 static const char cvsid[] = 
     11static const char cvsid[] =  
    1212        "$Id$"; 
    1313#endif /* HIDE_SOURCE_STRINGS */ 
     
    5454 
    5555char            *c_addr, *token[2], *token_e[2]; /* Could be in the session struct */ 
    56 int              should_exit = FALSE; 
     56int              should_exit = FALSE;  
    5757int              mbus_shutdown_error = FALSE; 
    5858int              num_sessions = 1; 
     
    7373static void parse_args(int argc, char *argv[]) 
    7474{ 
    75         int     i, tc; 
     75        int             i, tc; 
    7676 
    7777        if ((argc != 5)  && (argc != 8)) { 
     
    110110} 
    111111 
    112 static void 
     112static void  
    113113mbus_error_handler(int seqnum, int reason) 
    114114{ 
     
    119119                fatal_error("RAT v" RAT_VERSION, msg); 
    120120                abort(); 
    121         } 
     121        }  
    122122        mbus_shutdown_error = TRUE; 
    123123        UNUSED(seqnum); 
     
    145145                        timeout.tv_sec  = 0; 
    146146                        timeout.tv_usec = 10000; 
    147                         mbus_send(sp[j]->mbus_engine); 
     147                        mbus_send(sp[j]->mbus_engine);  
    148148                        mbus_recv(sp[j]->mbus_engine, (void *) sp[j], &timeout); 
    149149                        mbus_heartbeat(sp[j]->mbus_engine, 1); 
     
    188188                        timeout.tv_usec = 20000; 
    189189                        mbus_qmsgf(sp[i]->mbus_engine, c_addr, FALSE, "mbus.waiting", "%s", token_e[i]); 
    190                         mbus_send(sp[i]->mbus_engine); 
     190                        mbus_send(sp[i]->mbus_engine);  
    191191                        mbus_recv(sp[i]->mbus_engine, (void *) sp[i], &timeout); 
    192192                        mbus_heartbeat(sp[i]->mbus_engine, 1); 
     
    213213        SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); 
    214214#else 
    215         signal(SIGINT, signal_handler); 
     215        signal(SIGINT, signal_handler);  
    216216        debug_set_core_dir(argv[0]); 
    217217#endif 
     
    255255        /* Moved session[0] setup to rx_rtp_addr so one may change addr 
    256256           binding dynamically */ 
    257         /* Load saved settings, and create the participant database... */ 
    258         /* FIXME: probably needs updating for the transcoder so we can */ 
    259         /*        have different saved settings for each domain.       */ 
    260         /* FIXME: this gets the wrong device name for the transcoder.  */ 
    261         for (i = 0; i < num_sessions; i++) { 
    262                 if (pdb_create(&sp[i]->pdb) == FALSE) { 
    263                         debug_msg("Failed to create participant database\n"); 
    264                         abort(); 
    265                 } 
    266                 pdb_item_create(sp[i]->pdb, (uint16_t)ts_get_freq(sp[i]->cur_ts), rtp_my_ssrc(sp[i]->rtp_session[0])); 
    267                 settings_load_late(sp[i]); 
    268                 session_validate(sp[i]); 
    269         } 
     257        /* Load saved settings, and create the participant database... */ 
     258        /* FIXME: probably needs updating for the transcoder so we can */ 
     259        /*        have different saved settings for each domain.       */ 
     260        /* FIXME: this gets the wrong device name for the transcoder.  */ 
     261        for (i = 0; i < num_sessions; i++) { 
     262                if (pdb_create(&sp[i]->pdb) == FALSE) { 
     263                        debug_msg("Failed to create participant database\n"); 
     264                        abort(); 
     265                } 
     266                pdb_item_create(sp[i]->pdb, (uint16_t)ts_get_freq(sp[i]->cur_ts), rtp_my_ssrc(sp[i]->rtp_session[0]));  
     267                settings_load_late(sp[i]); 
     268                session_validate(sp[i]); 
     269        } 
    270270 
    271271        xmemchk(); 
     
    296296                                rtp_time = tx_get_rtp_time(sp[i]); 
    297297                                while(rtp_recv(sp[i]->rtp_session[j], &timeout, rtp_time)); 
    298                                 rtp_send_ctrl(sp[i]->rtp_session[j], rtp_time, NULL); 
     298                                rtp_send_ctrl(sp[i]->rtp_session[j], rtp_time, rtcp_app_site_callback); 
    299299                                rtp_update(sp[i]->rtp_session[j]); 
    300300                        } 
     
    306306                        mbus_heartbeat(sp[i]->mbus_engine, 1); 
    307307                        mbus_retransmit(sp[i]->mbus_engine); 
    308                         mbus_send(sp[i]->mbus_engine); 
     308                        mbus_send(sp[i]->mbus_engine);  
    309309 
    310310                        /* Process and mix active sources */ 
     
    431431                                } 
    432432                        } 
    433  
     433                         
    434434                        /* Choke CPU usage */ 
    435435                        if (!audio_is_ready(sp[i]->audio_device)) { 
     
    468468                audio_free_interfaces(); 
    469469        } 
    470  
     470         
    471471        /* FIXME: This should be integrated into the previous loop, so instead of */ 
    472472        /*        sending mbus.bye() ourselves, we just call mbus_exit(...) which */ 
     
    476476                do { 
    477477                        struct timeval   timeout; 
    478                         mbus_send(sp[0]->mbus_engine); 
     478                        mbus_send(sp[0]->mbus_engine);  
    479479                        /* At this stage we no longer care about acks for messages */ 
    480480                        /* mbus_retransmit(sp[0]->mbus_engine); */ 
     
    495495                xfree(token_e[i]); 
    496496        } 
    497  
     497         
    498498        converters_free(); 
    499499        xfree(c_addr); 
  • rat/trunk/main_ui.c

    r3642 r3969  
    9595 
    9696#ifdef WIN32 
     97        HANDLE waitHandles[2]; 
     98 
    9799        HANDLE     hWakeUpEvent; 
     100        HANDLE  hParentProcess; 
     101        DWORD waitRet; 
     102 
    98103        TkWinXInit(hAppInstance); 
    99104        hWakeUpEvent = CreateEvent(NULL, FALSE, FALSE, "Local\\RAT UI WakeUp Event"); 
     105 
    100106#endif 
    101107 
     
    105111        parse_args(argc, argv); 
    106112        tcl_init1(argc, argv); 
     113 
     114#ifdef WIN32 
     115        hParentProcess = OpenProcess(SYNCHRONIZE, FALSE, ppid); 
     116        debug_msg("OpenPRocess returns %d\n", hParentProcess); 
     117#endif 
    107118 
    108119        sprintf(m_addr, "(media:audio module:ui app:rat id:%lu)", (unsigned long) ppid); 
     
    162173#ifdef WIN32 
    163174                /* Just timeout waiting for event that never happens */ 
    164                 WaitForSingleObject(hWakeUpEvent, 30); 
     175                /* WaitForSingleObject(hWakeUpEvent, 30); */ 
     176 
     177                waitHandles[0] = hWakeUpEvent; 
     178                waitHandles[1] = hParentProcess; 
     179                waitRet = WaitForMultipleObjects(2, waitHandles, FALSE, 30); 
     180                 
     181                if ((waitRet - WAIT_OBJECT_0) == 1) 
     182                { 
     183                        debug_msg("Parent process died\n"); 
     184                        should_exit = TRUE; 
     185                } 
    165186#else 
    166187                timeout.tv_sec  = 0; 
  • rat/trunk/mbus_engine.c

    r3850 r3969  
    5353extern FILE     *stats_file; 
    5454 
     55extern void rtp_callback_open_logfile(char *file); 
     56 
    5557/* Mbus command reception function type */ 
    5658typedef void (*mbus_rx_proc)(char *srce, char *args, session_t *sp); 
     
    631633} 
    632634 
     635static void rx_tool_rat_logdebug(char *srce, char *args, session_t *sp) 
     636{ 
     637    int enabled; 
     638    char *file; 
     639        struct mbus_parser      *mp; 
     640 
     641        UNUSED(srce); 
     642        UNUSED(sp); 
     643         
     644                printf("Logdebug '%s'\n", args); 
     645 
     646        mp = mbus_parse_init(args); 
     647        if (mbus_parse_int(mp, &enabled) && 
     648            mbus_parse_str(mp, &file)) 
     649            { 
     650                mbus_decode_str(file); 
     651                printf("enabled=%d file=%s\n", enabled, file); 
     652                if (enabled) { 
     653                    rtp_callback_open_logfile(file); 
     654                } 
     655        } else { 
     656                debug_msg("mbus: usage \"tool.rat.logstats <boolean>\"\n"); 
     657        } 
     658        mbus_parse_done(mp); 
     659} 
     660 
    633661static void rx_tool_rat_tone_start(char *srce, char *args, session_t *sp) 
    634662{ 
     
    902930        uint32_t         ssrc, my_ssrc; 
    903931        struct s_source *s; 
     932    pdb_entry_t *e; 
    904933 
    905934        UNUSED(args); 
     
    918947                ui_send_rtp_note(sp, srce, ssrc); 
    919948                ui_send_rtp_mute(sp, srce, ssrc); 
     949 
     950                if (pdb_item_get(sp->pdb, ssrc, &e) == TRUE) { 
     951                  if (e->siteid != NULL) { 
     952                    ui_send_rtp_app_site(sp, srce, ssrc, e->siteid); 
     953                  } 
     954                } 
     955 
    920956                if (ssrc != my_ssrc) { 
    921957                        if ((s = source_get_by_ssrc(sp->active_sources, ssrc)) != NULL) { 
     
    10991135} 
    11001136 
     1137static void rx_rtp_source_app_site(char *srce, char *args, session_t *sp) 
     1138{ 
     1139        char               *arg, *ss; 
     1140        uint32_t           ssrc; 
     1141        struct mbus_parser *mp; 
     1142        UNUSED(srce); 
     1143 
     1144        mp = mbus_parse_init(args); 
     1145        if (mbus_parse_str(mp, &ss) && 
     1146            mbus_parse_str(mp, &arg)) { 
     1147                uint32_t my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); 
     1148                ss = mbus_decode_str(ss); 
     1149                if (isalpha((int)ss[0])) { 
     1150                        /* 
     1151                         * Allow alpha so people can do my_src, me, 
     1152                         * local_user, whatever.  Let the mbus police 
     1153                         * pick something sane. 
     1154                         */ 
     1155                        ssrc = my_ssrc; 
     1156                } else { 
     1157                        ssrc = strtoul(ss, 0, 16); 
     1158                } 
     1159                if (ssrc == my_ssrc) { 
     1160                        char *value; 
     1161 
     1162                        value = mbus_decode_str(arg); 
     1163 
     1164                        if (sp->rtp_session_app_site != NULL) { 
     1165                                xfree(sp->rtp_session_app_site); 
     1166                        } 
     1167                        sp->rtp_session_app_site = xstrdup(value); 
     1168                } else { 
     1169                        debug_msg("mbus: rtp_source_app_site ssrc %s (%08lx) != %08lx\n", ss, strtoul(ss, 0, 16), rtp_my_ssrc(sp->rtp_session[0])); 
     1170                } 
     1171        } else { 
     1172                debug_msg("mbus: usage \"rtp_source_app_site <ssrc> <siteid>\"\n"); 
     1173        } 
     1174        mbus_parse_done(mp); 
     1175} 
    11011176 
    11021177static void rx_rtp_source_gain(char *srce, char *args, session_t *sp) 
     
    16401715static const mbus_cmd_tuple engine_cmds[] = { 
    16411716        { "tool.rat.logstats",                     rx_tool_rat_logstats }, 
     1717        { "tool.rat.logdebug",                     rx_tool_rat_logdebug }, 
    16421718        { "tool.rat.tone.start",                   rx_tool_rat_tone_start }, 
    16431719        { "tool.rat.tone.stop",                    rx_tool_rat_tone_stop }, 
     
    16961772        { "rtp.source.mute",                       rx_rtp_source_mute }, 
    16971773        { "rtp.source.gain",                       rx_rtp_source_gain }, 
     1774        { "rtp.source.app.site",                   rx_rtp_source_app_site }, 
    16981775        { "mbus.quit",                             rx_mbus_quit }, 
    16991776        { "mbus.bye",                              rx_mbus_bye }, 
     
    17171794        debug_msg("Unknown mbus command: %s (%s)\n", cmnd, args); 
    17181795#ifndef NDEBUG 
     1796        fprintf(stderr, "Unknown mbus command: %s (%s)\n", cmnd, args); 
    17191797        abort(); 
    17201798#endif 
  • rat/trunk/pdb.c

    r3637 r3969  
    130130 
    131131        /* Initialize elements of item here as necesary **********************/ 
     132 
    132133        item->magic             = 0xc001babe; 
    133134        item->ssrc              = id; 
     
    153154        item->last_rtt          = 0.0; 
    154155        item->avg_rtt           = 0.0; 
    155  
    156156        /* Packet stats initialization                                       */ 
    157157        item->received          = 0; 
     
    162162        item->spike_events      = 0; 
    163163 
     164        item->siteid          = NULL; 
     165 
    164166        pdb_item_validate(item); 
    165167        /*********************************************************************/ 
  • rat/trunk/pdb.h

    r3642 r3969  
    6767        uint32_t        jit_toged;                   /* Packets discarded because late ("Thrown on ground") */ 
    6868 
     69  /* SiteID from RTCP APP packet. */ 
     70        char           *siteid; 
     71 
    6972        uint32_t        magic;  /* For debugging */ 
    7073} pdb_entry_t; 
  • rat/trunk/process.c

    r3642 r3969  
    4848 
    4949        if (num_tokens == 1) { 
    50                 sprintf(args, "%s -ctrl \"%s\" -token %s", proc_name, ctrl_addr, token[0]); 
     50                _snprintf(args, sizeof(args), "%s -ctrl \"%s\" -token %s", proc_name, ctrl_addr, token[0]); 
    5151        } else { 
    52                 sprintf(args, "%s -T -ctrl \"%s\" -token %s -token %s", proc_name, ctrl_addr, token[0], token[1]); 
     52                _snprintf(args, sizeof(args), "%s -T -ctrl \"%s\" -token %s -token %s", proc_name, ctrl_addr, token[0], token[1]); 
    5353        } 
    5454 
  • rat/trunk/rtp_callback.c

    r3671 r3969  
    3232#include "rtp_dump.h" 
    3333 
     34int rtp_get_ssrc_count(struct rtp *r); 
     35 
    3436/* We need to be able to resolve the rtp session to a rat session in */ 
    3537/* order to get persistent participant information, etc.  We use a   */ 
     
    4951static int rtp_as_inited; 
    5052 
     53static FILE *log_fp = 0; 
     54 
     55void rtp_callback_open_logfile(char *file); 
     56 
     57void rtp_callback_open_logfile(char *file) 
     58{ 
     59    log_fp = fopen(file, "a"); 
     60    if (!log_fp) 
     61    { 
     62        perror("log_fp open failed"); 
     63    } 
     64    else 
     65    { 
     66        struct timeval  tv; 
     67        gettimeofday(&tv, 0); 
     68 
     69        printf("Opened logfile %s\n", file); 
     70        fprintf(log_fp, "%d.%06d 0 start\n", (int) tv.tv_sec, (int) tv.tv_usec); 
     71    } 
     72} 
     73 
     74 
    5175void 
    5276rtp_callback_init(struct rtp *rtps, struct s_session *rats) 
     
    87111{ 
    88112        rtp_assoc_t *cur, *sentinel; 
     113 
     114 
     115        if (log_fp != 0) 
     116        { 
     117            fclose(log_fp); 
     118            log_fp = 0; 
     119        } 
    89120 
    90121        sentinel = &rtp_as; 
     
    283314                break; 
    284315        case RTCP_SDES_CNAME: 
     316            if (log_fp != 0) 
     317            { 
     318                struct timeval  tv; 
     319                gettimeofday(&tv, 0); 
     320 
     321                fprintf(log_fp, "%d.%06d %d cname %x %s\n", (int) tv.tv_sec, (int) tv.tv_usec, 
     322                        (int) rtp_get_ssrc_count(sp->rtp_session[0]), 
     323                        (int) ssrc, 
     324                        rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_CNAME)); 
     325                fflush(log_fp); 
     326            } 
    285327                ui_send_rtp_cname(sp, sp->mbus_ui_addr, ssrc); 
    286328                break; 
     
    312354 
    313355static void 
     356process_app(session_t *sp, uint32_t ssrc, rtcp_app *app) 
     357{ 
     358  if (strncmp(app->name, "site", 4) == 0) { 
     359    int site_id_len = 4*(app->length - 2); 
     360    pdb_entry_t *e; 
     361 
     362    if (pdb_item_get(sp->pdb, ssrc, &e) == FALSE) { 
     363      debug_msg("process_app: unknown source (0x%08x).\n", ssrc); 
     364      return; 
     365    } else { 
     366      if (e->siteid == NULL) { 
     367        e->siteid = xmalloc(site_id_len + 1); 
     368        strncpy(e->siteid, app->data, site_id_len); 
     369        e->siteid[site_id_len] = '\0'; 
     370      } 
     371         
     372      ui_send_rtp_app_site(sp, sp->mbus_ui_addr, ssrc, e->siteid); 
     373    } 
     374  } 
     375} 
     376 
     377static void 
    314378process_create(session_t *sp, uint32_t ssrc) 
    315379{ 
     380            if (log_fp != 0) 
     381            { 
     382                struct timeval  tv; 
     383                gettimeofday(&tv, 0); 
     384 
     385                fprintf(log_fp, "%d.%06d %d create %x \n", (int) tv.tv_sec, (int) tv.tv_usec, 
     386                        (int) rtp_get_ssrc_count(sp->rtp_session[0]), 
     387                        (int) ssrc); 
     388                fflush(log_fp); 
     389            } 
     390     
    316391        if (pdb_item_create(sp->pdb, (uint16_t)ts_get_freq(sp->cur_ts), ssrc) == FALSE) { 
    317392                debug_msg("Unable to create source 0x%08lx\n", ssrc); 
     
    322397process_delete(session_t *sp, rtp_event *e) 
    323398{ 
     399            if (log_fp != 0) 
     400            { 
     401                struct timeval  tv, *dead; 
     402                int d_sec = -1, d_usec = -1; 
     403 
     404                gettimeofday(&tv, 0); 
     405 
     406                dead = (struct timeval *) e->data; 
     407                if (dead != 0) 
     408                { 
     409                    d_sec = (int) dead->tv_sec; 
     410                    d_usec = (int) dead->tv_usec; 
     411                } 
     412                fprintf(log_fp, "%d.%06d %d delete %x %d.%06d\n", (int) tv.tv_sec, (int) tv.tv_usec, 
     413                        rtp_get_ssrc_count(sp->rtp_session[0]), 
     414                        e->ssrc, 
     415                        d_sec, d_usec); 
     416                fflush(log_fp); 
     417            } 
    324418        if (e->ssrc != rtp_my_ssrc(sp->rtp_session[0]) && sp->mbus_engine != NULL) { 
    325419                struct s_source *s; 
     
    384478        case RX_APP: 
    385479                debug_msg("Received and ignored application specific report from %08x\n", e->ssrc); 
     480                process_app(sp, e->ssrc, (rtcp_app*)e->data); 
     481                xfree(e->data); 
    386482                break; 
    387483        case RX_BYE: 
     
    406502} 
    407503 
     504rtcp_app* rtcp_app_site_callback(struct rtp *session,  
     505                                 uint32_t rtp_ts,  
     506                                 int max_size) 
     507{ 
     508        struct s_session *sp; 
     509        int len; 
     510        int datalen; 
     511        int slen; 
     512 
     513        sp = get_session(session); 
     514        if (sp == NULL) { 
     515                /* Shouldn't happen */ 
     516                return NULL; 
     517        } 
     518 
     519        if (sp->rtp_session_app_site == NULL) { 
     520                /* Site identifier not set */ 
     521                return NULL; 
     522        } 
     523 
     524        if (sp->rtcp_app_packet_ts == rtp_ts) { 
     525                /* Already sent an APP for this timestamp */ 
     526                return NULL; 
     527        } 
     528 
     529        slen = strlen(sp->rtp_session_app_site); 
     530        datalen = slen; 
     531        if (slen % 4 > 0) { 
     532                datalen += 4 - (slen % 4); 
     533        } 
     534        len = datalen + sizeof(rtcp_app) - 1; 
     535        if (len > max_size) { 
     536                /* Can't fit the site id in the current RTCP compound packet */ 
     537                return NULL; 
     538        } 
     539 
     540        if (sp->rtcp_app_packet != NULL) { 
     541          xfree(sp->rtcp_app_packet); 
     542        } 
     543 
     544        sp->rtcp_app_packet = xmalloc(len); 
     545 
     546        sp->rtcp_app_packet->version = RTP_VERSION; 
     547        sp->rtcp_app_packet->p = 0; 
     548        sp->rtcp_app_packet->subtype = 0; 
     549        sp->rtcp_app_packet->pt = 204; 
     550 
     551        /* Host -> Network order is handled by common lib */ 
     552        sp->rtcp_app_packet->length = 2 + datalen/4; 
     553        sp->rtcp_app_packet->ssrc = rtp_my_ssrc(session); 
     554 
     555        strncpy(sp->rtcp_app_packet->name, "site", 4); 
     556        memset(sp->rtcp_app_packet->data, 0, datalen); 
     557        strncpy(sp->rtcp_app_packet->data, sp->rtp_session_app_site, slen); 
     558 
     559        sp->rtcp_app_packet_ts = rtp_ts; 
     560        return sp->rtcp_app_packet; 
     561} 
     562 
     563 
  • rat/trunk/rtp_callback.h

    r3543 r3969  
    1919void rtp_callback_exit (struct rtp *s); 
    2020 
     21 
     22rtcp_app* rtcp_app_site_callback(struct rtp *session, 
     23                                 uint32_t rtp_ts, 
     24                                 int max_size); 
     25 
    2126#endif /* __RTP_CALLBACK_H__ */ 
  • rat/trunk/session.h

    r3642 r3969  
    1818#include "converter_types.h" 
    1919#include "repair_types.h" 
     20 
     21#include "rtp.h" 
    2022 
    2123/* This will have to be raised in the future */ 
     
    6365        struct rtp              *rtp_session[MAX_LAYERS]; 
    6466        int                      rtp_session_count; 
     67        char                    *rtp_session_app_site; 
     68        rtcp_app                *rtcp_app_packet; 
     69        uint32_t                 rtcp_app_packet_ts; 
    6570        uint8_t                  layers;                        /* number of layers == rtp_session_count */ 
    6671        int                      filter_loopback; 
  • rat/trunk/ui_audiotool.tcl

    r3959 r3969  
    322322                rtp.source.gain                 {eval mbus_recv_rtp.source.gain $args} 
    323323                rtp.source.rtt                  {eval mbus_recv_rtp.source.rtt $args} 
     324                rtp.source.app.site     {eval mbus_recv_rtp.source.app.site $args} 
    324325                security.encryption.key         {eval mbus_recv_security.encryption.key $args} 
    325326                default                         {bgerror "Unknown mbus command $cmnd"} 
     
    10931094} 
    10941095 
     1096proc mbus_recv_rtp.source.app.site {ssrc val} { 
     1097} 
     1098 
    10951099proc mbus_recv_audio.file.play.ready {name} { 
    10961100    global play_file 
     
    12401244                $cw create polygon $l $h $h $l $h $f -outline black -fill grey -tag m 
    12411245                $cw create polygon $f $h $h $l $h $f -outline black -fill grey -tag h 
     1246                scale ${cw}.gain_scale_$ssrc -showvalue 0 -orient h -from -3 -to +3 -resolution 0.25 -command "ssrc_set_gain $ssrc" 
     1247                $cw create window [expr $iwd + 1] $h -anchor e -window $cw.gain_scale_$ssrc  
    12421248 
    12431249                bind $cw <Button-1>         "toggle_stats \"$ssrc\"" 
     
    16411647pack .st -side bottom -fill x -padx 2 -pady 0 
    16421648pack .st.file .st.recp .st.help -side left -anchor e -padx 2 -pady 2 
    1643  
    16441649 
    16451650pack .st.quit .st.about .st.opts -side right -anchor w -padx 2 -pady 2 
  • rat/trunk/ui_send_rtp.c

    r3821 r3969  
    189189} 
    190190 
     191void ui_send_rtp_app_site(session_t *sp, char *addr, uint32_t ssrc, char *siteid) 
     192{ 
     193        char *enc_siteid; 
     194        if (!sp->ui_on) return; 
     195        enc_siteid = mbus_encode_str(siteid); 
     196        mbus_qmsgf(sp->mbus_engine, addr, TRUE, "rtp.source.app.site", "\"%08lx\" %s", ssrc, enc_siteid); 
     197        xfree(enc_siteid); 
     198} 
  • rat/trunk/ui_send_rtp.h

    r3642 r3969  
    2828void ui_send_rtp_addr       (session_t *sp, char *addr); 
    2929void ui_send_rtp_title      (session_t *sp, char *addr); 
    30  
     30void ui_send_rtp_app_site   (session_t *sp, char *addr, uint32_t ssrc, char *siteid);