X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fthird_party%2Fwebrtc%2Fmodules%2Frtp_rtcp%2Fsource%2Frtp_sender.cc;h=677f3fc4986bc35910dd5b81a87f69be47c1f3d0;hb=1afa4dd80ef85af7c90efaea6959db1d92330844;hp=f544db2108e3ecc06adbf0526d3ccf8b8878fd92;hpb=90762837333c13ccf56f2ad88e4481fc71e8d281;p=platform%2Fframework%2Fweb%2Fcrosswalk.git diff --git a/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender.cc index f544db2..677f3fc 100644 --- a/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender.cc +++ b/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender.cc @@ -40,6 +40,57 @@ const char* FrameTypeToString(const FrameType frame_type) { } // namespace +class BitrateAggregator { + public: + explicit BitrateAggregator(BitrateStatisticsObserver* bitrate_callback) + : callback_(bitrate_callback), + total_bitrate_observer_(*this), + retransmit_bitrate_observer_(*this), + ssrc_(0) {} + + void OnStatsUpdated() const { + if (callback_) + callback_->Notify(total_bitrate_observer_.statistics(), + retransmit_bitrate_observer_.statistics(), + ssrc_); + } + + Bitrate::Observer* total_bitrate_observer() { + return &total_bitrate_observer_; + } + Bitrate::Observer* retransmit_bitrate_observer() { + return &retransmit_bitrate_observer_; + } + + void set_ssrc(uint32_t ssrc) { ssrc_ = ssrc; } + + private: + // We assume that these observers are called on the same thread, which is + // true for RtpSender as they are called on the Process thread. + class BitrateObserver : public Bitrate::Observer { + public: + explicit BitrateObserver(const BitrateAggregator& aggregator) + : aggregator_(aggregator) {} + + // Implements Bitrate::Observer. + virtual void BitrateUpdated(const BitrateStatistics& stats) OVERRIDE { + statistics_ = stats; + aggregator_.OnStatsUpdated(); + } + + BitrateStatistics statistics() const { return statistics_; } + + private: + BitrateStatistics statistics_; + const BitrateAggregator& aggregator_; + }; + + BitrateStatisticsObserver* const callback_; + BitrateObserver total_bitrate_observer_; + BitrateObserver retransmit_bitrate_observer_; + uint32_t ssrc_; +}; + RTPSender::RTPSender(const int32_t id, const bool audio, Clock* clock, @@ -50,12 +101,18 @@ RTPSender::RTPSender(const int32_t id, FrameCountObserver* frame_count_observer, SendSideDelayObserver* send_side_delay_observer) : clock_(clock), - bitrate_sent_(clock, this), + // TODO(holmer): Remove this conversion when we remove the use of + // TickTime. + clock_delta_ms_(clock_->TimeInMilliseconds() - + TickTime::MillisecondTimestamp()), + bitrates_(new BitrateAggregator(bitrate_callback)), + total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()), id_(id), audio_configured_(audio), audio_(NULL), video_(NULL), paced_sender_(paced_sender), + last_capture_time_ms_sent_(0), send_critsect_(CriticalSectionWrapper::CreateCriticalSection()), transport_(transport), sending_media_(true), // Default to sending media. @@ -69,12 +126,11 @@ RTPSender::RTPSender(const int32_t id, // NACK. nack_byte_count_times_(), nack_byte_count_(), - nack_bitrate_(clock, NULL), + nack_bitrate_(clock, bitrates_->retransmit_bitrate_observer()), packet_history_(clock), // Statistics statistics_crit_(CriticalSectionWrapper::CreateCriticalSection()), rtp_stats_callback_(NULL), - bitrate_callback_(bitrate_callback), frame_count_observer_(frame_count_observer), send_side_delay_observer_(send_side_delay_observer), // RTP variables @@ -103,6 +159,7 @@ RTPSender::RTPSender(const int32_t id, srand(static_cast(clock_->TimeInMilliseconds())); ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. ssrc_rtx_ = ssrc_db_.CreateSSRC(); // Can't be 0. + bitrates_->set_ssrc(ssrc_); // Random start, 16 bits. Can't be 0. sequence_number_rtx_ = static_cast(rand() + 1) & 0x7FFF; sequence_number_ = static_cast(rand() + 1) & 0x7FFF; @@ -144,7 +201,7 @@ uint32_t RTPSender::GetTargetBitrate() { } uint16_t RTPSender::ActualSendBitrateKbit() const { - return (uint16_t)(bitrate_sent_.BitrateNow() / 1000); + return (uint16_t)(total_bitrate_sent_.BitrateNow() / 1000); } uint32_t RTPSender::VideoBitrateSent() const { @@ -622,15 +679,10 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, uint32_t min_resend_time) { } // Convert from TickTime to Clock since capture_time_ms is based on // TickTime. - // TODO(holmer): Remove this conversion when we remove the use of TickTime. - int64_t clock_delta_ms = clock_->TimeInMilliseconds() - - TickTime::MillisecondTimestamp(); - if (!paced_sender_->SendPacket(PacedSender::kHighPriority, - header.ssrc, - header.sequenceNumber, - capture_time_ms + clock_delta_ms, - length - header.headerLength, - true)) { + int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_; + if (!paced_sender_->SendPacket( + PacedSender::kHighPriority, header.ssrc, header.sequenceNumber, + corrected_capture_tims_ms, length - header.headerLength, true)) { // We can't send the packet right now. // We will be called when it is time. return length; @@ -819,6 +871,10 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, RtpUtility::RtpHeaderParser rtp_parser(buffer, length); RTPHeader rtp_header; rtp_parser.Parse(rtp_header); + if (!is_retransmit && rtp_header.markerBit) { + TRACE_EVENT_ASYNC_END0("webrtc_rtp", "PacedSend", capture_time_ms); + } + TRACE_EVENT_INSTANT2("webrtc_rtp", "PrepareAndSendPacket", "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber); @@ -860,7 +916,7 @@ void RTPSender::UpdateRtpStats(const uint8_t* buffer, counters = &rtp_stats_; } - bitrate_sent_.Update(size); + total_bitrate_sent_.Update(size); ++counters->packets; if (IsFecPacket(buffer, header)) { ++counters->fec_packets; @@ -937,12 +993,18 @@ int32_t RTPSender::SendToNetwork( } if (paced_sender_ && storage != kDontStore) { - int64_t clock_delta_ms = clock_->TimeInMilliseconds() - - TickTime::MillisecondTimestamp(); + // Correct offset between implementations of millisecond time stamps in + // TickTime and Clock. + int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_; if (!paced_sender_->SendPacket(priority, rtp_header.ssrc, - rtp_header.sequenceNumber, - capture_time_ms + clock_delta_ms, + rtp_header.sequenceNumber, corrected_time_ms, payload_length, false)) { + if (last_capture_time_ms_sent_ == 0 || + corrected_time_ms > last_capture_time_ms_sent_) { + last_capture_time_ms_sent_ = corrected_time_ms; + TRACE_EVENT_ASYNC_BEGIN1("webrtc_rtp", "PacedSend", corrected_time_ms, + "capture_time_ms", corrected_time_ms); + } // We can't send the packet right now. // We will be called when it is time. return 0; @@ -954,7 +1016,6 @@ int32_t RTPSender::SendToNetwork( uint32_t length = payload_length + rtp_header_length; if (!SendPacketToNetwork(buffer, length)) return -1; - assert(payload_length - rtp_header.paddingLength > 0); { CriticalSectionScoped lock(send_critsect_); media_has_been_sent_ = true; @@ -988,7 +1049,7 @@ void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { void RTPSender::ProcessBitrate() { CriticalSectionScoped cs(send_critsect_); - bitrate_sent_.Process(); + total_bitrate_sent_.Process(); nack_bitrate_.Process(); if (audio_configured_) { return; @@ -1411,6 +1472,7 @@ void RTPSender::SetSendingStatus(bool enabled) { // Generate a new SSRC. ssrc_db_.ReturnSSRC(ssrc_); ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. + bitrates_->set_ssrc(ssrc_); } // Don't initialize seq number if SSRC passed externally. if (!sequence_number_forced_ && !ssrc_forced_) { @@ -1461,6 +1523,7 @@ uint32_t RTPSender::GenerateNewSSRC() { return 0; } ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. + bitrates_->set_ssrc(ssrc_); return ssrc_; } @@ -1475,6 +1538,7 @@ void RTPSender::SetSSRC(uint32_t ssrc) { ssrc_db_.ReturnSSRC(ssrc_); ssrc_db_.RegisterSSRC(ssrc); ssrc_ = ssrc; + bitrates_->set_ssrc(ssrc_); if (!sequence_number_forced_) { sequence_number_ = rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); // NOLINT @@ -1672,17 +1736,8 @@ StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const { return rtp_stats_callback_; } -uint32_t RTPSender::BitrateSent() const { return bitrate_sent_.BitrateLast(); } - -void RTPSender::BitrateUpdated(const BitrateStatistics& stats) { - uint32_t ssrc; - { - CriticalSectionScoped ssrc_lock(send_critsect_); - ssrc = ssrc_; - } - if (bitrate_callback_) { - bitrate_callback_->Notify(stats, ssrc); - } +uint32_t RTPSender::BitrateSent() const { + return total_bitrate_sent_.BitrateLast(); } void RTPSender::SetRtpState(const RtpState& rtp_state) {