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 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
106 RTPSender::RTPSender( | 106 RTPSender::RTPSender( |
107 bool audio, | 107 bool audio, |
108 Clock* clock, | 108 Clock* clock, |
109 Transport* transport, | 109 Transport* transport, |
110 RtpPacketSender* paced_sender, | 110 RtpPacketSender* paced_sender, |
111 TransportSequenceNumberAllocator* sequence_number_allocator, | 111 TransportSequenceNumberAllocator* sequence_number_allocator, |
112 TransportFeedbackObserver* transport_feedback_observer, | 112 TransportFeedbackObserver* transport_feedback_observer, |
113 BitrateStatisticsObserver* bitrate_callback, | 113 BitrateStatisticsObserver* bitrate_callback, |
114 FrameCountObserver* frame_count_observer, | 114 FrameCountObserver* frame_count_observer, |
115 SendSideDelayObserver* send_side_delay_observer, | 115 SendSideDelayObserver* send_side_delay_observer, |
116 RtcEventLog* event_log) | 116 RtcEventLog* event_log, |
| 117 SendPacketObserver* send_packet_observer) |
117 : clock_(clock), | 118 : clock_(clock), |
118 // TODO(holmer): Remove this conversion when we remove the use of | 119 // TODO(holmer): Remove this conversion when we remove the use of |
119 // TickTime. | 120 // TickTime. |
120 clock_delta_ms_(clock_->TimeInMilliseconds() - | 121 clock_delta_ms_(clock_->TimeInMilliseconds() - |
121 TickTime::MillisecondTimestamp()), | 122 TickTime::MillisecondTimestamp()), |
122 random_(clock_->TimeInMicroseconds()), | 123 random_(clock_->TimeInMicroseconds()), |
123 bitrates_(bitrate_callback), | 124 bitrates_(bitrate_callback), |
124 total_bitrate_sent_(clock, bitrates_.total_bitrate_observer()), | 125 total_bitrate_sent_(clock, bitrates_.total_bitrate_observer()), |
125 audio_configured_(audio), | 126 audio_configured_(audio), |
126 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr), | 127 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr), |
(...skipping 16 matching lines...) Expand all Loading... |
143 // NACK. | 144 // NACK. |
144 nack_byte_count_times_(), | 145 nack_byte_count_times_(), |
145 nack_byte_count_(), | 146 nack_byte_count_(), |
146 nack_bitrate_(clock, bitrates_.retransmit_bitrate_observer()), | 147 nack_bitrate_(clock, bitrates_.retransmit_bitrate_observer()), |
147 packet_history_(clock), | 148 packet_history_(clock), |
148 // Statistics | 149 // Statistics |
149 rtp_stats_callback_(NULL), | 150 rtp_stats_callback_(NULL), |
150 frame_count_observer_(frame_count_observer), | 151 frame_count_observer_(frame_count_observer), |
151 send_side_delay_observer_(send_side_delay_observer), | 152 send_side_delay_observer_(send_side_delay_observer), |
152 event_log_(event_log), | 153 event_log_(event_log), |
| 154 send_packet_observer_(send_packet_observer), |
153 // RTP variables | 155 // RTP variables |
154 start_timestamp_forced_(false), | 156 start_timestamp_forced_(false), |
155 start_timestamp_(0), | 157 start_timestamp_(0), |
156 ssrc_db_(SSRCDatabase::GetSSRCDatabase()), | 158 ssrc_db_(SSRCDatabase::GetSSRCDatabase()), |
157 remote_ssrc_(0), | 159 remote_ssrc_(0), |
158 sequence_number_forced_(false), | 160 sequence_number_forced_(false), |
159 ssrc_forced_(false), | 161 ssrc_forced_(false), |
160 timestamp_(0), | 162 timestamp_(0), |
161 capture_time_ms_(0), | 163 capture_time_ms_(0), |
162 last_timestamp_time_ms_(0), | 164 last_timestamp_time_ms_(0), |
(...skipping 502 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
665 rtp_parser.Parse(&rtp_header); | 667 rtp_parser.Parse(&rtp_header); |
666 | 668 |
667 if (capture_time_ms > 0) { | 669 if (capture_time_ms > 0) { |
668 UpdateTransmissionTimeOffset( | 670 UpdateTransmissionTimeOffset( |
669 padding_packet, length, rtp_header, now_ms - capture_time_ms); | 671 padding_packet, length, rtp_header, now_ms - capture_time_ms); |
670 } | 672 } |
671 | 673 |
672 UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); | 674 UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); |
673 | 675 |
674 PacketOptions options; | 676 PacketOptions options; |
675 if (using_transport_seq) { | 677 if (AllocateTransportSequenceNumber(&options.packet_id)) { |
676 options.packet_id = | 678 if (UpdateTransportSequenceNumber(options.packet_id, padding_packet, |
677 UpdateTransportSequenceNumber(padding_packet, length, rtp_header); | 679 length, rtp_header)) { |
678 } | 680 if (transport_feedback_observer_) |
679 | 681 transport_feedback_observer_->AddPacket(options.packet_id, length, |
680 if (using_transport_seq && transport_feedback_observer_) { | 682 true); |
681 transport_feedback_observer_->AddPacket(options.packet_id, length, true); | 683 } |
682 } | 684 } |
683 | 685 |
684 if (!SendPacketToNetwork(padding_packet, length, options)) | 686 if (!SendPacketToNetwork(padding_packet, length, options)) |
685 break; | 687 break; |
686 | 688 |
687 bytes_sent += padding_bytes_in_packet; | 689 bytes_sent += padding_bytes_in_packet; |
688 UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); | 690 UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); |
689 } | 691 } |
690 | 692 |
691 return bytes_sent; | 693 return bytes_sent; |
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
876 | 878 |
877 if (!packet_history_.GetPacketAndSetSendTime(sequence_number, | 879 if (!packet_history_.GetPacketAndSetSendTime(sequence_number, |
878 0, | 880 0, |
879 retransmission, | 881 retransmission, |
880 data_buffer, | 882 data_buffer, |
881 &length, | 883 &length, |
882 &stored_time_ms)) { | 884 &stored_time_ms)) { |
883 // Packet cannot be found. Allow sending to continue. | 885 // Packet cannot be found. Allow sending to continue. |
884 return true; | 886 return true; |
885 } | 887 } |
886 if (!retransmission && capture_time_ms > 0) { | 888 |
887 UpdateDelayStatistics(capture_time_ms, clock_->TimeInMilliseconds()); | |
888 } | |
889 int rtx; | 889 int rtx; |
890 { | 890 { |
891 rtc::CritScope lock(&send_critsect_); | 891 rtc::CritScope lock(&send_critsect_); |
892 rtx = rtx_; | 892 rtx = rtx_; |
893 } | 893 } |
894 return PrepareAndSendPacket(data_buffer, | 894 return PrepareAndSendPacket(data_buffer, |
895 length, | 895 length, |
896 capture_time_ms, | 896 capture_time_ms, |
897 retransmission && (rtx & kRtxRetransmitted) > 0, | 897 retransmission && (rtx & kRtxRetransmitted) > 0, |
898 retransmission); | 898 retransmission); |
(...skipping 23 matching lines...) Expand all Loading... |
922 BuildRtxPacket(buffer, &length, data_buffer_rtx); | 922 BuildRtxPacket(buffer, &length, data_buffer_rtx); |
923 buffer_to_send_ptr = data_buffer_rtx; | 923 buffer_to_send_ptr = data_buffer_rtx; |
924 } | 924 } |
925 | 925 |
926 int64_t now_ms = clock_->TimeInMilliseconds(); | 926 int64_t now_ms = clock_->TimeInMilliseconds(); |
927 int64_t diff_ms = now_ms - capture_time_ms; | 927 int64_t diff_ms = now_ms - capture_time_ms; |
928 UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, | 928 UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, |
929 diff_ms); | 929 diff_ms); |
930 UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); | 930 UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); |
931 | 931 |
932 // TODO(sprang): Potentially too much overhead in IsRegistered()? | |
933 bool using_transport_seq = rtp_header_extension_map_.IsRegistered( | |
934 kRtpExtensionTransportSequenceNumber) && | |
935 transport_sequence_number_allocator_; | |
936 | |
937 PacketOptions options; | 932 PacketOptions options; |
938 if (using_transport_seq) { | 933 if (AllocateTransportSequenceNumber(&options.packet_id)) { |
939 options.packet_id = | 934 if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr, |
940 UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header); | 935 length, rtp_header)) { |
| 936 if (transport_feedback_observer_) |
| 937 transport_feedback_observer_->AddPacket(options.packet_id, length, |
| 938 true); |
| 939 } |
941 } | 940 } |
942 | 941 |
943 if (using_transport_seq && transport_feedback_observer_) { | 942 if (!is_retransmit && !send_over_rtx) { |
944 transport_feedback_observer_->AddPacket(options.packet_id, length, true); | 943 UpdateDelayStatistics(capture_time_ms, now_ms); |
| 944 UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc); |
945 } | 945 } |
946 | 946 |
947 bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options); | 947 bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options); |
948 if (ret) { | 948 if (ret) { |
949 rtc::CritScope lock(&send_critsect_); | 949 rtc::CritScope lock(&send_critsect_); |
950 media_has_been_sent_ = true; | 950 media_has_been_sent_ = true; |
951 } | 951 } |
952 UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, | 952 UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, |
953 is_retransmit); | 953 is_retransmit); |
954 return ret; | 954 return ret; |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1051 payload_length, false); | 1051 payload_length, false); |
1052 if (last_capture_time_ms_sent_ == 0 || | 1052 if (last_capture_time_ms_sent_ == 0 || |
1053 corrected_time_ms > last_capture_time_ms_sent_) { | 1053 corrected_time_ms > last_capture_time_ms_sent_) { |
1054 last_capture_time_ms_sent_ = corrected_time_ms; | 1054 last_capture_time_ms_sent_ = corrected_time_ms; |
1055 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 1055 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
1056 "PacedSend", corrected_time_ms, | 1056 "PacedSend", corrected_time_ms, |
1057 "capture_time_ms", corrected_time_ms); | 1057 "capture_time_ms", corrected_time_ms); |
1058 } | 1058 } |
1059 return 0; | 1059 return 0; |
1060 } | 1060 } |
1061 if (capture_time_ms > 0) { | |
1062 UpdateDelayStatistics(capture_time_ms, now_ms); | |
1063 } | |
1064 | |
1065 // TODO(sprang): Potentially too much overhead in IsRegistered()? | |
1066 bool using_transport_seq = rtp_header_extension_map_.IsRegistered( | |
1067 kRtpExtensionTransportSequenceNumber) && | |
1068 transport_sequence_number_allocator_; | |
1069 | 1061 |
1070 PacketOptions options; | 1062 PacketOptions options; |
1071 if (using_transport_seq) { | 1063 if (AllocateTransportSequenceNumber(&options.packet_id)) { |
1072 options.packet_id = | 1064 if (UpdateTransportSequenceNumber(options.packet_id, buffer, length, |
1073 UpdateTransportSequenceNumber(buffer, length, rtp_header); | 1065 rtp_header)) { |
1074 if (transport_feedback_observer_) { | 1066 if (transport_feedback_observer_) |
1075 transport_feedback_observer_->AddPacket(options.packet_id, length, true); | 1067 transport_feedback_observer_->AddPacket(options.packet_id, length, |
| 1068 true); |
1076 } | 1069 } |
1077 } | 1070 } |
| 1071 UpdateDelayStatistics(capture_time_ms, now_ms); |
| 1072 UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc); |
1078 | 1073 |
1079 bool sent = SendPacketToNetwork(buffer, length, options); | 1074 bool sent = SendPacketToNetwork(buffer, length, options); |
1080 | 1075 |
1081 // Mark the packet as sent in the history even if send failed. Dropping a | 1076 // Mark the packet as sent in the history even if send failed. Dropping a |
1082 // packet here should be treated as any other packet drop so we should be | 1077 // packet here should be treated as any other packet drop so we should be |
1083 // ready for a retransmission. | 1078 // ready for a retransmission. |
1084 packet_history_.SetSent(rtp_header.sequenceNumber); | 1079 packet_history_.SetSent(rtp_header.sequenceNumber); |
1085 | 1080 |
1086 if (!sent) | 1081 if (!sent) |
1087 return -1; | 1082 return -1; |
1088 | 1083 |
1089 { | 1084 { |
1090 rtc::CritScope lock(&send_critsect_); | 1085 rtc::CritScope lock(&send_critsect_); |
1091 media_has_been_sent_ = true; | 1086 media_has_been_sent_ = true; |
1092 } | 1087 } |
1093 UpdateRtpStats(buffer, length, rtp_header, false, false); | 1088 UpdateRtpStats(buffer, length, rtp_header, false, false); |
1094 return 0; | 1089 return 0; |
1095 } | 1090 } |
1096 | 1091 |
1097 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { | 1092 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { |
1098 if (!send_side_delay_observer_) | 1093 if (!send_side_delay_observer_ || capture_time_ms <= 0) |
1099 return; | 1094 return; |
1100 | 1095 |
1101 uint32_t ssrc; | 1096 uint32_t ssrc; |
1102 int avg_delay_ms = 0; | 1097 int avg_delay_ms = 0; |
1103 int max_delay_ms = 0; | 1098 int max_delay_ms = 0; |
1104 { | 1099 { |
1105 rtc::CritScope lock(&send_critsect_); | 1100 rtc::CritScope lock(&send_critsect_); |
1106 ssrc = ssrc_; | 1101 ssrc = ssrc_; |
1107 } | 1102 } |
1108 { | 1103 { |
(...skipping 11 matching lines...) Expand all Loading... |
1120 ++num_delays; | 1115 ++num_delays; |
1121 } | 1116 } |
1122 if (num_delays == 0) | 1117 if (num_delays == 0) |
1123 return; | 1118 return; |
1124 avg_delay_ms = (avg_delay_ms + num_delays / 2) / num_delays; | 1119 avg_delay_ms = (avg_delay_ms + num_delays / 2) / num_delays; |
1125 } | 1120 } |
1126 send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, | 1121 send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, |
1127 ssrc); | 1122 ssrc); |
1128 } | 1123 } |
1129 | 1124 |
| 1125 void RTPSender::UpdateOnSendPacket(int packet_id, |
| 1126 int64_t capture_time_ms, |
| 1127 uint32_t ssrc) { |
| 1128 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1) |
| 1129 return; |
| 1130 |
| 1131 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc); |
| 1132 } |
| 1133 |
1130 void RTPSender::ProcessBitrate() { | 1134 void RTPSender::ProcessBitrate() { |
1131 rtc::CritScope lock(&send_critsect_); | 1135 rtc::CritScope lock(&send_critsect_); |
1132 total_bitrate_sent_.Process(); | 1136 total_bitrate_sent_.Process(); |
1133 nack_bitrate_.Process(); | 1137 nack_bitrate_.Process(); |
1134 if (audio_configured_) { | 1138 if (audio_configured_) { |
1135 return; | 1139 return; |
1136 } | 1140 } |
1137 video_->ProcessBitrate(); | 1141 video_->ProcessBitrate(); |
1138 } | 1142 } |
1139 | 1143 |
(...skipping 463 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1603 default: | 1607 default: |
1604 RTC_NOTREACHED(); | 1608 RTC_NOTREACHED(); |
1605 } | 1609 } |
1606 | 1610 |
1607 // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit | 1611 // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit |
1608 // fractional part). | 1612 // fractional part). |
1609 ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, | 1613 ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, |
1610 ConvertMsTo24Bits(now_ms)); | 1614 ConvertMsTo24Bits(now_ms)); |
1611 } | 1615 } |
1612 | 1616 |
1613 uint16_t RTPSender::UpdateTransportSequenceNumber( | 1617 bool RTPSender::UpdateTransportSequenceNumber( |
| 1618 uint16_t sequence_number, |
1614 uint8_t* rtp_packet, | 1619 uint8_t* rtp_packet, |
1615 size_t rtp_packet_length, | 1620 size_t rtp_packet_length, |
1616 const RTPHeader& rtp_header) const { | 1621 const RTPHeader& rtp_header) const { |
1617 size_t offset; | 1622 size_t offset; |
1618 rtc::CritScope lock(&send_critsect_); | 1623 rtc::CritScope lock(&send_critsect_); |
1619 | 1624 |
1620 switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet, | 1625 switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet, |
1621 rtp_packet_length, rtp_header, | 1626 rtp_packet_length, rtp_header, |
1622 kTransportSequenceNumberLength, &offset)) { | 1627 kTransportSequenceNumberLength, &offset)) { |
1623 case ExtensionStatus::kNotRegistered: | 1628 case ExtensionStatus::kNotRegistered: |
1624 return 0; | 1629 return false; |
1625 case ExtensionStatus::kError: | 1630 case ExtensionStatus::kError: |
1626 LOG(LS_WARNING) << "Failed to update transport sequence number"; | 1631 LOG(LS_WARNING) << "Failed to update transport sequence number"; |
1627 return 0; | 1632 return false; |
1628 case ExtensionStatus::kOk: | 1633 case ExtensionStatus::kOk: |
1629 break; | 1634 break; |
1630 default: | 1635 default: |
1631 RTC_NOTREACHED(); | 1636 RTC_NOTREACHED(); |
1632 } | 1637 } |
1633 | 1638 |
1634 uint16_t seq = transport_sequence_number_allocator_->AllocateSequenceNumber(); | 1639 BuildTransportSequenceNumberExtension(rtp_packet + offset, sequence_number); |
1635 BuildTransportSequenceNumberExtension(rtp_packet + offset, seq); | 1640 return true; |
1636 return seq; | 1641 } |
| 1642 |
| 1643 bool RTPSender::AllocateTransportSequenceNumber(int* packet_id) const { |
| 1644 if (!transport_sequence_number_allocator_) |
| 1645 return false; |
| 1646 |
| 1647 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber(); |
| 1648 return true; |
1637 } | 1649 } |
1638 | 1650 |
1639 void RTPSender::SetSendingStatus(bool enabled) { | 1651 void RTPSender::SetSendingStatus(bool enabled) { |
1640 if (enabled) { | 1652 if (enabled) { |
1641 uint32_t frequency_hz = SendPayloadFrequency(); | 1653 uint32_t frequency_hz = SendPayloadFrequency(); |
1642 uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz); | 1654 uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz); |
1643 | 1655 |
1644 // Will be ignored if it's already configured via API. | 1656 // Will be ignored if it's already configured via API. |
1645 SetStartTimestamp(RTPtime, false); | 1657 SetStartTimestamp(RTPtime, false); |
1646 } else { | 1658 } else { |
(...skipping 254 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1901 rtc::CritScope lock(&send_critsect_); | 1913 rtc::CritScope lock(&send_critsect_); |
1902 | 1914 |
1903 RtpState state; | 1915 RtpState state; |
1904 state.sequence_number = sequence_number_rtx_; | 1916 state.sequence_number = sequence_number_rtx_; |
1905 state.start_timestamp = start_timestamp_; | 1917 state.start_timestamp = start_timestamp_; |
1906 | 1918 |
1907 return state; | 1919 return state; |
1908 } | 1920 } |
1909 | 1921 |
1910 } // namespace webrtc | 1922 } // namespace webrtc |
OLD | NEW |