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 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
103 rtp_stats_callback_(nullptr), | 103 rtp_stats_callback_(nullptr), |
104 total_bitrate_sent_(kBitrateStatisticsWindowMs, | 104 total_bitrate_sent_(kBitrateStatisticsWindowMs, |
105 RateStatistics::kBpsScale), | 105 RateStatistics::kBpsScale), |
106 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale), | 106 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale), |
107 frame_count_observer_(frame_count_observer), | 107 frame_count_observer_(frame_count_observer), |
108 send_side_delay_observer_(send_side_delay_observer), | 108 send_side_delay_observer_(send_side_delay_observer), |
109 event_log_(event_log), | 109 event_log_(event_log), |
110 send_packet_observer_(send_packet_observer), | 110 send_packet_observer_(send_packet_observer), |
111 bitrate_callback_(bitrate_callback), | 111 bitrate_callback_(bitrate_callback), |
112 // RTP variables | 112 // RTP variables |
113 ssrc_db_(SSRCDatabase::GetSSRCDatabase()), | |
114 remote_ssrc_(0), | 113 remote_ssrc_(0), |
115 sequence_number_forced_(false), | 114 sequence_number_forced_(false), |
116 ssrc_forced_(false), | |
117 last_rtp_timestamp_(0), | 115 last_rtp_timestamp_(0), |
118 capture_time_ms_(0), | 116 capture_time_ms_(0), |
119 last_timestamp_time_ms_(0), | 117 last_timestamp_time_ms_(0), |
120 media_has_been_sent_(false), | 118 media_has_been_sent_(false), |
121 last_packet_marker_bit_(false), | 119 last_packet_marker_bit_(false), |
122 csrcs_(), | 120 csrcs_(), |
123 rtx_(kRtxOff), | 121 rtx_(kRtxOff), |
124 rtp_overhead_bytes_per_packet_(0), | 122 rtp_overhead_bytes_per_packet_(0), |
125 retransmission_rate_limiter_(retransmission_rate_limiter), | 123 retransmission_rate_limiter_(retransmission_rate_limiter), |
126 overhead_observer_(overhead_observer) { | 124 overhead_observer_(overhead_observer) { |
127 ssrc_ = ssrc_db_->CreateSSRC(); | |
128 RTC_DCHECK(ssrc_ != 0); | |
129 ssrc_rtx_ = ssrc_db_->CreateSSRC(); | |
130 RTC_DCHECK(ssrc_rtx_ != 0); | |
131 | |
132 // This random initialization is not intended to be cryptographic strong. | 125 // This random initialization is not intended to be cryptographic strong. |
133 timestamp_offset_ = random_.Rand<uint32_t>(); | 126 timestamp_offset_ = random_.Rand<uint32_t>(); |
134 // Random start, 16 bits. Can't be 0. | 127 // Random start, 16 bits. Can't be 0. |
135 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 128 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
136 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 129 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
137 | 130 |
138 // Store FlexFEC packets in the packet history data structure, so they can | 131 // Store FlexFEC packets in the packet history data structure, so they can |
139 // be found when paced. | 132 // be found when paced. |
140 if (flexfec_sender) { | 133 if (flexfec_sender) { |
141 flexfec_packet_history_.SetStorePacketsStatus( | 134 flexfec_packet_history_.SetStorePacketsStatus( |
142 true, kMinFlexfecPacketsToStoreForPacing); | 135 true, kMinFlexfecPacketsToStoreForPacing); |
143 } | 136 } |
144 } | 137 } |
145 | 138 |
146 RTPSender::~RTPSender() { | 139 RTPSender::~RTPSender() { |
147 // TODO(tommi): Use a thread checker to ensure the object is created and | 140 // TODO(tommi): Use a thread checker to ensure the object is created and |
148 // deleted on the same thread. At the moment this isn't possible due to | 141 // deleted on the same thread. At the moment this isn't possible due to |
149 // voe::ChannelOwner in voice engine. To reproduce, run: | 142 // voe::ChannelOwner in voice engine. To reproduce, run: |
150 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus | 143 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus |
151 | 144 |
152 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member | 145 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member |
153 // variables but we grab them in all other methods. (what's the design?) | 146 // variables but we grab them in all other methods. (what's the design?) |
154 // Start documenting what thread we're on in what method so that it's easier | 147 // Start documenting what thread we're on in what method so that it's easier |
155 // to understand performance attributes and possibly remove locks. | 148 // to understand performance attributes and possibly remove locks. |
156 if (remote_ssrc_ != 0) { | |
157 ssrc_db_->ReturnSSRC(remote_ssrc_); | |
158 } | |
159 ssrc_db_->ReturnSSRC(ssrc_); | |
160 | |
161 SSRCDatabase::ReturnSSRCDatabase(); | |
162 while (!payload_type_map_.empty()) { | 149 while (!payload_type_map_.empty()) { |
163 std::map<int8_t, RtpUtility::Payload*>::iterator it = | 150 std::map<int8_t, RtpUtility::Payload*>::iterator it = |
164 payload_type_map_.begin(); | 151 payload_type_map_.begin(); |
165 delete it->second; | 152 delete it->second; |
166 payload_type_map_.erase(it); | 153 payload_type_map_.erase(it); |
167 } | 154 } |
168 } | 155 } |
169 | 156 |
170 uint16_t RTPSender::ActualSendBitrateKbit() const { | 157 uint16_t RTPSender::ActualSendBitrateKbit() const { |
171 rtc::CritScope cs(&statistics_crit_); | 158 rtc::CritScope cs(&statistics_crit_); |
(...skipping 151 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
323 rtx_ = mode; | 310 rtx_ = mode; |
324 } | 311 } |
325 | 312 |
326 int RTPSender::RtxStatus() const { | 313 int RTPSender::RtxStatus() const { |
327 rtc::CritScope lock(&send_critsect_); | 314 rtc::CritScope lock(&send_critsect_); |
328 return rtx_; | 315 return rtx_; |
329 } | 316 } |
330 | 317 |
331 void RTPSender::SetRtxSsrc(uint32_t ssrc) { | 318 void RTPSender::SetRtxSsrc(uint32_t ssrc) { |
332 rtc::CritScope lock(&send_critsect_); | 319 rtc::CritScope lock(&send_critsect_); |
333 ssrc_rtx_ = ssrc; | 320 ssrc_rtx_ = rtc::Optional<uint32_t>(ssrc); |
danilchap
2017/02/01 12:23:55
ssrc_rtx_.emplace(ssrc); is another, shorter synta
nisse-webrtc
2017/02/01 14:00:51
Done.
| |
334 } | 321 } |
335 | 322 |
336 uint32_t RTPSender::RtxSsrc() const { | 323 uint32_t RTPSender::RtxSsrc() const { |
337 rtc::CritScope lock(&send_critsect_); | 324 rtc::CritScope lock(&send_critsect_); |
338 return ssrc_rtx_; | 325 // TODO(nisse): Is it better to crash if ssrc_rtx_ is unset? |
danilchap
2017/02/01 12:23:55
check how RtxSsrc is used. It might be better to c
nisse-webrtc
2017/02/01 14:00:51
There's a single call, in ModuleRtpRtcpImpl::SetRt
| |
326 return ssrc_rtx_.value_or(0); | |
339 } | 327 } |
340 | 328 |
341 void RTPSender::SetRtxPayloadType(int payload_type, | 329 void RTPSender::SetRtxPayloadType(int payload_type, |
342 int associated_payload_type) { | 330 int associated_payload_type) { |
343 rtc::CritScope lock(&send_critsect_); | 331 rtc::CritScope lock(&send_critsect_); |
344 RTC_DCHECK_LE(payload_type, 127); | 332 RTC_DCHECK_LE(payload_type, 127); |
345 RTC_DCHECK_LE(associated_payload_type, 127); | 333 RTC_DCHECK_LE(associated_payload_type, 127); |
346 if (payload_type < 0) { | 334 if (payload_type < 0) { |
347 LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type; | 335 LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type; |
348 return; | 336 return; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
390 size_t payload_size, | 378 size_t payload_size, |
391 const RTPFragmentationHeader* fragmentation, | 379 const RTPFragmentationHeader* fragmentation, |
392 const RTPVideoHeader* rtp_header, | 380 const RTPVideoHeader* rtp_header, |
393 uint32_t* transport_frame_id_out) { | 381 uint32_t* transport_frame_id_out) { |
394 uint32_t ssrc; | 382 uint32_t ssrc; |
395 uint16_t sequence_number; | 383 uint16_t sequence_number; |
396 uint32_t rtp_timestamp; | 384 uint32_t rtp_timestamp; |
397 { | 385 { |
398 // Drop this packet if we're not sending media packets. | 386 // Drop this packet if we're not sending media packets. |
399 rtc::CritScope lock(&send_critsect_); | 387 rtc::CritScope lock(&send_critsect_); |
400 ssrc = ssrc_; | 388 if (!ssrc_) { |
389 LOG(LS_ERROR) << "SSRC unset"; | |
390 return false; | |
391 } | |
392 | |
393 ssrc = *ssrc_; | |
401 sequence_number = sequence_number_; | 394 sequence_number = sequence_number_; |
402 rtp_timestamp = timestamp_offset_ + capture_timestamp; | 395 rtp_timestamp = timestamp_offset_ + capture_timestamp; |
403 if (transport_frame_id_out) | 396 if (transport_frame_id_out) |
404 *transport_frame_id_out = rtp_timestamp; | 397 *transport_frame_id_out = rtp_timestamp; |
405 if (!sending_media_) | 398 if (!sending_media_) |
406 return true; | 399 return true; |
407 } | 400 } |
408 RtpVideoCodecTypes video_type = kRtpVideoGeneric; | 401 RtpVideoCodecTypes video_type = kRtpVideoGeneric; |
409 if (CheckPayloadType(payload_type, &video_type) != 0) { | 402 if (CheckPayloadType(payload_type, &video_type) != 0) { |
410 LOG(LS_ERROR) << "Don't send data with unknown payload type: " | 403 LOG(LS_ERROR) << "Don't send data with unknown payload type: " |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
495 { | 488 { |
496 rtc::CritScope lock(&send_critsect_); | 489 rtc::CritScope lock(&send_critsect_); |
497 if (!sending_media_) | 490 if (!sending_media_) |
498 break; | 491 break; |
499 timestamp = last_rtp_timestamp_; | 492 timestamp = last_rtp_timestamp_; |
500 capture_time_ms = capture_time_ms_; | 493 capture_time_ms = capture_time_ms_; |
501 if (rtx_ == kRtxOff) { | 494 if (rtx_ == kRtxOff) { |
502 // Without RTX we can't send padding in the middle of frames. | 495 // Without RTX we can't send padding in the middle of frames. |
503 if (!last_packet_marker_bit_) | 496 if (!last_packet_marker_bit_) |
504 break; | 497 break; |
505 ssrc = ssrc_; | 498 if (!ssrc_) { |
499 LOG(LS_ERROR) << "SSRC unset"; | |
500 return 0; | |
501 } | |
502 | |
503 ssrc = *ssrc_; | |
504 | |
506 sequence_number = sequence_number_; | 505 sequence_number = sequence_number_; |
507 ++sequence_number_; | 506 ++sequence_number_; |
508 payload_type = payload_type_; | 507 payload_type = payload_type_; |
509 over_rtx = false; | 508 over_rtx = false; |
510 } else { | 509 } else { |
511 // Without abs-send-time or transport sequence number a media packet | 510 // Without abs-send-time or transport sequence number a media packet |
512 // must be sent before padding so that the timestamps used for | 511 // must be sent before padding so that the timestamps used for |
513 // estimation are correct. | 512 // estimation are correct. |
514 if (!media_has_been_sent_ && | 513 if (!media_has_been_sent_ && |
515 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) || | 514 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) || |
516 (rtp_header_extension_map_.IsRegistered( | 515 (rtp_header_extension_map_.IsRegistered( |
517 TransportSequenceNumber::kId) && | 516 TransportSequenceNumber::kId) && |
518 transport_sequence_number_allocator_))) { | 517 transport_sequence_number_allocator_))) { |
519 break; | 518 break; |
520 } | 519 } |
521 // Only change change the timestamp of padding packets sent over RTX. | 520 // Only change change the timestamp of padding packets sent over RTX. |
522 // Padding only packets over RTP has to be sent as part of a media | 521 // Padding only packets over RTP has to be sent as part of a media |
523 // frame (and therefore the same timestamp). | 522 // frame (and therefore the same timestamp). |
524 if (last_timestamp_time_ms_ > 0) { | 523 if (last_timestamp_time_ms_ > 0) { |
525 timestamp += | 524 timestamp += |
526 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs; | 525 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs; |
527 capture_time_ms += (now_ms - last_timestamp_time_ms_); | 526 capture_time_ms += (now_ms - last_timestamp_time_ms_); |
528 } | 527 } |
529 ssrc = ssrc_rtx_; | 528 if (!ssrc_rtx_) { |
529 LOG(LS_ERROR) << "RTX SSRC unset"; | |
530 return 0; | |
531 } | |
532 ssrc = *ssrc_rtx_; | |
530 sequence_number = sequence_number_rtx_; | 533 sequence_number = sequence_number_rtx_; |
531 ++sequence_number_rtx_; | 534 ++sequence_number_rtx_; |
532 payload_type = rtx_payload_type_map_.begin()->second; | 535 payload_type = rtx_payload_type_map_.begin()->second; |
533 over_rtx = true; | 536 over_rtx = true; |
534 } | 537 } |
535 } | 538 } |
536 | 539 |
537 RtpPacketToSend padding_packet(&rtp_header_extension_map_); | 540 RtpPacketToSend padding_packet(&rtp_header_extension_map_); |
538 padding_packet.SetPayloadType(payload_type); | 541 padding_packet.SetPayloadType(payload_type); |
539 padding_packet.SetMarker(false); | 542 padding_packet.SetMarker(false); |
(...skipping 353 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
893 | 896 |
894 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { | 897 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { |
895 if (!send_side_delay_observer_ || capture_time_ms <= 0) | 898 if (!send_side_delay_observer_ || capture_time_ms <= 0) |
896 return; | 899 return; |
897 | 900 |
898 uint32_t ssrc; | 901 uint32_t ssrc; |
899 int avg_delay_ms = 0; | 902 int avg_delay_ms = 0; |
900 int max_delay_ms = 0; | 903 int max_delay_ms = 0; |
901 { | 904 { |
902 rtc::CritScope lock(&send_critsect_); | 905 rtc::CritScope lock(&send_critsect_); |
903 ssrc = ssrc_; | 906 if (!ssrc_) |
907 return; | |
908 ssrc = *ssrc_; | |
904 } | 909 } |
905 { | 910 { |
906 rtc::CritScope cs(&statistics_crit_); | 911 rtc::CritScope cs(&statistics_crit_); |
907 // TODO(holmer): Compute this iteratively instead. | 912 // TODO(holmer): Compute this iteratively instead. |
908 send_delays_[now_ms] = now_ms - capture_time_ms; | 913 send_delays_[now_ms] = now_ms - capture_time_ms; |
909 send_delays_.erase(send_delays_.begin(), | 914 send_delays_.erase(send_delays_.begin(), |
910 send_delays_.lower_bound(now_ms - | 915 send_delays_.lower_bound(now_ms - |
911 kSendSideDelayWindowMs)); | 916 kSendSideDelayWindowMs)); |
912 int num_delays = 0; | 917 int num_delays = 0; |
913 for (auto it = send_delays_.upper_bound(now_ms - kSendSideDelayWindowMs); | 918 for (auto it = send_delays_.upper_bound(now_ms - kSendSideDelayWindowMs); |
(...skipping 19 matching lines...) Expand all Loading... | |
933 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc); | 938 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc); |
934 } | 939 } |
935 | 940 |
936 void RTPSender::ProcessBitrate() { | 941 void RTPSender::ProcessBitrate() { |
937 if (!bitrate_callback_) | 942 if (!bitrate_callback_) |
938 return; | 943 return; |
939 int64_t now_ms = clock_->TimeInMilliseconds(); | 944 int64_t now_ms = clock_->TimeInMilliseconds(); |
940 uint32_t ssrc; | 945 uint32_t ssrc; |
941 { | 946 { |
942 rtc::CritScope lock(&send_critsect_); | 947 rtc::CritScope lock(&send_critsect_); |
943 ssrc = ssrc_; | 948 if (!ssrc_) |
949 return; | |
950 ssrc = *ssrc_; | |
944 } | 951 } |
945 | 952 |
946 rtc::CritScope lock(&statistics_crit_); | 953 rtc::CritScope lock(&statistics_crit_); |
947 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0), | 954 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0), |
948 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc); | 955 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc); |
949 } | 956 } |
950 | 957 |
951 size_t RTPSender::RtpHeaderLength() const { | 958 size_t RTPSender::RtpHeaderLength() const { |
952 rtc::CritScope lock(&send_critsect_); | 959 rtc::CritScope lock(&send_critsect_); |
953 size_t rtp_header_length = kRtpHeaderLength; | 960 size_t rtp_header_length = kRtpHeaderLength; |
(...skipping 13 matching lines...) Expand all Loading... | |
967 StreamDataCounters* rtx_stats) const { | 974 StreamDataCounters* rtx_stats) const { |
968 rtc::CritScope lock(&statistics_crit_); | 975 rtc::CritScope lock(&statistics_crit_); |
969 *rtp_stats = rtp_stats_; | 976 *rtp_stats = rtp_stats_; |
970 *rtx_stats = rtx_rtp_stats_; | 977 *rtx_stats = rtx_rtp_stats_; |
971 } | 978 } |
972 | 979 |
973 std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const { | 980 std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const { |
974 rtc::CritScope lock(&send_critsect_); | 981 rtc::CritScope lock(&send_critsect_); |
975 std::unique_ptr<RtpPacketToSend> packet( | 982 std::unique_ptr<RtpPacketToSend> packet( |
976 new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_)); | 983 new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_)); |
977 packet->SetSsrc(ssrc_); | 984 RTC_DCHECK(ssrc_); |
985 packet->SetSsrc(ssrc_.value_or(0)); | |
danilchap
2017/02/01 12:23:55
there is a DCHECK just above, do not try to recove
nisse-webrtc
2017/02/01 14:00:51
Done.
| |
978 packet->SetCsrcs(csrcs_); | 986 packet->SetCsrcs(csrcs_); |
979 // Reserve extensions, if registered, RtpSender set in SendToNetwork. | 987 // Reserve extensions, if registered, RtpSender set in SendToNetwork. |
980 packet->ReserveExtension<AbsoluteSendTime>(); | 988 packet->ReserveExtension<AbsoluteSendTime>(); |
981 packet->ReserveExtension<TransmissionOffset>(); | 989 packet->ReserveExtension<TransmissionOffset>(); |
982 packet->ReserveExtension<TransportSequenceNumber>(); | 990 packet->ReserveExtension<TransportSequenceNumber>(); |
983 if (playout_delay_oracle_.send_playout_delay()) { | 991 if (playout_delay_oracle_.send_playout_delay()) { |
984 packet->SetExtension<PlayoutDelayLimits>( | 992 packet->SetExtension<PlayoutDelayLimits>( |
985 playout_delay_oracle_.playout_delay()); | 993 playout_delay_oracle_.playout_delay()); |
986 } | 994 } |
987 return packet; | 995 return packet; |
988 } | 996 } |
989 | 997 |
990 bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) { | 998 bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) { |
991 rtc::CritScope lock(&send_critsect_); | 999 rtc::CritScope lock(&send_critsect_); |
992 if (!sending_media_) | 1000 if (!sending_media_) |
993 return false; | 1001 return false; |
994 RTC_DCHECK_EQ(packet->Ssrc(), ssrc_); | 1002 if (!ssrc_) |
1003 return false; | |
1004 RTC_DCHECK_EQ(packet->Ssrc(), *ssrc_); | |
danilchap
2017/02/01 12:23:55
RTC_DCHECK_EQ(packet->Ssrc(), ssrc_)
should work.
nisse-webrtc
2017/02/01 14:00:51
Comparing with RTC_DCHECK_EQ fails. But RTC_DCHECK
| |
995 packet->SetSequenceNumber(sequence_number_++); | 1005 packet->SetSequenceNumber(sequence_number_++); |
996 | 1006 |
997 // Remember marker bit to determine if padding can be inserted with | 1007 // Remember marker bit to determine if padding can be inserted with |
998 // sequence number following |packet|. | 1008 // sequence number following |packet|. |
999 last_packet_marker_bit_ = packet->Marker(); | 1009 last_packet_marker_bit_ = packet->Marker(); |
1000 // Save timestamps to generate timestamp field and extensions for the padding. | 1010 // Save timestamps to generate timestamp field and extensions for the padding. |
1001 last_rtp_timestamp_ = packet->Timestamp(); | 1011 last_rtp_timestamp_ = packet->Timestamp(); |
1002 last_timestamp_time_ms_ = clock_->TimeInMilliseconds(); | 1012 last_timestamp_time_ms_ = clock_->TimeInMilliseconds(); |
1003 capture_time_ms_ = packet->capture_time_ms(); | 1013 capture_time_ms_ = packet->capture_time_ms(); |
1004 return true; | 1014 return true; |
(...skipping 11 matching lines...) Expand all Loading... | |
1016 return false; | 1026 return false; |
1017 | 1027 |
1018 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber(); | 1028 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber(); |
1019 | 1029 |
1020 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id)) | 1030 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id)) |
1021 return false; | 1031 return false; |
1022 | 1032 |
1023 return true; | 1033 return true; |
1024 } | 1034 } |
1025 | 1035 |
1026 void RTPSender::SetSendingStatus(bool enabled) { | |
1027 if (!enabled) { | |
1028 rtc::CritScope lock(&send_critsect_); | |
1029 if (!ssrc_forced_) { | |
1030 // Generate a new SSRC. | |
1031 ssrc_db_->ReturnSSRC(ssrc_); | |
1032 ssrc_ = ssrc_db_->CreateSSRC(); | |
1033 RTC_DCHECK(ssrc_ != 0); | |
1034 } | |
1035 // Don't initialize seq number if SSRC passed externally. | |
1036 if (!sequence_number_forced_ && !ssrc_forced_) { | |
1037 // Generate a new sequence number. | |
1038 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); | |
1039 } | |
1040 } | |
1041 } | |
1042 | |
1043 void RTPSender::SetSendingMediaStatus(bool enabled) { | 1036 void RTPSender::SetSendingMediaStatus(bool enabled) { |
1044 rtc::CritScope lock(&send_critsect_); | 1037 rtc::CritScope lock(&send_critsect_); |
1045 sending_media_ = enabled; | 1038 sending_media_ = enabled; |
1046 } | 1039 } |
1047 | 1040 |
1048 bool RTPSender::SendingMedia() const { | 1041 bool RTPSender::SendingMedia() const { |
1049 rtc::CritScope lock(&send_critsect_); | 1042 rtc::CritScope lock(&send_critsect_); |
1050 return sending_media_; | 1043 return sending_media_; |
1051 } | 1044 } |
1052 | 1045 |
1053 void RTPSender::SetTimestampOffset(uint32_t timestamp) { | 1046 void RTPSender::SetTimestampOffset(uint32_t timestamp) { |
1054 rtc::CritScope lock(&send_critsect_); | 1047 rtc::CritScope lock(&send_critsect_); |
1055 timestamp_offset_ = timestamp; | 1048 timestamp_offset_ = timestamp; |
1056 } | 1049 } |
1057 | 1050 |
1058 uint32_t RTPSender::TimestampOffset() const { | 1051 uint32_t RTPSender::TimestampOffset() const { |
1059 rtc::CritScope lock(&send_critsect_); | 1052 rtc::CritScope lock(&send_critsect_); |
1060 return timestamp_offset_; | 1053 return timestamp_offset_; |
1061 } | 1054 } |
1062 | 1055 |
1063 uint32_t RTPSender::GenerateNewSSRC() { | |
1064 // If configured via API, return 0. | |
1065 rtc::CritScope lock(&send_critsect_); | |
1066 | |
1067 if (ssrc_forced_) { | |
1068 return 0; | |
1069 } | |
1070 ssrc_ = ssrc_db_->CreateSSRC(); | |
1071 RTC_DCHECK(ssrc_ != 0); | |
1072 return ssrc_; | |
1073 } | |
1074 | |
1075 void RTPSender::SetSSRC(uint32_t ssrc) { | 1056 void RTPSender::SetSSRC(uint32_t ssrc) { |
1076 // This is configured via the API. | 1057 // This is configured via the API. |
1077 rtc::CritScope lock(&send_critsect_); | 1058 rtc::CritScope lock(&send_critsect_); |
1078 | 1059 |
1079 if (ssrc_ == ssrc && ssrc_forced_) { | 1060 if (ssrc_ && *ssrc_== ssrc) { |
danilchap
2017/02/01 12:23:56
if (ssrc_ == ssrc)
(it is legal to compare optiona
nisse-webrtc
2017/02/01 14:00:51
Done, I didn't know that was allowed.
| |
1080 return; // Since it's same ssrc, don't reset anything. | 1061 return; // Since it's same ssrc, don't reset anything. |
1081 } | 1062 } |
1082 ssrc_forced_ = true; | 1063 ssrc_ = rtc::Optional<uint32_t>(ssrc); |
danilchap
2017/02/01 12:23:55
ssrc_.emplace(ssrc)
nisse-webrtc
2017/02/01 14:00:51
Done.
| |
1083 ssrc_db_->ReturnSSRC(ssrc_); | |
1084 ssrc_db_->RegisterSSRC(ssrc); | |
1085 ssrc_ = ssrc; | |
1086 if (!sequence_number_forced_) { | 1064 if (!sequence_number_forced_) { |
1087 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 1065 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
1088 } | 1066 } |
1089 } | 1067 } |
1090 | 1068 |
1091 uint32_t RTPSender::SSRC() const { | 1069 uint32_t RTPSender::SSRC() const { |
1092 rtc::CritScope lock(&send_critsect_); | 1070 rtc::CritScope lock(&send_critsect_); |
1093 return ssrc_; | 1071 // TODO(nisse): Is it better to crash if ssrc_ is unset? |
danilchap
2017/02/01 12:23:55
likely better to crash than return unusable value.
nisse-webrtc
2017/02/01 14:00:51
Done.
| |
1072 return ssrc_.value_or(0); | |
1094 } | 1073 } |
1095 | 1074 |
1096 rtc::Optional<uint32_t> RTPSender::FlexfecSsrc() const { | 1075 rtc::Optional<uint32_t> RTPSender::FlexfecSsrc() const { |
1097 if (video_) { | 1076 if (video_) { |
1098 return video_->FlexfecSsrc(); | 1077 return video_->FlexfecSsrc(); |
1099 } | 1078 } |
1100 return rtc::Optional<uint32_t>(); | 1079 return rtc::Optional<uint32_t>(); |
1101 } | 1080 } |
1102 | 1081 |
1103 void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { | 1082 void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1162 // TODO(danilchap): Create rtx packet with extra capacity for SRTP | 1141 // TODO(danilchap): Create rtx packet with extra capacity for SRTP |
1163 // when transport interface would be updated to take buffer class. | 1142 // when transport interface would be updated to take buffer class. |
1164 std::unique_ptr<RtpPacketToSend> rtx_packet(new RtpPacketToSend( | 1143 std::unique_ptr<RtpPacketToSend> rtx_packet(new RtpPacketToSend( |
1165 &rtp_header_extension_map_, packet.size() + kRtxHeaderSize)); | 1144 &rtp_header_extension_map_, packet.size() + kRtxHeaderSize)); |
1166 // Add original RTP header. | 1145 // Add original RTP header. |
1167 rtx_packet->CopyHeaderFrom(packet); | 1146 rtx_packet->CopyHeaderFrom(packet); |
1168 { | 1147 { |
1169 rtc::CritScope lock(&send_critsect_); | 1148 rtc::CritScope lock(&send_critsect_); |
1170 if (!sending_media_) | 1149 if (!sending_media_) |
1171 return nullptr; | 1150 return nullptr; |
1172 | 1151 if (!ssrc_rtx_) |
danilchap
2017/02/01 12:23:55
feel free to DCHECK: no point to try to build rtx
nisse-webrtc
2017/02/01 14:00:51
Done.
| |
1152 return nullptr; | |
1173 // Replace payload type. | 1153 // Replace payload type. |
1174 auto kv = rtx_payload_type_map_.find(packet.PayloadType()); | 1154 auto kv = rtx_payload_type_map_.find(packet.PayloadType()); |
1175 if (kv == rtx_payload_type_map_.end()) | 1155 if (kv == rtx_payload_type_map_.end()) |
1176 return nullptr; | 1156 return nullptr; |
1177 rtx_packet->SetPayloadType(kv->second); | 1157 rtx_packet->SetPayloadType(kv->second); |
1178 | 1158 |
1179 // Replace sequence number. | 1159 // Replace sequence number. |
1180 rtx_packet->SetSequenceNumber(sequence_number_rtx_++); | 1160 rtx_packet->SetSequenceNumber(sequence_number_rtx_++); |
1181 | 1161 |
1182 // Replace SSRC. | 1162 // Replace SSRC. |
1183 rtx_packet->SetSsrc(ssrc_rtx_); | 1163 rtx_packet->SetSsrc(*ssrc_rtx_); |
1184 } | 1164 } |
1185 | 1165 |
1186 uint8_t* rtx_payload = | 1166 uint8_t* rtx_payload = |
1187 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize); | 1167 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize); |
1188 RTC_DCHECK(rtx_payload); | 1168 RTC_DCHECK(rtx_payload); |
1189 // Add OSN (original sequence number). | 1169 // Add OSN (original sequence number). |
1190 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber()); | 1170 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber()); |
1191 | 1171 |
1192 // Add original payload data. | 1172 // Add original payload data. |
1193 auto payload = packet.payload(); | 1173 auto payload = packet.payload(); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1276 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) { | 1256 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) { |
1277 return; | 1257 return; |
1278 } | 1258 } |
1279 rtp_overhead_bytes_per_packet_ = packet.headers_size(); | 1259 rtp_overhead_bytes_per_packet_ = packet.headers_size(); |
1280 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_; | 1260 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_; |
1281 } | 1261 } |
1282 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet); | 1262 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet); |
1283 } | 1263 } |
1284 | 1264 |
1285 } // namespace webrtc | 1265 } // namespace webrtc |
OLD | NEW |