Changeset 4252

Show
Ignore:
Timestamp:
08/08/08 02:13:20 (6 years ago)
Author:
soohyunc
Message:

two types of XR packets (one for ackvec and the other for ts)

o now, a separate send_xreport() created

o this way, we could have SR/RR and XR at the same time

o now, two separate methods for ackvec pkt and ts pkt

Todo: currently, send_xreport() is driven by timer. we need to call
send_xreport() upon every ackofack reception.

Location:
vic/branches/cc
Files:
5 modified

Legend:

Unmodified
Added
Removed
  • vic/branches/cc/cc/tfwc_rcvr.h

    r4245 r4252  
    5252protected: 
    5353        inline u_int32_t get_ackvec() { return tfwcAV; } 
     54        inline u_int32_t get_timestamp() { return tfwcAV; } 
    5455        u_int32_t tfwcAV;       // AckVec (bit vector) 
    5556        u_int16_t seqno_;       // received RTP packet seqno 
  • vic/branches/cc/cc/tfwc_sndr.cpp

    r4247 r4252  
    5151{ 
    5252        u_int32_t marginvec_ = 0xe0000000; 
    53         debug_msg("XXX %d\n", marginvec_); 
    5453} 
    5554 
     
    6766void TfwcSndr::tfwc_sndr_recv(u_int32_t ackv) 
    6867{ 
    69         UNUSED(ackv); 
    70  
    7168        // the most recent 3 packets will be marked as 1 using marginvec_ 
    7269        ackv_ = ackv | marginvec_; 
  • vic/branches/cc/rtp/rtp.h

    r4251 r4252  
    133133 * (RFC 3611) 
    134134 */ 
     135#define XR_BT_1 1       // Loss RLE Report Block 
     136#define XR_BT_2 2       // Duplicate RLE Report Block 
     137#define XR_BT_3 3       // Packet Receipt Times Report Block 
     138#define XR_BT_4 4       // Receiver Reference Time Report Block 
    135139struct rtcp_xr_hdr { 
    136140        u_int32_t xr_flags;     /* BT:8 TS:8 LEN:16 */ 
  • vic/branches/cc/rtp/session.cpp

    r4251 r4252  
    593593{ 
    594594        send_report(ch, 0); 
     595        send_xreport(ch, 0); 
     596} 
     597 
     598/* 
     599 * Send an RTP extended report packet. 
     600 */ 
     601void SessionManager::send_xreport(CtrlHandler* ch, int bye, int app) 
     602{ 
     603        UNUSED(app); 
     604        UNUSED(bye); 
     605 
     606        SourceManager& sm = SourceManager::instance(); 
     607        Source& s = *sm.localsrc(); 
     608        rtcphdr* rh = (rtcphdr*)pktbuf_; 
     609        rh->rh_ssrc = s.srcid(); 
     610        int flags = RTP_VERSION << 14; 
     611        int layer = ch - ch_; 
     612        Source::Layer& sl = s.layer(layer); 
     613        timeval now = unixtime(); 
     614        sl.lts_ctrl(now); 
     615 
     616        int we_sent = 0; 
     617        rtcp_rr* rr; 
     618        rtcp_xr_hdr* xrh;   // extended report header 
     619        rtcp_xr_blk* xrb;   // extended report block 
     620        Tcl& tcl = Tcl::instance(); 
     621 
     622        MediaTimer* mt = MediaTimer::instance(); 
     623        if (sl.np() != last_np_ && mt) { 
     624                last_np_ = sl.np(); 
     625                we_sent = 1; 
     626                flags |= RTCP_PT_SR; 
     627                rtcp_sr* sr = (rtcp_sr*)(rh + 1); 
     628                sr->sr_ntp = ntp64time(now); 
     629                HTONL(sr->sr_ntp.upper); 
     630                HTONL(sr->sr_ntp.lower); 
     631                sr->sr_ts = htonl(mt->ref_ts()); 
     632                sr->sr_np = htonl(sl.np()); 
     633                sr->sr_nb = htonl(sl.nb()); 
     634                rr = (rtcp_rr*)(sr + 1); 
     635        } else { 
     636                flags |= RTCP_PT_RR; 
     637                rr = (rtcp_rr*)(rh + 1); 
     638        } 
     639 
     640        // set this to XR packet 
     641        flags |= RTCP_PT_XR; 
     642        // access XR header  
     643        xrh = (rtcp_xr_hdr*)(rh + 1); 
     644        // XR block length 
     645        int xrlen = (xrh->xr_flags << 16) >> 16; 
     646        // access XR block contents 
     647        xrb = (rtcp_xr_blk*)(xrh + xrlen + 1); 
     648        // for ackofack 
     649        xrb->begin_seq = htonl(lastseq_); 
     650        xrb->end_seq = htonl(seqno_ + 1); 
     651        // this chunk is ackvec 
     652        xrb->chunk = (u_int32_t *) htonl(get_ackvec()); 
     653        // this chunk is timestamp echo 
     654        //xrb->chunk = htonl(mt->ref_ts()); 
     655 
     656        int nrr = 0; 
     657        int nsrc = 0; 
     658 
     659        u_int inactive = u_int(ch->rint() * (32./1000.)); 
     660        if (inactive < 2) 
     661                inactive = 2; 
     662        for (Source* sp = sm.sources(); sp != 0; sp = sp->next_) { 
     663                ++nsrc; 
     664                Source::Layer& sl = sp->layer(layer); 
     665                int received = sl.np() - sl.snp(); 
     666                if (received == 0) { 
     667                        if (u_int(now.tv_sec - sl.lts_ctrl().tv_sec) > inactive) 
     668                                --nsrc; 
     669                        continue; 
     670                } 
     671                sl.snp(sl.np()); 
     672                rr->rr_srcid = sp->srcid(); 
     673                int expected = sl.ns() - sl.sns(); 
     674                sl.sns(sl.ns()); 
     675                u_int32_t v; 
     676                int lost = expected - received; 
     677 
     678                if (lost <= 0) 
     679                        v = 0; 
     680                else 
     681                        /* expected != 0 if lost > 0 */ 
     682                        v = ((lost << 8) / expected) << 24; 
     683 
     684                /* XXX should saturate on over/underflow */ 
     685                v |= (sl.ns() - sl.np()) & 0xffffff; 
     686                rr->rr_loss = htonl(v); 
     687                rr->rr_ehsr = htonl(sl.ehs()); 
     688                rr->rr_dv = (sp->handler() != 0) ? sp->handler()->delvar() : 0; 
     689                rr->rr_lsr = htonl(sl.sts_ctrl()); 
     690 
     691                if (sl.lts_ctrl().tv_sec == 0) 
     692                        rr->rr_dlsr = 0; 
     693                else { 
     694                        u_int32_t ntp_now = ntptime(now); 
     695                        u_int32_t ntp_then = ntptime(sl.lts_ctrl()); 
     696                        rr->rr_dlsr = htonl(ntp_now - ntp_then); 
     697                } 
     698                ++rr; 
     699                if (++nrr >= 31) 
     700                        break; 
     701        } 
     702 
     703        flags |= nrr << 8; 
     704        rh->rh_flags = htons(flags); 
     705        int len = (u_char*)rr - pktbuf_; 
     706        rh->rh_len = htons((len >> 2) - 1); 
     707 
     708        if (bye) 
     709                len += build_bye((rtcphdr*)rr, s); 
     710        else 
     711                len += build_sdes((rtcphdr*)rr, s); 
     712         
     713        // build "site" app data if specified 
     714        const char *data = tcl.attr("site"); 
     715        if(data)  
     716        { 
     717            rr = (rtcp_rr*)(((u_char*)rh) + len); 
     718            len += build_app((rtcphdr*)rr, s, "site", (void *)data, strlen(data)); 
     719        } 
     720 
     721    ch->send(pktbuf_, len); 
    595722} 
    596723 
     
    614741        int we_sent = 0; 
    615742        rtcp_rr* rr; 
    616         rtcp_xr_hdr* xrh;       // extended report header 
    617         rtcp_xr_blk* xrb;       // extended report block 
     743        //rtcp_xr_hdr* xrh;     // extended report header 
     744        //rtcp_xr_blk* xrb;     // extended report block 
    618745        Tcl& tcl = Tcl::instance(); 
    619746 
     
    641768                rr = (rtcp_rr*)(rh + 1); 
    642769        } 
    643  
     770/* 
    644771        // if CC is turned on, we need XR report 
    645772        if (is_cc_on()) { 
     
    653780                //xrb->chunk = htonl(mt->ref_ts()); 
    654781        } 
    655  
     782*/ 
    656783        int nrr = 0; 
    657784        int nsrc = 0; 
     
    10091136                                                          Source* ps, Address & addr, int layer) 
    10101137{ 
     1138        debug_msg("XXX parse_sr() called!\n"); 
    10111139        rtcp_sr* sr = (rtcp_sr*)(rh + 1); 
    10121140        Source* s; 
     
    10771205                                      const u_char* ep, Address & addr) 
    10781206{ 
    1079         debug_msg("XXX parse_xr_records\n"); 
     1207        debug_msg("XXX parse_xr_records() called!"); 
    10801208        UNUSED(cnt); 
    10811209        UNUSED(ep); 
     
    10911219                // we received ackofack, so do receiver stuffs here 
    10921220                //trim_vec(xrb->chunk); // chunk in xrb is ackvec 
    1093                 ch_[0].send(build_ackvpkt(xrh), xrlen); 
     1221                ch_[0].send(build_ackvpkt(xrh, ssrc), xrlen); 
     1222                ch_[0].send(build_tspkt(xrh, ssrc), xrlen); 
    10941223        } else { 
    10951224                // we received ackvec, so do sender stuffs here 
     
    11011230} 
    11021231 
    1103 u_char* SessionManager::build_ackvpkt(rtcp_xr_hdr* xrh)  
    1104 { 
     1232// build ackvec packet (RTCP XR packet) 
     1233u_char* SessionManager::build_ackvpkt(rtcp_xr_hdr* xrh, u_int32_t ssrc)  
     1234{ 
     1235        // set XR block type 
     1236        xrh->xr_flags |= 0x01000000; 
     1237 
     1238        // take XR block contents 
     1239        int xrlen = (xrh->xr_flags << 16) >> 16; 
     1240        rtcp_xr_blk* xrb = (rtcp_xr_blk*)(xrh + xrlen + 1); 
     1241 
     1242        xrb->ssrc = ssrc; 
     1243        xrb->chunk = (u_int32_t *) get_ackvec(); 
     1244         
     1245        u_char* p = (u_char*) xrh; 
     1246        return (p); 
     1247} 
     1248 
     1249// build timestamp packet (RTCP XR packet) 
     1250u_char* SessionManager::build_tspkt(rtcp_xr_hdr* xrh, u_int32_t ssrc)  
     1251{ 
     1252        // set XR block type 
     1253        xrh->xr_flags |= 0x03000000; 
     1254 
     1255        // take XR block contents 
     1256        int xrlen = (xrh->xr_flags << 16) >> 16; 
     1257        rtcp_xr_blk* xrb = (rtcp_xr_blk*)(xrh + xrlen + 1); 
     1258 
     1259        xrb->ssrc = ssrc; 
     1260        //xrb->chunk = (u_int32_t *) echo_timestamp(); 
     1261 
    11051262        u_char* p = (u_char*) xrh; 
    11061263        return (p); 
  • vic/branches/cc/rtp/session.h

    r4249 r4252  
    128128//      virtual void send_report(); 
    129129        virtual void send_report(CtrlHandler*, int bye, int app = 0); 
     130        virtual void send_xreport(CtrlHandler*, int bye, int app = 0); 
    130131 
    131132protected: 
     
    156157                        Address & addr, u_int32_t ssrc, int layer); 
    157158        void parse_bye(rtcphdr* rh, int flags, u_char* ep, Source* ps); 
    158         u_char* build_ackvpkt(rtcp_xr_hdr* xrh); 
     159        u_char* build_ackvpkt(rtcp_xr_hdr* xrh, u_int32_t ssrc); 
     160        u_char* build_tspkt(rtcp_xr_hdr* xrh, u_int32_t ssrc); 
    159161 
    160162        int parseopts(const u_char* bp, int cc, Address & addr) const;