Changeset 2959

Show
Ignore:
Timestamp:
11/24/99 19:56:32 (15 years ago)
Author:
ucacoxh
Message:

- Packet spike defense. Sounds good with spikes on sessions tested so

far.

- Spike stats added to user panel.

Location:
rat/trunk
Files:
7 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/MODS

    r2958 r2959  
    963963          and the same for the signed varients. 
    964964        - And change them all to be uint32, etc 
     965        - Packet spikes now accounted for in packet processing.  Transit  
     966          average and playout not updated during spike period. 
     967        - Playout panel now displays spike info also. 
    965968 
    966969TODO -- They're features not bugs dammit! 
  • rat/trunk/pdb.c

    r2958 r2959  
    151151        item->misordered      = 0; 
    152152        item->jit_toged       = 0; 
     153        item->spike_toged     = 0; 
     154        item->spike_events    = 0; 
    153155 
    154156        /*********************************************************************/ 
  • rat/trunk/pdb.h

    r2958 r2959  
    2929  
    3030typedef struct { 
    31         uint32_t         ssrc;                        /* Unique Id */ 
     31        uint32_t        ssrc;                        /* Unique Id */ 
    3232        u_char          first_mix:1; 
    3333        struct s_render_3D_dbentry  *render_3D_data; /* Participant 3d state */ 
    3434        double          gain;                        /* Participant gain */ 
    35         u_char          mute:1;                      /* source muted */ 
     35        u_char          mute:1;                      /* source muted */ 
    3636        struct s_time  *clock; 
    37         uint16_t                units_per_packet; 
    38         uint16_t         inter_pkt_gap;               /* expected time between pkt arrivals */ 
     37        uint16_t        units_per_packet; 
     38        uint16_t        inter_pkt_gap;               /* expected time between pkt arrivals */ 
    3939        ts_t            frame_dur; 
    4040        u_char          enc; 
    4141        char*           enc_fmt; 
    4242        int             enc_fmt_len; 
    43         uint32_t         last_ts; 
    44         uint32_t         last_seq; 
     43        uint32_t        last_ts; 
     44        uint32_t        last_seq; 
    4545        ts_t            last_arr;                    /* ts_t representation of last_ts */ 
    4646 
     
    5050        ts_t            last_transit; 
    5151        ts_t            avg_transit; 
    52         cc_id_t         channel_coder_id;            /* channel_coder of last received packet */ 
    53         ts_t            last_mixed;                  /* Used to check mixing */ 
    54         ts_t            playout;                     /* Playout delay for this talkspurt */ 
     52        cc_id_t         channel_coder_id;            /* channel_coder of last received packet    */ 
     53        ts_t            last_mixed;                  /* Used to check mixing                     */ 
     54        ts_t            playout;                     /* Playout delay for this talkspurt         */ 
    5555        ts_sequencer    seq;                         /* Mapper from RTP time rep to rat time rep */ 
    56  
     56        uint32_t        spike_events;                /* Number of spike events                   */ 
     57        uint32_t        spike_toged;                 /* Number of packets dropped in spike mode  */ 
    5758        /* Display Info */ 
    5859        ts_t            last_ui_update;              /* Used for periodic update of packet counts, etc */ 
    5960 
    6061        /* Packet info */ 
    61         uint32_t         received; 
    62         uint32_t         duplicates; 
    63         uint32_t         misordered; 
    64         uint32_t         jit_toged;                   /* Packets discarded because late ("Thrown on ground") */ 
     62        uint32_t        received; 
     63        uint32_t        duplicates; 
     64        uint32_t        misordered; 
     65        uint32_t        jit_toged;                   /* Packets discarded because late ("Thrown on ground") */ 
    6566 
    6667        /* Variables for playout time calculation */ 
     
    7172        /* Mapping between rtp time and NTP time for this sender */ 
    7273        int             mapping_valid; 
    73         uint32_t         last_ntp_sec;  /* NTP timestamp */ 
    74         uint32_t         last_ntp_frac; 
    75         uint32_t         last_rtp_ts;   /* RTP timestamp */ 
     74        uint32_t        last_ntp_sec;   /* NTP timestamp */ 
     75        uint32_t        last_ntp_frac; 
     76        uint32_t        last_rtp_ts;    /* RTP timestamp */ 
    7677} pdb_entry_t; 
    7778 
  • rat/trunk/playout_calc.c

    r2958 r2959  
    2121#include "playout_calc.h" 
    2222 
    23 #define PLAYOUT_JITTER_SCALE 2 
     23#define PLAYOUT_JITTER_SCALE 3 
    2424 
    2525static ts_t 
     
    7676        } 
    7777 
    78 /* 
    79         if (ts_gt(ts_abs_diff(transit, e->avg_transit), ts_mul(e->jitter, 5)) && new_spurt) { 
    80                 e->avg_transit = transit; 
    81         } 
    82         */ 
    83  
    8478        if (new_spurt == TRUE) { 
    8579                ts_t hvar, jvar; /* Host and jitter components       */ 
  • rat/trunk/source.c

    r2958 r2959  
    6060typedef enum { SOURCE_SKEW_SLOW, SOURCE_SKEW_FAST, SOURCE_SKEW_NONE } skew_t; 
    6161 
     62typedef enum { PLAYOUT_MODE_NORMAL, PLAYOUT_MODE_SPIKE } pmode_t; 
     63 
    6264typedef struct s_source { 
    6365        struct s_source            *next; 
     
    7981        struct s_pb_iterator       *media_pos; 
    8082        struct s_converter         *converter; 
     83        pmode_t                     playout_mode; /* SPIKE, NORMAL */ 
     84        ts_t                        ipg;          /* inter-packet gap        */ 
    8185        /* Fine grained playout buffer adjustment variables.  Used in        */ 
    8286        /* attempts to correct for clock skew between source and local host. */ 
     
    195199static ts_t transit_reset;  /* Period after which new transit time taken     */ 
    196200                            /* if source has been quiet.                     */ 
     201static ts_t spike_jump;     /* Packet spike delay threshold (trigger).       */ 
    197202static int  time_constants_inited = FALSE; 
    198203 
     
    203208        /* We use these time constants *all* the time.   Initialize once     */ 
    204209        zero_ts        = ts_map32(8000, 0); 
    205         keep_source_ts = ts_map32(8000, 2000);  
     210        keep_source_ts = ts_map32(8000, 24000); 
    206211        history_ts     = ts_map32(8000, 1000);  
    207212        bw_avg_period  = ts_map32(8000, 8000); 
     
    209214        skew_limit     = ts_map32(8000, 4000); 
    210215        transit_reset  = ts_map32(8000, 80000); 
     216        spike_jump     = ts_map32(8000, 4000);  
    211217        time_constants_inited = TRUE; 
    212218} 
     
    576582 
    577583static void 
    578 source_playout_log(source *src, uint32_t ts) 
     584source_playout_log(source *src, u_int32_t ts, ts_t now) 
    579585{ 
    580586        if (psf == NULL) { 
     
    584590                } else { 
    585591                        atexit(source_close_log); 
    586                         fprintf(psf, "# <RTP timestamp> <talkstart> <jitter> <transit> <avg transit> <last transit> <playout del>\n"); 
     592                        fprintf(psf, "# <RTP timestamp> <talkstart> <jitter> <transit> <avg transit> <last transit> <playout del> <ipg> <arr time>\n"); 
    587593                } 
    588594                t0 = ts - 1000; /* -1000 in case of out of order first packet */ 
    589595        } 
    590596 
    591         fprintf(psf, "%.6f %5lu %5lu %5lu %5lu %5lu %5lu\n", 
     597        fprintf(psf, "%.6f %5u %5u %5u %5u %5u %5u %5u %5u\n", 
    592598                (ts - t0)/8000.0, 
    593599                ts_to_ms(src->talkstart), 
     
    596602                ts_to_ms(src->pdbe->avg_transit), 
    597603                ts_to_ms(src->pdbe->last_transit), 
    598                 ts_to_ms(src->pdbe->playout)); 
     604                ts_to_ms(src->pdbe->playout), 
     605                ts_to_ms(src->ipg), 
     606                ts_to_ms(now) 
     607                ); 
    599608} 
    600609 
     
    620629source_process_packets(session_t *sp, source *src, ts_t now) 
    621630{ 
    622         ts_t    src_ts, playout, transit; 
    623         pdb_entry_t     *e; 
    624         rtp_packet      *p; 
    625         cc_id_t          ccid = -1; 
    626         uint16_t          units_per_packet = -1; 
    627         uint32_t          delta_ts, delta_seq; 
    628         u_char           codec_pt; 
    629         int              adjust_playout; 
     631 
     632        ts_t    src_ts, playout, transit, ipg; 
     633        pdb_entry_t    *e; 
     634        rtp_packet     *p; 
     635        cc_id_t         ccid = -1; 
     636        uint16_t        units_per_packet = -1; 
     637        uint32_t        delta_ts, delta_seq; 
     638        uint8_t         codec_pt; 
     639        uint8_t         adjust_playout; 
    630640 
    631641        e = src->pdbe; 
     
    668678                        e->inter_pkt_gap    = e->units_per_packet * (uint16_t)samples_per_frame; 
    669679                        e->frame_dur        = ts_map32(cf->format.sample_rate, samples_per_frame); 
    670  
     680                        src->ipg            = ts_mul(e->frame_dur, e->units_per_packet); 
    671681                        debug_msg("Encoding change\n"); 
    672682                        /* Get string describing encoding.                   */ 
     
    697707                } 
    698708 
    699                 if (ts_gt(e->jitter, e->playout)) { 
    700                         /* Network conditions have changed drastically.      */ 
    701                         /* We are in the wrong ball park change immediately. */ 
    702                         adjust_playout = TRUE; 
     709                /* Spike adaptation - similar to Henning's Adaptive Playout  */ 
     710                ipg = ts_sub(now, e->last_arr); /* inter-packet gap  */ 
     711                if (adjust_playout == FALSE) { 
     712                        ts_t spt; 
     713/*                        spt = ts_add(e->jitter, spike_jump); */ 
     714                        spt = ts_mul(e->playout, 3); 
     715                        if (ts_gt(ipg, spt)) { 
     716                                debug_msg("Spike"); 
     717                                src->playout_mode = PLAYOUT_MODE_SPIKE; 
     718                                src->ipg          = ipg; 
     719                                e->spike_events++; 
     720                        } 
     721 
     722                        src->ipg = ts_mul(src->ipg, 7); 
     723                        src->ipg = ts_add(src->ipg, ipg); 
     724                        src->ipg = ts_div(src->ipg, 8); 
     725 
     726                        if (src->playout_mode == PLAYOUT_MODE_SPIKE) { 
     727                                if (ts_gt(ts_mul(e->frame_dur, e->units_per_packet + 1), src->ipg)) { 
     728                                        /* measured interpacket gap is > half expected */ 
     729                                        debug_msg("Normal mode - Spike toged %ld\n", e->spike_toged); 
     730                                        src->playout_mode = PLAYOUT_MODE_NORMAL; 
     731                                        adjust_playout = TRUE; 
     732                                } else { 
     733                                        debug_msg("Spike mode, discarding packet.\n"); 
     734                                        e->spike_toged++; 
     735                                        src_ts = ts_seq32_in(&e->seq, get_freq(e->clock), p->ts); 
     736                                } 
     737                        } 
     738                } else { 
     739                        src->playout_mode = PLAYOUT_MODE_NORMAL; 
    703740                } 
    704741 
     
    725762 
    726763                /* Calculate the playout point for this packet.              */ 
    727                 playout = playout_calc(sp, e->ssrc, transit, adjust_playout); 
     764                if (src->playout_mode == PLAYOUT_MODE_NORMAL) { 
     765                        playout = playout_calc(sp, e->ssrc, transit, adjust_playout); 
     766                } else { 
     767                        playout = e->playout; 
     768                } 
     769 
    728770                if ((p->m || src->packets_done == 0) && ts_gt(playout, e->frame_dur)) { 
    729771                        /* Packets are likely to be compressed at talkspurt start */ 
     
    732774                        debug_msg("New ts shift XXX\n"); 
    733775                } 
     776 
    734777                playout = ts_add(e->transit, playout); 
    735778                playout = ts_add(src_ts, playout); 
    736779 
    737780                if (adjust_playout) { 
    738 /* 
    739                         debug_msg("last  % 5d avg % 5d\n", transit.ticks, e->avg_transit.ticks); 
    740                         if (ts_gt(now, playout)) { 
    741                                 ts_t shortfall; 
    742 */ 
    743                                 /* Unit would have been discarded.  Jitter has    */ 
    744                                 /* affected our first packets transit time.       */ 
    745 /* 
    746                                 shortfall       = ts_sub(now, playout); 
    747                                 playout         = ts_add(playout, shortfall); 
    748                                 e->transit      = ts_add(e->transit, shortfall); 
    749                                 e->last_transit = e->transit; 
    750                                 e->avg_transit  = e->transit; 
    751                                 debug_msg("Push back %d samples\n", shortfall.ticks); 
    752                         } 
    753 */ 
    754781                        src->talkstart = playout; /* Note start of new talkspurt  */ 
    755782                        src->post_talkstart_units = 0; 
     
    781808                        /* threshold.  It signifies current playout delay   */ 
    782809                        /* is inappropriate.                                */ 
    783                         debug_msg("Packet late (compared to now)\n"); 
    784                         source_update_toged(src, 1); 
    785                         src->pdbe->jit_toged++; 
     810                        if (src->playout_mode == PLAYOUT_MODE_NORMAL) { 
     811                                debug_msg("Packet late (compared to now)\n"); 
     812                                source_update_toged(src, 1); 
     813                                src->pdbe->jit_toged++; 
     814                        } else { 
     815                                /* Spike mode - don't worry about jit_toged */ 
     816                                src->pdbe->spike_toged++; 
     817                        } 
    786818                }  
    787819 
     
    790822                        e->misordered++; 
    791823                } 
    792                 e->last_seq = p->seq; 
    793                 e->last_ts  = p->ts; 
    794                 e->last_arr = now; 
    795  
     824                e->last_seq     = p->seq; 
     825                e->last_ts      = p->ts; 
     826                e->last_arr     = now; 
     827                e->last_transit = transit; 
    796828#ifdef SOURCE_LOG_PLAYOUT 
    797                 source_playout_log(src, p->ts); 
     829                source_playout_log(src, p->ts, now); 
    798830#endif /* SOURCE_LOG_PLAYOUT */ 
    799831                src->packets_done++; 
     
    11841216                        /* so get data at media_pos again.                   */ 
    11851217                        if (source_repair(src, repair_type, src->next_played) == TRUE) { 
     1218/* 
    11861219                                debug_msg("Repair % 2d got % 6d exp % 6d talks % 6d\n",  
    11871220                                          src->consec_lost, playout.ticks, src->next_played.ticks, src->talkstart.ticks); 
     1221                                          */ 
    11881222                                success = pb_iterator_get_at(src->media_pos,  
    11891223                                                             (u_char**)&md,  
  • rat/trunk/ui.c

    r2958 r2959  
    206206        mbus_qmsgf(sp->mbus_engine, sp->mbus_ui_addr, FALSE, "tool.rat.audio.delay", "\"%08lx\" %ld", pdbe->ssrc, delay); 
    207207        mbus_qmsgf(sp->mbus_engine, sp->mbus_ui_addr, FALSE, "tool.rat.audio.skew", "\"%08lx\" %.5f", pdbe->ssrc, skew_rate); 
     208        mbus_qmsgf(sp->mbus_engine, sp->mbus_ui_addr, FALSE, "tool.rat.spike.events", "\"%08lx\" %ld", pdbe->ssrc, pdbe->spike_events); 
     209        mbus_qmsgf(sp->mbus_engine, sp->mbus_ui_addr, FALSE, "tool.rat.spike.toged", "\"%08lx\" %ld",  pdbe->ssrc, pdbe->spike_toged); 
    208210 
    209211        my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); 
  • rat/trunk/ui_audiotool.tcl

    r2946 r2959  
    9696        global CODEC DURATION PCKTS_RECV PCKTS_LOST PCKTS_MISO PCKTS_DUP JITTER \ 
    9797                LOSS_TO_ME LOSS_FROM_ME INDEX JIT_TOGED BUFFER_SIZE PLAYOUT_DELAY \ 
    98                 GAIN MUTE SKEW 
     98                GAIN MUTE SKEW SPIKE_EVENTS SPIKE_TOGED 
    9999 
    100100        # This is a debugging test -- old versions of the mbus used the 
     
    122122                set PLAYOUT_DELAY($ssrc) 0 
    123123                set          SKEW($ssrc) 1.000 
     124                set   SPIKE_EVENTS($ssrc) 0          
     125                set   SPIKE_TOGED($ssrc) 0           
    124126                set    PCKTS_RECV($ssrc) 0 
    125127                set    PCKTS_LOST($ssrc) 0 
     
    248250                tool.rat.audio.delay            {eval mbus_recv_tool.rat.audio.delay $args} 
    249251                tool.rat.audio.skew             {eval mbus_recv_tool.rat.audio.skew $args} 
     252                tool.rat.spike.events           {eval mbus_recv_tool.rat.spike.events $args} 
     253                tool.rat.spike.toged            {eval mbus_recv_tool.rat.spike.toged $args} 
    250254                tool.rat.3d.enabled             {eval mbus_recv_tool.rat.3d.enabled $args} 
    251255                tool.rat.3d.azimuth.min         {eval mbus_recv_tool.rat.3d.azimuth.min $args} 
     
    864868        init_source $ssrc 
    865869        set BUFFER_SIZE($ssrc) $buffered  
    866 # we don't update cname as source.packet.duration always follows  
    867870} 
    868871 
     
    871874        init_source $ssrc 
    872875        set PLAYOUT_DELAY($ssrc) $len  
    873 # we don't update cname as source.packet.duration always follows  
    874876} 
    875877 
     
    878880        init_source $ssrc 
    879881        set SKEW($ssrc) [format "%.3f" $skew] 
    880 # we don't update cname as source.packet.duration always follows  
     882} 
     883 
     884proc mbus_recv_tool.rat.spike.events {ssrc events} { 
     885    global SPIKE_EVENTS 
     886    init_source $ssrc 
     887    set SPIKE_EVENTS($ssrc) $events 
     888} 
     889 
     890proc mbus_recv_tool.rat.spike.toged {ssrc toged} { 
     891    global SPIKE_TOGED 
     892    init_source $ssrc 
     893    set SPIKE_TOGED($ssrc) $toged 
    881894} 
    882895 
     
    959972            PCKTS_DUP JITTER BUFFER_SIZE PLAYOUT_DELAY LOSS_TO_ME LOSS_FROM_ME INDEX JIT_TOGED \ 
    960973            num_ssrc loss_to_me_timer loss_from_me_timer GAIN MUTE HEARD_LOSS_TO_ME HEARD_LOSS_FROM_ME \ 
    961             SKEW 
     974            SKEW SPIKE_EVENTS SPIKE_TOGED 
    962975 
    963976    # Disable updating of loss diamonds. This has to be done before we destroy the 
     
    974987        unset CODEC($ssrc) DURATION($ssrc) PCKTS_RECV($ssrc) PCKTS_LOST($ssrc) PCKTS_MISO($ssrc) PCKTS_DUP($ssrc) 
    975988        unset JITTER($ssrc) LOSS_TO_ME($ssrc) LOSS_FROM_ME($ssrc) INDEX($ssrc) JIT_TOGED($ssrc) BUFFER_SIZE($ssrc) 
    976         unset PLAYOUT_DELAY($ssrc) GAIN($ssrc) MUTE($ssrc) SKEW($ssrc) 
     989        unset PLAYOUT_DELAY($ssrc) GAIN($ssrc) MUTE($ssrc) SKEW($ssrc) SPIKE_EVENTS($ssrc) SPIKE_TOGED($ssrc) 
    977990        incr num_ssrc -1 
    978991    } 
     
    13291342        frame $win.df.playout -relief groove -bd 2 
    13301343        global BUFFER_SIZE PLAYOUT_DELAY JITTER JIT_TOGED SKEW 
    1331         stats_add_field $win.df.playout.1 "Actual Playout (ms): "    BUFFER_SIZE($ssrc) 
    1332         stats_add_field $win.df.playout.2 "Target Playout (ms): "    PLAYOUT_DELAY($ssrc) 
    1333         stats_add_field $win.df.playout.3 "Arrival jitter (ms): "    JITTER($ssrc) 
    1334         stats_add_field $win.df.playout.4 "Units dropped (jitter): " JIT_TOGED($ssrc) 
    1335         stats_add_field $win.df.playout.5 "Relative clock rate:"     SKEW($ssrc) 
     1344        stats_add_field $win.df.playout.1 "Actual Playout (ms): "     BUFFER_SIZE($ssrc) 
     1345        stats_add_field $win.df.playout.2 "Target Playout (ms): "     PLAYOUT_DELAY($ssrc) 
     1346        stats_add_field $win.df.playout.3 "Arrival jitter (ms): "     JITTER($ssrc) 
     1347        stats_add_field $win.df.playout.4 "Packets dropped (jitter):" JIT_TOGED($ssrc) 
     1348        stats_add_field $win.df.playout.5 "Spike Events:"             SPIKE_EVENTS($ssrc) 
     1349        stats_add_field $win.df.playout.6 "Packets dropped (spike):"  SPIKE_TOGED($ssrc) 
     1350        stats_add_field $win.df.playout.7 "Relative clock rate:"      SKEW($ssrc) 
    13361351 
    13371352        frame $win.df.decoder -relief groove -bd 2