OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
70 Transport* transport, | 70 Transport* transport, |
71 RtpPacketSender* paced_sender, | 71 RtpPacketSender* paced_sender, |
72 FlexfecSender* flexfec_sender, | 72 FlexfecSender* flexfec_sender, |
73 TransportSequenceNumberAllocator* sequence_number_allocator, | 73 TransportSequenceNumberAllocator* sequence_number_allocator, |
74 TransportFeedbackObserver* transport_feedback_observer, | 74 TransportFeedbackObserver* transport_feedback_observer, |
75 BitrateStatisticsObserver* bitrate_callback, | 75 BitrateStatisticsObserver* bitrate_callback, |
76 FrameCountObserver* frame_count_observer, | 76 FrameCountObserver* frame_count_observer, |
77 SendSideDelayObserver* send_side_delay_observer, | 77 SendSideDelayObserver* send_side_delay_observer, |
78 RtcEventLog* event_log, | 78 RtcEventLog* event_log, |
79 SendPacketObserver* send_packet_observer, | 79 SendPacketObserver* send_packet_observer, |
80 RateLimiter* retransmission_rate_limiter) | 80 RateLimiter* retransmission_rate_limiter, |
| 81 OverheadObserver* overhead_observer) |
81 : clock_(clock), | 82 : clock_(clock), |
82 // TODO(holmer): Remove this conversion? | 83 // TODO(holmer): Remove this conversion? |
83 clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()), | 84 clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()), |
84 random_(clock_->TimeInMicroseconds()), | 85 random_(clock_->TimeInMicroseconds()), |
85 audio_configured_(audio), | 86 audio_configured_(audio), |
86 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr), | 87 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr), |
87 video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)), | 88 video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)), |
88 paced_sender_(paced_sender), | 89 paced_sender_(paced_sender), |
89 transport_sequence_number_allocator_(sequence_number_allocator), | 90 transport_sequence_number_allocator_(sequence_number_allocator), |
90 transport_feedback_observer_(transport_feedback_observer), | 91 transport_feedback_observer_(transport_feedback_observer), |
(...skipping 21 matching lines...) Expand all Loading... |
112 remote_ssrc_(0), | 113 remote_ssrc_(0), |
113 sequence_number_forced_(false), | 114 sequence_number_forced_(false), |
114 ssrc_forced_(false), | 115 ssrc_forced_(false), |
115 last_rtp_timestamp_(0), | 116 last_rtp_timestamp_(0), |
116 capture_time_ms_(0), | 117 capture_time_ms_(0), |
117 last_timestamp_time_ms_(0), | 118 last_timestamp_time_ms_(0), |
118 media_has_been_sent_(false), | 119 media_has_been_sent_(false), |
119 last_packet_marker_bit_(false), | 120 last_packet_marker_bit_(false), |
120 csrcs_(), | 121 csrcs_(), |
121 rtx_(kRtxOff), | 122 rtx_(kRtxOff), |
122 retransmission_rate_limiter_(retransmission_rate_limiter) { | 123 transport_overhead_bytes_per_packet_(0), |
| 124 rtp_overhead_bytes_per_packet_(0), |
| 125 retransmission_rate_limiter_(retransmission_rate_limiter), |
| 126 overhead_observer_(overhead_observer) { |
123 ssrc_ = ssrc_db_->CreateSSRC(); | 127 ssrc_ = ssrc_db_->CreateSSRC(); |
124 RTC_DCHECK(ssrc_ != 0); | 128 RTC_DCHECK(ssrc_ != 0); |
125 ssrc_rtx_ = ssrc_db_->CreateSSRC(); | 129 ssrc_rtx_ = ssrc_db_->CreateSSRC(); |
126 RTC_DCHECK(ssrc_rtx_ != 0); | 130 RTC_DCHECK(ssrc_rtx_ != 0); |
127 | 131 |
128 // This random initialization is not intended to be cryptographic strong. | 132 // This random initialization is not intended to be cryptographic strong. |
129 timestamp_offset_ = random_.Rand<uint32_t>(); | 133 timestamp_offset_ = random_.Rand<uint32_t>(); |
130 // Random start, 16 bits. Can't be 0. | 134 // Random start, 16 bits. Can't be 0. |
131 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 135 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
132 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 136 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
(...skipping 431 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
564 padding_packet.SetTimestamp(timestamp); | 568 padding_packet.SetTimestamp(timestamp); |
565 padding_packet.SetSsrc(ssrc); | 569 padding_packet.SetSsrc(ssrc); |
566 | 570 |
567 int64_t now_ms = clock_->TimeInMilliseconds(); | 571 int64_t now_ms = clock_->TimeInMilliseconds(); |
568 | 572 |
569 if (capture_time_ms > 0) { | 573 if (capture_time_ms > 0) { |
570 padding_packet.SetExtension<TransmissionOffset>( | 574 padding_packet.SetExtension<TransmissionOffset>( |
571 kTimestampTicksPerMs * (now_ms - capture_time_ms)); | 575 kTimestampTicksPerMs * (now_ms - capture_time_ms)); |
572 } | 576 } |
573 padding_packet.SetExtension<AbsoluteSendTime>(now_ms); | 577 padding_packet.SetExtension<AbsoluteSendTime>(now_ms); |
574 | |
575 PacketOptions options; | 578 PacketOptions options; |
576 bool has_transport_seq_no = | 579 bool has_transport_seq_num = |
577 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id); | 580 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id); |
578 | |
579 padding_packet.SetPadding(padding_bytes_in_packet, &random_); | 581 padding_packet.SetPadding(padding_bytes_in_packet, &random_); |
580 | 582 |
581 if (has_transport_seq_no && transport_feedback_observer_) | 583 if (has_transport_seq_num) { |
582 transport_feedback_observer_->AddPacket( | 584 AddPacketToTransportFeedback(options.packet_id, padding_packet, |
583 options.packet_id, | 585 probe_cluster_id); |
584 padding_packet.payload_size() + padding_packet.padding_size(), | 586 } |
585 probe_cluster_id); | |
586 | 587 |
587 if (!SendPacketToNetwork(padding_packet, options)) | 588 if (!SendPacketToNetwork(padding_packet, options)) |
588 break; | 589 break; |
589 | 590 |
590 bytes_sent += padding_bytes_in_packet; | 591 bytes_sent += padding_bytes_in_packet; |
591 UpdateRtpStats(padding_packet, over_rtx, false); | 592 UpdateRtpStats(padding_packet, over_rtx, false); |
592 } | 593 } |
593 | 594 |
594 return bytes_sent; | 595 return bytes_sent; |
595 } | 596 } |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
633 if (!PrepareAndSendPacket(std::move(packet), rtx, true, | 634 if (!PrepareAndSendPacket(std::move(packet), rtx, true, |
634 PacketInfo::kNotAProbe)) | 635 PacketInfo::kNotAProbe)) |
635 return -1; | 636 return -1; |
636 return packet_size; | 637 return packet_size; |
637 } | 638 } |
638 | 639 |
639 bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet, | 640 bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet, |
640 const PacketOptions& options) { | 641 const PacketOptions& options) { |
641 int bytes_sent = -1; | 642 int bytes_sent = -1; |
642 if (transport_) { | 643 if (transport_) { |
| 644 UpdateRtpOverhead(packet); |
643 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options) | 645 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options) |
644 ? static_cast<int>(packet.size()) | 646 ? static_cast<int>(packet.size()) |
645 : -1; | 647 : -1; |
646 if (event_log_ && bytes_sent > 0) { | 648 if (event_log_ && bytes_sent > 0) { |
647 event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet.data(), | 649 event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet.data(), |
648 packet.size()); | 650 packet.size()); |
649 } | 651 } |
650 } | 652 } |
651 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 653 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
652 "RTPSender::SendPacketToNetwork", "size", packet.size(), | 654 "RTPSender::SendPacketToNetwork", "size", packet.size(), |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
748 packet_to_send = packet_rtx.get(); | 750 packet_to_send = packet_rtx.get(); |
749 } | 751 } |
750 | 752 |
751 int64_t now_ms = clock_->TimeInMilliseconds(); | 753 int64_t now_ms = clock_->TimeInMilliseconds(); |
752 int64_t diff_ms = now_ms - capture_time_ms; | 754 int64_t diff_ms = now_ms - capture_time_ms; |
753 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs * | 755 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs * |
754 diff_ms); | 756 diff_ms); |
755 packet_to_send->SetExtension<AbsoluteSendTime>(now_ms); | 757 packet_to_send->SetExtension<AbsoluteSendTime>(now_ms); |
756 | 758 |
757 PacketOptions options; | 759 PacketOptions options; |
758 if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id) && | 760 if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id)) { |
759 transport_feedback_observer_) { | 761 AddPacketToTransportFeedback(options.packet_id, *packet_to_send, |
760 transport_feedback_observer_->AddPacket( | 762 probe_cluster_id); |
761 options.packet_id, | |
762 packet_to_send->payload_size() + packet_to_send->padding_size(), | |
763 probe_cluster_id); | |
764 } | 763 } |
765 | 764 |
766 if (!is_retransmit && !send_over_rtx) { | 765 if (!is_retransmit && !send_over_rtx) { |
767 UpdateDelayStatistics(packet->capture_time_ms(), now_ms); | 766 UpdateDelayStatistics(packet->capture_time_ms(), now_ms); |
768 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), | 767 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), |
769 packet->Ssrc()); | 768 packet->Ssrc()); |
770 } | 769 } |
771 | 770 |
772 if (!SendPacketToNetwork(*packet_to_send, options)) | 771 if (!SendPacketToNetwork(*packet_to_send, options)) |
773 return false; | 772 return false; |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
882 corrected_time_ms > last_capture_time_ms_sent_) { | 881 corrected_time_ms > last_capture_time_ms_sent_) { |
883 last_capture_time_ms_sent_ = corrected_time_ms; | 882 last_capture_time_ms_sent_ = corrected_time_ms; |
884 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 883 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
885 "PacedSend", corrected_time_ms, | 884 "PacedSend", corrected_time_ms, |
886 "capture_time_ms", corrected_time_ms); | 885 "capture_time_ms", corrected_time_ms); |
887 } | 886 } |
888 return true; | 887 return true; |
889 } | 888 } |
890 | 889 |
891 PacketOptions options; | 890 PacketOptions options; |
892 if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id) && | 891 if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) { |
893 transport_feedback_observer_) { | 892 AddPacketToTransportFeedback(options.packet_id, *packet.get(), |
894 transport_feedback_observer_->AddPacket( | 893 PacketInfo::kNotAProbe); |
895 options.packet_id, packet->payload_size() + packet->padding_size(), | |
896 PacketInfo::kNotAProbe); | |
897 } | 894 } |
898 | 895 |
899 UpdateDelayStatistics(packet->capture_time_ms(), now_ms); | 896 UpdateDelayStatistics(packet->capture_time_ms(), now_ms); |
900 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), | 897 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), |
901 packet->Ssrc()); | 898 packet->Ssrc()); |
902 | 899 |
903 bool sent = SendPacketToNetwork(*packet, options); | 900 bool sent = SendPacketToNetwork(*packet, options); |
904 | 901 |
905 if (sent) { | 902 if (sent) { |
906 { | 903 { |
(...skipping 366 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1273 RtpState RTPSender::GetRtxRtpState() const { | 1270 RtpState RTPSender::GetRtxRtpState() const { |
1274 rtc::CritScope lock(&send_critsect_); | 1271 rtc::CritScope lock(&send_critsect_); |
1275 | 1272 |
1276 RtpState state; | 1273 RtpState state; |
1277 state.sequence_number = sequence_number_rtx_; | 1274 state.sequence_number = sequence_number_rtx_; |
1278 state.start_timestamp = timestamp_offset_; | 1275 state.start_timestamp = timestamp_offset_; |
1279 | 1276 |
1280 return state; | 1277 return state; |
1281 } | 1278 } |
1282 | 1279 |
| 1280 void RTPSender::SetTransportOverhead(int transport_overhead) { |
| 1281 if (!overhead_observer_) |
| 1282 return; |
| 1283 size_t overhead_bytes_per_packet = 0; |
| 1284 { |
| 1285 rtc::CritScope lock(&send_critsect_); |
| 1286 if (transport_overhead_bytes_per_packet_ == |
| 1287 static_cast<size_t>(transport_overhead)) { |
| 1288 return; |
| 1289 } |
| 1290 transport_overhead_bytes_per_packet_ = transport_overhead; |
| 1291 overhead_bytes_per_packet = |
| 1292 rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_; |
| 1293 } |
| 1294 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet); |
| 1295 } |
| 1296 |
| 1297 void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id, |
| 1298 const RtpPacketToSend& packet, |
| 1299 int probe_cluster_id) { |
| 1300 if (transport_feedback_observer_) { |
| 1301 transport_feedback_observer_->AddPacket( |
| 1302 packet_id, packet.payload_size() + packet.padding_size(), |
| 1303 probe_cluster_id); |
| 1304 } |
| 1305 } |
| 1306 |
| 1307 void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) { |
| 1308 if (!overhead_observer_) |
| 1309 return; |
| 1310 size_t overhead_bytes_per_packet = 0; |
| 1311 { |
| 1312 rtc::CritScope lock(&send_critsect_); |
| 1313 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) { |
| 1314 return; |
| 1315 } |
| 1316 rtp_overhead_bytes_per_packet_ = packet.headers_size(); |
| 1317 overhead_bytes_per_packet = |
| 1318 rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_; |
| 1319 } |
| 1320 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet); |
| 1321 } |
| 1322 |
1283 } // namespace webrtc | 1323 } // namespace webrtc |
OLD | NEW |