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 |
11 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" | 11 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" |
12 | 12 |
13 #include <stdlib.h> // srand | |
14 #include <algorithm> | 13 #include <algorithm> |
15 #include <utility> | 14 #include <utility> |
16 | 15 |
17 #include "webrtc/base/checks.h" | 16 #include "webrtc/base/checks.h" |
18 #include "webrtc/base/logging.h" | 17 #include "webrtc/base/logging.h" |
19 #include "webrtc/base/rate_limiter.h" | 18 #include "webrtc/base/rate_limiter.h" |
20 #include "webrtc/base/trace_event.h" | 19 #include "webrtc/base/trace_event.h" |
21 #include "webrtc/base/timeutils.h" | 20 #include "webrtc/base/timeutils.h" |
22 #include "webrtc/call.h" | 21 #include "webrtc/call.h" |
23 #include "webrtc/call/rtc_event_log.h" | 22 #include "webrtc/call/rtc_event_log.h" |
24 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" | 23 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" |
25 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 24 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
26 #include "webrtc/modules/rtp_rtcp/source/playout_delay_oracle.h" | 25 #include "webrtc/modules/rtp_rtcp/source/playout_delay_oracle.h" |
| 26 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" |
| 27 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
27 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h" | 28 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h" |
28 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" | 29 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" |
29 #include "webrtc/modules/rtp_rtcp/source/time_util.h" | 30 #include "webrtc/modules/rtp_rtcp/source/time_util.h" |
30 | 31 |
31 namespace webrtc { | 32 namespace webrtc { |
32 | 33 |
| 34 namespace { |
33 // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP. | 35 // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP. |
34 static const size_t kMaxPaddingLength = 224; | 36 constexpr size_t kMaxPaddingLength = 224; |
35 static const int kSendSideDelayWindowMs = 1000; | 37 constexpr int kSendSideDelayWindowMs = 1000; |
36 static const uint32_t kAbsSendTimeFraction = 18; | 38 constexpr size_t kRtpHeaderLength = 12; |
37 static const int kBitrateStatisticsWindowMs = 1000; | 39 constexpr uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1. |
38 | 40 constexpr uint32_t kTimestampTicksPerMs = 90; |
39 namespace { | 41 constexpr int kBitrateStatisticsWindowMs = 1000; |
40 | |
41 const size_t kRtpHeaderLength = 12; | |
42 const uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1. | |
43 | 42 |
44 const char* FrameTypeToString(FrameType frame_type) { | 43 const char* FrameTypeToString(FrameType frame_type) { |
45 switch (frame_type) { | 44 switch (frame_type) { |
46 case kEmptyFrame: | 45 case kEmptyFrame: |
47 return "empty"; | 46 return "empty"; |
48 case kAudioFrameSpeech: return "audio_speech"; | 47 case kAudioFrameSpeech: return "audio_speech"; |
49 case kAudioFrameCN: return "audio_cn"; | 48 case kAudioFrameCN: return "audio_cn"; |
50 case kVideoFrameKey: return "video_key"; | 49 case kVideoFrameKey: return "video_key"; |
51 case kVideoFrameDelta: return "video_delta"; | 50 case kVideoFrameDelta: return "video_delta"; |
52 } | 51 } |
53 return ""; | 52 return ""; |
54 } | 53 } |
55 | 54 |
56 // TODO(holmer): Merge this with the implementation in | 55 void CountPacket(RtpPacketCounter* counter, const RtpPacketToSend& packet) { |
57 // remote_bitrate_estimator_abs_send_time.cc. | 56 ++counter->packets; |
58 uint32_t ConvertMsTo24Bits(int64_t time_ms) { | 57 counter->header_bytes += packet.headers_size(); |
59 uint32_t time_24_bits = | 58 counter->padding_bytes += packet.padding_size(); |
60 static_cast<uint32_t>( | 59 counter->payload_bytes += packet.payload_size(); |
61 ((static_cast<uint64_t>(time_ms) << kAbsSendTimeFraction) + 500) / | |
62 1000) & | |
63 0x00FFFFFF; | |
64 return time_24_bits; | |
65 } | 60 } |
| 61 |
66 } // namespace | 62 } // namespace |
67 | 63 |
68 RTPSender::RTPSender( | 64 RTPSender::RTPSender( |
69 bool audio, | 65 bool audio, |
70 Clock* clock, | 66 Clock* clock, |
71 Transport* transport, | 67 Transport* transport, |
72 RtpPacketSender* paced_sender, | 68 RtpPacketSender* paced_sender, |
73 TransportSequenceNumberAllocator* sequence_number_allocator, | 69 TransportSequenceNumberAllocator* sequence_number_allocator, |
74 TransportFeedbackObserver* transport_feedback_observer, | 70 TransportFeedbackObserver* transport_feedback_observer, |
75 BitrateStatisticsObserver* bitrate_callback, | 71 BitrateStatisticsObserver* bitrate_callback, |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
120 sequence_number_forced_(false), | 116 sequence_number_forced_(false), |
121 ssrc_forced_(false), | 117 ssrc_forced_(false), |
122 timestamp_(0), | 118 timestamp_(0), |
123 capture_time_ms_(0), | 119 capture_time_ms_(0), |
124 last_timestamp_time_ms_(0), | 120 last_timestamp_time_ms_(0), |
125 media_has_been_sent_(false), | 121 media_has_been_sent_(false), |
126 last_packet_marker_bit_(false), | 122 last_packet_marker_bit_(false), |
127 csrcs_(), | 123 csrcs_(), |
128 rtx_(kRtxOff), | 124 rtx_(kRtxOff), |
129 retransmission_rate_limiter_(retransmission_rate_limiter) { | 125 retransmission_rate_limiter_(retransmission_rate_limiter) { |
130 // We need to seed the random generator for BuildPaddingPacket() below. | |
131 // TODO(holmer,tommi): Note that TimeInMilliseconds might return 0 on Mac | |
132 // early on in the process. | |
133 srand(static_cast<uint32_t>(clock_->TimeInMilliseconds())); | |
134 ssrc_ = ssrc_db_->CreateSSRC(); | 126 ssrc_ = ssrc_db_->CreateSSRC(); |
135 RTC_DCHECK(ssrc_ != 0); | 127 RTC_DCHECK(ssrc_ != 0); |
136 ssrc_rtx_ = ssrc_db_->CreateSSRC(); | 128 ssrc_rtx_ = ssrc_db_->CreateSSRC(); |
137 RTC_DCHECK(ssrc_rtx_ != 0); | 129 RTC_DCHECK(ssrc_rtx_ != 0); |
138 | 130 |
139 // Random start, 16 bits. Can't be 0. | 131 // Random start, 16 bits. Can't be 0. |
140 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 132 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
141 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); | 133 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
142 } | 134 } |
143 | 135 |
(...skipping 195 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
339 | 331 |
340 void RTPSender::SetMaxPayloadLength(size_t max_payload_length) { | 332 void RTPSender::SetMaxPayloadLength(size_t max_payload_length) { |
341 // Sanity check. | 333 // Sanity check. |
342 RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE) | 334 RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE) |
343 << "Invalid max payload length: " << max_payload_length; | 335 << "Invalid max payload length: " << max_payload_length; |
344 rtc::CritScope lock(&send_critsect_); | 336 rtc::CritScope lock(&send_critsect_); |
345 max_payload_length_ = max_payload_length; | 337 max_payload_length_ = max_payload_length; |
346 } | 338 } |
347 | 339 |
348 size_t RTPSender::MaxDataPayloadLength() const { | 340 size_t RTPSender::MaxDataPayloadLength() const { |
349 int rtx; | |
350 { | |
351 rtc::CritScope lock(&send_critsect_); | |
352 rtx = rtx_; | |
353 } | |
354 if (audio_configured_) { | 341 if (audio_configured_) { |
355 return max_payload_length_ - RtpHeaderLength(); | 342 return max_payload_length_ - RtpHeaderLength(); |
356 } else { | 343 } else { |
357 return max_payload_length_ - RtpHeaderLength() // RTP overhead. | 344 return max_payload_length_ - RtpHeaderLength() // RTP overhead. |
358 - video_->FECPacketOverhead() // FEC/ULP/RED overhead. | 345 - video_->FECPacketOverhead() // FEC/ULP/RED overhead. |
359 - ((rtx) ? 2 : 0); // RTX overhead. | 346 - (RtxStatus() ? kRtxHeaderSize : 0); // RTX overhead. |
360 } | 347 } |
361 } | 348 } |
362 | 349 |
363 size_t RTPSender::MaxPayloadLength() const { | 350 size_t RTPSender::MaxPayloadLength() const { |
364 return max_payload_length_; | 351 return max_payload_length_; |
365 } | 352 } |
366 | 353 |
367 void RTPSender::SetRtxStatus(int mode) { | 354 void RTPSender::SetRtxStatus(int mode) { |
368 rtc::CritScope lock(&send_critsect_); | 355 rtc::CritScope lock(&send_critsect_); |
369 rtx_ = mode; | 356 rtx_ = mode; |
(...skipping 166 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
536 size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send, | 523 size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send, |
537 int probe_cluster_id) { | 524 int probe_cluster_id) { |
538 { | 525 { |
539 rtc::CritScope lock(&send_critsect_); | 526 rtc::CritScope lock(&send_critsect_); |
540 if (!sending_media_) | 527 if (!sending_media_) |
541 return 0; | 528 return 0; |
542 if ((rtx_ & kRtxRedundantPayloads) == 0) | 529 if ((rtx_ & kRtxRedundantPayloads) == 0) |
543 return 0; | 530 return 0; |
544 } | 531 } |
545 | 532 |
546 uint8_t buffer[IP_PACKET_SIZE]; | |
547 int bytes_left = static_cast<int>(bytes_to_send); | 533 int bytes_left = static_cast<int>(bytes_to_send); |
548 while (bytes_left > 0) { | 534 while (bytes_left > 0) { |
549 size_t length = bytes_left; | 535 std::unique_ptr<RtpPacketToSend> packet = |
550 int64_t capture_time_ms; | 536 packet_history_.GetBestFittingPacket(bytes_left); |
551 if (!packet_history_.GetBestFittingPacket(buffer, &length, | 537 if (!packet) |
552 &capture_time_ms)) { | |
553 break; | 538 break; |
554 } | 539 size_t payload_size = packet->payload_size(); |
555 if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false, | 540 if (!PrepareAndSendPacket(std::move(packet), true, false, probe_cluster_id)) |
556 probe_cluster_id)) | |
557 break; | 541 break; |
558 RtpUtility::RtpHeaderParser rtp_parser(buffer, length); | 542 bytes_left -= payload_size; |
559 RTPHeader rtp_header; | |
560 rtp_parser.Parse(&rtp_header); | |
561 bytes_left -= static_cast<int>(length - rtp_header.headerLength); | |
562 } | 543 } |
563 return bytes_to_send - bytes_left; | 544 return bytes_to_send - bytes_left; |
564 } | 545 } |
565 | 546 |
566 void RTPSender::BuildPaddingPacket(uint8_t* packet, | |
567 size_t header_length, | |
568 size_t padding_length) { | |
569 packet[0] |= 0x20; // Set padding bit. | |
570 int32_t* data = reinterpret_cast<int32_t*>(&(packet[header_length])); | |
571 | |
572 // Fill data buffer with random data. | |
573 for (size_t j = 0; j < (padding_length >> 2); ++j) { | |
574 data[j] = rand(); // NOLINT | |
575 } | |
576 // Set number of padding bytes in the last byte of the packet. | |
577 packet[header_length + padding_length - 1] = | |
578 static_cast<uint8_t>(padding_length); | |
579 } | |
580 | |
581 size_t RTPSender::SendPadData(size_t bytes, | 547 size_t RTPSender::SendPadData(size_t bytes, |
582 bool timestamp_provided, | 548 bool timestamp_provided, |
583 uint32_t timestamp, | 549 uint32_t timestamp, |
584 int64_t capture_time_ms) { | 550 int64_t capture_time_ms) { |
585 return SendPadData(bytes, timestamp_provided, timestamp, capture_time_ms, | 551 return SendPadData(bytes, timestamp_provided, timestamp, capture_time_ms, |
586 PacketInfo::kNotAProbe); | 552 PacketInfo::kNotAProbe); |
587 } | 553 } |
588 | 554 |
589 size_t RTPSender::SendPadData(size_t bytes, | 555 size_t RTPSender::SendPadData(size_t bytes, |
590 bool timestamp_provided, | 556 bool timestamp_provided, |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
646 (clock_->TimeInMilliseconds() - last_timestamp_time_ms_); | 612 (clock_->TimeInMilliseconds() - last_timestamp_time_ms_); |
647 } | 613 } |
648 ssrc = ssrc_rtx_; | 614 ssrc = ssrc_rtx_; |
649 sequence_number = sequence_number_rtx_; | 615 sequence_number = sequence_number_rtx_; |
650 ++sequence_number_rtx_; | 616 ++sequence_number_rtx_; |
651 payload_type = rtx_payload_type_map_.begin()->second; | 617 payload_type = rtx_payload_type_map_.begin()->second; |
652 over_rtx = true; | 618 over_rtx = true; |
653 } | 619 } |
654 } | 620 } |
655 | 621 |
656 uint8_t padding_packet[IP_PACKET_SIZE]; | 622 RtpPacketToSend padding_packet(&rtp_header_extension_map_, IP_PACKET_SIZE); |
657 size_t header_length = 0; | 623 padding_packet.SetPayloadType(payload_type); |
658 { | 624 padding_packet.SetMarker(false); |
659 rtc::CritScope lock(&send_critsect_); | 625 padding_packet.SetSequenceNumber(sequence_number); |
660 header_length = | 626 padding_packet.SetTimestamp(timestamp); |
661 CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp, | 627 padding_packet.SetSsrc(ssrc); |
662 sequence_number, std::vector<uint32_t>()); | 628 |
663 } | |
664 BuildPaddingPacket(padding_packet, header_length, padding_bytes_in_packet); | |
665 size_t length = padding_bytes_in_packet + header_length; | |
666 int64_t now_ms = clock_->TimeInMilliseconds(); | 629 int64_t now_ms = clock_->TimeInMilliseconds(); |
667 | 630 |
668 RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length); | |
669 RTPHeader rtp_header; | |
670 rtp_parser.Parse(&rtp_header); | |
671 | |
672 if (capture_time_ms > 0) { | 631 if (capture_time_ms > 0) { |
673 UpdateTransmissionTimeOffset( | 632 padding_packet.SetExtension<TransmissionOffset>( |
674 padding_packet, length, rtp_header, now_ms - capture_time_ms); | 633 kTimestampTicksPerMs * (now_ms - capture_time_ms)); |
675 } | 634 } |
676 | 635 padding_packet.SetExtension<AbsoluteSendTime>(now_ms); |
677 UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); | |
678 | 636 |
679 PacketOptions options; | 637 PacketOptions options; |
680 if (UpdateTransportSequenceNumber(padding_packet, length, rtp_header, | 638 bool has_transport_seq_no = |
681 &options.packet_id)) { | 639 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id); |
682 if (transport_feedback_observer_) | |
683 transport_feedback_observer_->AddPacket(options.packet_id, length, | |
684 probe_cluster_id); | |
685 } | |
686 | 640 |
687 if (!SendPacketToNetwork(padding_packet, length, options)) | 641 padding_packet.SetPadding(padding_bytes_in_packet, &random_); |
| 642 |
| 643 if (has_transport_seq_no && transport_feedback_observer_) |
| 644 transport_feedback_observer_->AddPacket( |
| 645 options.packet_id, padding_packet.size(), probe_cluster_id); |
| 646 |
| 647 if (!SendPacketToNetwork(padding_packet, options)) |
688 break; | 648 break; |
689 | 649 |
690 bytes_sent += padding_bytes_in_packet; | 650 bytes_sent += padding_bytes_in_packet; |
691 UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); | 651 UpdateRtpStats(padding_packet, over_rtx, false); |
692 } | 652 } |
693 | 653 |
694 return bytes_sent; | 654 return bytes_sent; |
695 } | 655 } |
696 | 656 |
697 void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { | 657 void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { |
698 packet_history_.SetStorePacketsStatus(enable, number_to_store); | 658 packet_history_.SetStorePacketsStatus(enable, number_to_store); |
699 } | 659 } |
700 | 660 |
701 bool RTPSender::StorePackets() const { | 661 bool RTPSender::StorePackets() const { |
702 return packet_history_.StorePackets(); | 662 return packet_history_.StorePackets(); |
703 } | 663 } |
704 | 664 |
705 int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) { | 665 int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) { |
706 size_t length = IP_PACKET_SIZE; | 666 std::unique_ptr<RtpPacketToSend> packet = |
707 uint8_t data_buffer[IP_PACKET_SIZE]; | 667 packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true); |
708 int64_t capture_time_ms; | 668 if (!packet) { |
709 | |
710 if (!packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true, | |
711 data_buffer, &length, | |
712 &capture_time_ms)) { | |
713 // Packet not found. | 669 // Packet not found. |
714 return 0; | 670 return 0; |
715 } | 671 } |
716 | 672 |
717 // Check if we're overusing retransmission bitrate. | 673 // Check if we're overusing retransmission bitrate. |
718 // TODO(sprang): Add histograms for nack success or failure reasons. | 674 // TODO(sprang): Add histograms for nack success or failure reasons. |
719 RTC_DCHECK(retransmission_rate_limiter_); | 675 RTC_DCHECK(retransmission_rate_limiter_); |
720 if (!retransmission_rate_limiter_->TryUseRate(length)) | 676 if (!retransmission_rate_limiter_->TryUseRate(packet->size())) |
721 return -1; | 677 return -1; |
722 | 678 |
723 if (paced_sender_) { | 679 if (paced_sender_) { |
724 RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length); | |
725 RTPHeader header; | |
726 if (!rtp_parser.Parse(&header)) { | |
727 assert(false); | |
728 return -1; | |
729 } | |
730 // Convert from TickTime to Clock since capture_time_ms is based on | 680 // Convert from TickTime to Clock since capture_time_ms is based on |
731 // TickTime. | 681 // TickTime. |
732 int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_; | 682 int64_t corrected_capture_tims_ms = |
733 paced_sender_->InsertPacket( | 683 packet->capture_time_ms() + clock_delta_ms_; |
734 RtpPacketSender::kNormalPriority, header.ssrc, header.sequenceNumber, | 684 paced_sender_->InsertPacket(RtpPacketSender::kNormalPriority, |
735 corrected_capture_tims_ms, length - header.headerLength, true); | 685 packet->Ssrc(), packet->SequenceNumber(), |
| 686 corrected_capture_tims_ms, |
| 687 packet->payload_size(), true); |
736 | 688 |
737 return length; | 689 return packet->size(); |
738 } | 690 } |
739 int rtx = kRtxOff; | 691 bool rtx = (RtxStatus() & kRtxRetransmitted) > 0; |
740 { | 692 int32_t packet_size = static_cast<int32_t>(packet->size()); |
741 rtc::CritScope lock(&send_critsect_); | 693 if (!PrepareAndSendPacket(std::move(packet), rtx, true, |
742 rtx = rtx_; | 694 PacketInfo::kNotAProbe)) |
743 } | |
744 if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms, | |
745 (rtx & kRtxRetransmitted) > 0, true, | |
746 PacketInfo::kNotAProbe)) { | |
747 return -1; | 695 return -1; |
748 } | 696 return packet_size; |
749 return static_cast<int32_t>(length); | |
750 } | 697 } |
751 | 698 |
752 bool RTPSender::SendPacketToNetwork(const uint8_t* packet, | 699 bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet, |
753 size_t size, | |
754 const PacketOptions& options) { | 700 const PacketOptions& options) { |
755 int bytes_sent = -1; | 701 int bytes_sent = -1; |
756 if (transport_) { | 702 if (transport_) { |
757 bytes_sent = transport_->SendRtp(packet, size, options) | 703 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options) |
758 ? static_cast<int>(size) | 704 ? static_cast<int>(packet.size()) |
759 : -1; | 705 : -1; |
760 if (event_log_ && bytes_sent > 0) { | 706 if (event_log_ && bytes_sent > 0) { |
761 event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet, size); | 707 event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet.data(), |
| 708 packet.size()); |
762 } | 709 } |
763 } | 710 } |
764 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 711 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
765 "RTPSender::SendPacketToNetwork", "size", size, "sent", | 712 "RTPSender::SendPacketToNetwork", "size", packet.size(), |
766 bytes_sent); | 713 "sent", bytes_sent); |
767 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer. | 714 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer. |
768 if (bytes_sent <= 0) { | 715 if (bytes_sent <= 0) { |
769 LOG(LS_WARNING) << "Transport failed to send packet"; | 716 LOG(LS_WARNING) << "Transport failed to send packet"; |
770 return false; | 717 return false; |
771 } | 718 } |
772 return true; | 719 return true; |
773 } | 720 } |
774 | 721 |
775 int RTPSender::SelectiveRetransmissions() const { | 722 int RTPSender::SelectiveRetransmissions() const { |
776 if (!video_) | 723 if (!video_) |
(...skipping 27 matching lines...) Expand all Loading... |
804 void RTPSender::OnReceivedRtcpReportBlocks( | 751 void RTPSender::OnReceivedRtcpReportBlocks( |
805 const ReportBlockList& report_blocks) { | 752 const ReportBlockList& report_blocks) { |
806 playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks); | 753 playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks); |
807 } | 754 } |
808 | 755 |
809 // Called from pacer when we can send the packet. | 756 // Called from pacer when we can send the packet. |
810 bool RTPSender::TimeToSendPacket(uint16_t sequence_number, | 757 bool RTPSender::TimeToSendPacket(uint16_t sequence_number, |
811 int64_t capture_time_ms, | 758 int64_t capture_time_ms, |
812 bool retransmission, | 759 bool retransmission, |
813 int probe_cluster_id) { | 760 int probe_cluster_id) { |
814 size_t length = IP_PACKET_SIZE; | 761 std::unique_ptr<RtpPacketToSend> packet = |
815 uint8_t data_buffer[IP_PACKET_SIZE]; | 762 packet_history_.GetPacketAndSetSendTime(sequence_number, 0, |
816 int64_t stored_time_ms; | 763 retransmission); |
817 | 764 if (!packet) |
818 if (!packet_history_.GetPacketAndSetSendTime(sequence_number, | |
819 0, | |
820 retransmission, | |
821 data_buffer, | |
822 &length, | |
823 &stored_time_ms)) { | |
824 // Packet cannot be found. Allow sending to continue. | 765 // Packet cannot be found. Allow sending to continue. |
825 return true; | 766 return true; |
826 } | |
827 | 767 |
828 int rtx; | 768 return PrepareAndSendPacket( |
829 { | 769 std::move(packet), |
830 rtc::CritScope lock(&send_critsect_); | 770 retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission, |
831 rtx = rtx_; | 771 probe_cluster_id); |
832 } | |
833 return PrepareAndSendPacket(data_buffer, length, capture_time_ms, | |
834 retransmission && (rtx & kRtxRetransmitted) > 0, | |
835 retransmission, probe_cluster_id); | |
836 } | 772 } |
837 | 773 |
838 bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, | 774 bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet, |
839 size_t length, | |
840 int64_t capture_time_ms, | |
841 bool send_over_rtx, | 775 bool send_over_rtx, |
842 bool is_retransmit, | 776 bool is_retransmit, |
843 int probe_cluster_id) { | 777 int probe_cluster_id) { |
844 uint8_t* buffer_to_send_ptr = buffer; | 778 RTC_DCHECK(packet); |
| 779 int64_t capture_time_ms = packet->capture_time_ms(); |
| 780 RtpPacketToSend* packet_to_send = packet.get(); |
845 | 781 |
846 RtpUtility::RtpHeaderParser rtp_parser(buffer, length); | 782 if (!is_retransmit && packet->Marker()) { |
847 RTPHeader rtp_header; | |
848 rtp_parser.Parse(&rtp_header); | |
849 if (!is_retransmit && rtp_header.markerBit) { | |
850 TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend", | 783 TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend", |
851 capture_time_ms); | 784 capture_time_ms); |
852 } | 785 } |
853 | 786 |
854 TRACE_EVENT_INSTANT2( | 787 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
855 TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PrepareAndSendPacket", | 788 "PrepareAndSendPacket", "timestamp", packet->Timestamp(), |
856 "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber); | 789 "seqnum", packet->SequenceNumber()); |
857 | 790 |
858 uint8_t data_buffer_rtx[IP_PACKET_SIZE]; | 791 std::unique_ptr<RtpPacketToSend> packet_rtx; |
859 if (send_over_rtx) { | 792 if (send_over_rtx) { |
860 if (!BuildRtxPacket(buffer, &length, data_buffer_rtx)) | 793 packet_rtx = BuildRtxPacket(*packet); |
| 794 if (!packet_rtx) |
861 return false; | 795 return false; |
862 buffer_to_send_ptr = data_buffer_rtx; | 796 packet_to_send = packet_rtx.get(); |
863 } | 797 } |
864 | 798 |
865 int64_t now_ms = clock_->TimeInMilliseconds(); | 799 int64_t now_ms = clock_->TimeInMilliseconds(); |
866 int64_t diff_ms = now_ms - capture_time_ms; | 800 int64_t diff_ms = now_ms - capture_time_ms; |
867 UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, | 801 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs * |
868 diff_ms); | 802 diff_ms); |
869 UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); | 803 packet_to_send->SetExtension<AbsoluteSendTime>(now_ms); |
870 | 804 |
871 PacketOptions options; | 805 PacketOptions options; |
872 if (UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header, | 806 if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id) && |
873 &options.packet_id)) { | 807 transport_feedback_observer_) { |
874 if (transport_feedback_observer_) | 808 transport_feedback_observer_->AddPacket( |
875 transport_feedback_observer_->AddPacket(options.packet_id, length, | 809 options.packet_id, packet_to_send->size(), probe_cluster_id); |
876 probe_cluster_id); | |
877 } | 810 } |
878 | 811 |
879 if (!is_retransmit && !send_over_rtx) { | 812 if (!is_retransmit && !send_over_rtx) { |
880 UpdateDelayStatistics(capture_time_ms, now_ms); | 813 UpdateDelayStatistics(packet->capture_time_ms(), now_ms); |
881 UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc); | 814 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), |
| 815 packet->Ssrc()); |
882 } | 816 } |
883 | 817 |
884 bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options); | 818 if (!SendPacketToNetwork(*packet_to_send, options)) |
885 if (ret) { | 819 return false; |
| 820 |
| 821 { |
886 rtc::CritScope lock(&send_critsect_); | 822 rtc::CritScope lock(&send_critsect_); |
887 media_has_been_sent_ = true; | 823 media_has_been_sent_ = true; |
888 } | 824 } |
889 UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, | 825 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit); |
890 is_retransmit); | 826 return true; |
891 return ret; | |
892 } | 827 } |
893 | 828 |
894 void RTPSender::UpdateRtpStats(const uint8_t* buffer, | 829 void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet, |
895 size_t packet_length, | |
896 const RTPHeader& header, | |
897 bool is_rtx, | 830 bool is_rtx, |
898 bool is_retransmit) { | 831 bool is_retransmit) { |
899 StreamDataCounters* counters; | 832 StreamDataCounters* counters; |
900 // Get ssrc before taking statistics_crit_ to avoid possible deadlock. | 833 // Get ssrc before taking statistics_crit_ to avoid possible deadlock. |
901 uint32_t ssrc = is_rtx ? RtxSsrc() : SSRC(); | 834 uint32_t ssrc = is_rtx ? RtxSsrc() : SSRC(); |
902 int64_t now_ms = clock_->TimeInMilliseconds(); | 835 int64_t now_ms = clock_->TimeInMilliseconds(); |
903 | 836 |
904 rtc::CritScope lock(&statistics_crit_); | 837 rtc::CritScope lock(&statistics_crit_); |
905 if (is_rtx) { | 838 if (is_rtx) { |
906 counters = &rtx_rtp_stats_; | 839 counters = &rtx_rtp_stats_; |
907 } else { | 840 } else { |
908 counters = &rtp_stats_; | 841 counters = &rtp_stats_; |
909 } | 842 } |
910 | 843 |
911 total_bitrate_sent_.Update(packet_length, now_ms); | 844 total_bitrate_sent_.Update(packet.size(), now_ms); |
912 | 845 |
913 if (counters->first_packet_time_ms == -1) | 846 if (counters->first_packet_time_ms == -1) { |
914 counters->first_packet_time_ms = clock_->TimeInMilliseconds(); | 847 counters->first_packet_time_ms = clock_->TimeInMilliseconds(); |
| 848 } |
| 849 if (IsFecPacket(packet)) { |
| 850 CountPacket(&counters->fec, packet); |
| 851 } |
| 852 if (is_retransmit) { |
| 853 CountPacket(&counters->retransmitted, packet); |
| 854 nack_bitrate_sent_.Update(packet.size(), now_ms); |
| 855 } |
| 856 CountPacket(&counters->transmitted, packet); |
915 | 857 |
916 if (IsFecPacket(buffer, header)) | 858 if (rtp_stats_callback_) { |
917 counters->fec.AddPacket(packet_length, header); | 859 rtp_stats_callback_->DataCountersUpdated(*counters, ssrc); |
918 | |
919 if (is_retransmit) { | |
920 counters->retransmitted.AddPacket(packet_length, header); | |
921 nack_bitrate_sent_.Update(packet_length, now_ms); | |
922 } | 860 } |
923 | |
924 counters->transmitted.AddPacket(packet_length, header); | |
925 | |
926 if (rtp_stats_callback_) | |
927 rtp_stats_callback_->DataCountersUpdated(*counters, ssrc); | |
928 } | 861 } |
929 | 862 |
930 bool RTPSender::IsFecPacket(const uint8_t* buffer, | 863 bool RTPSender::IsFecPacket(const RtpPacketToSend& packet) const { |
931 const RTPHeader& header) const { | |
932 if (!video_) { | 864 if (!video_) { |
933 return false; | 865 return false; |
934 } | 866 } |
935 bool fec_enabled; | 867 bool fec_enabled; |
936 uint8_t pt_red; | 868 uint8_t pt_red; |
937 uint8_t pt_fec; | 869 uint8_t pt_fec; |
938 video_->GenericFECStatus(&fec_enabled, &pt_red, &pt_fec); | 870 video_->GenericFECStatus(&fec_enabled, &pt_red, &pt_fec); |
939 return fec_enabled && | 871 return fec_enabled && packet.PayloadType() == pt_red && |
940 header.payloadType == pt_red && | 872 packet.payload()[0] == pt_fec; |
941 buffer[header.headerLength] == pt_fec; | |
942 } | 873 } |
943 | 874 |
944 size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) { | 875 size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) { |
945 if (audio_configured_ || bytes == 0) | 876 if (audio_configured_ || bytes == 0) |
946 return 0; | 877 return 0; |
947 size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id); | 878 size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id); |
948 if (bytes_sent < bytes) | 879 if (bytes_sent < bytes) |
949 bytes_sent += | 880 bytes_sent += |
950 SendPadData(bytes - bytes_sent, false, 0, 0, probe_cluster_id); | 881 SendPadData(bytes - bytes_sent, false, 0, 0, probe_cluster_id); |
951 return bytes_sent; | 882 return bytes_sent; |
952 } | 883 } |
953 | 884 |
954 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again. | |
955 bool RTPSender::SendToNetwork(uint8_t* buffer, | 885 bool RTPSender::SendToNetwork(uint8_t* buffer, |
956 size_t payload_length, | 886 size_t payload_length, |
957 size_t rtp_header_length, | 887 size_t rtp_header_length, |
958 int64_t capture_time_ms, | 888 int64_t capture_time_ms, |
959 StorageType storage, | 889 StorageType storage, |
960 RtpPacketSender::Priority priority) { | 890 RtpPacketSender::Priority priority) { |
961 size_t length = payload_length + rtp_header_length; | 891 size_t length = payload_length + rtp_header_length; |
962 RtpUtility::RtpHeaderParser rtp_parser(buffer, length); | 892 std::unique_ptr<RtpPacketToSend> packet( |
| 893 new RtpPacketToSend(&rtp_header_extension_map_, length)); |
| 894 RTC_CHECK(packet->Parse(buffer, length)); |
| 895 packet->set_capture_time_ms(capture_time_ms); |
| 896 return SendToNetwork(std::move(packet), storage, priority); |
| 897 } |
963 | 898 |
964 RTPHeader rtp_header; | 899 bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet, |
965 rtp_parser.Parse(&rtp_header); | 900 StorageType storage, |
966 | 901 RtpPacketSender::Priority priority) { |
| 902 RTC_DCHECK(packet); |
967 int64_t now_ms = clock_->TimeInMilliseconds(); | 903 int64_t now_ms = clock_->TimeInMilliseconds(); |
968 | 904 |
969 // |capture_time_ms| <= 0 is considered invalid. | 905 // |capture_time_ms| <= 0 is considered invalid. |
970 // TODO(holmer): This should be changed all over Video Engine so that negative | 906 // TODO(holmer): This should be changed all over Video Engine so that negative |
971 // time is consider invalid, while 0 is considered a valid time. | 907 // time is consider invalid, while 0 is considered a valid time. |
972 if (capture_time_ms > 0) { | 908 if (packet->capture_time_ms() > 0) { |
973 UpdateTransmissionTimeOffset(buffer, length, rtp_header, | 909 packet->SetExtension<TransmissionOffset>( |
974 now_ms - capture_time_ms); | 910 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms())); |
975 } | 911 } |
976 | 912 packet->SetExtension<AbsoluteSendTime>(now_ms); |
977 UpdateAbsoluteSendTime(buffer, length, rtp_header, now_ms); | |
978 | |
979 // Used for NACK and to spread out the transmission of packets. | |
980 if (packet_history_.PutRTPPacket(buffer, length, capture_time_ms, storage) != | |
981 0) { | |
982 return false; | |
983 } | |
984 | 913 |
985 if (paced_sender_) { | 914 if (paced_sender_) { |
| 915 uint16_t seq_no = packet->SequenceNumber(); |
| 916 uint32_t ssrc = packet->Ssrc(); |
986 // Correct offset between implementations of millisecond time stamps in | 917 // Correct offset between implementations of millisecond time stamps in |
987 // TickTime and Clock. | 918 // TickTime and Clock. |
988 int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_; | 919 int64_t corrected_time_ms = packet->capture_time_ms() + clock_delta_ms_; |
989 paced_sender_->InsertPacket(priority, rtp_header.ssrc, | 920 size_t payload_length = packet->payload_size(); |
990 rtp_header.sequenceNumber, corrected_time_ms, | 921 packet_history_.PutRtpPacket(std::move(packet), storage, false); |
| 922 |
| 923 paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms, |
991 payload_length, false); | 924 payload_length, false); |
992 if (last_capture_time_ms_sent_ == 0 || | 925 if (last_capture_time_ms_sent_ == 0 || |
993 corrected_time_ms > last_capture_time_ms_sent_) { | 926 corrected_time_ms > last_capture_time_ms_sent_) { |
994 last_capture_time_ms_sent_ = corrected_time_ms; | 927 last_capture_time_ms_sent_ = corrected_time_ms; |
995 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 928 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
996 "PacedSend", corrected_time_ms, | 929 "PacedSend", corrected_time_ms, |
997 "capture_time_ms", corrected_time_ms); | 930 "capture_time_ms", corrected_time_ms); |
998 } | 931 } |
999 return true; | 932 return true; |
1000 } | 933 } |
1001 | 934 |
1002 PacketOptions options; | 935 PacketOptions options; |
1003 if (UpdateTransportSequenceNumber(buffer, length, rtp_header, | 936 if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id) && |
1004 &options.packet_id)) { | 937 transport_feedback_observer_) { |
1005 if (transport_feedback_observer_) | 938 transport_feedback_observer_->AddPacket(options.packet_id, packet->size(), |
1006 transport_feedback_observer_->AddPacket(options.packet_id, length, | 939 PacketInfo::kNotAProbe); |
1007 PacketInfo::kNotAProbe); | |
1008 } | 940 } |
1009 UpdateDelayStatistics(capture_time_ms, now_ms); | |
1010 UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc); | |
1011 | 941 |
1012 bool sent = SendPacketToNetwork(buffer, length, options); | 942 UpdateDelayStatistics(packet->capture_time_ms(), now_ms); |
| 943 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(), |
| 944 packet->Ssrc()); |
| 945 |
| 946 bool sent = SendPacketToNetwork(*packet, options); |
| 947 |
| 948 if (sent) { |
| 949 { |
| 950 rtc::CritScope lock(&send_critsect_); |
| 951 media_has_been_sent_ = true; |
| 952 } |
| 953 UpdateRtpStats(*packet, false, false); |
| 954 } |
1013 | 955 |
1014 // Mark the packet as sent in the history even if send failed. Dropping a | 956 // Mark the packet as sent in the history even if send failed. Dropping a |
1015 // packet here should be treated as any other packet drop so we should be | 957 // packet here should be treated as any other packet drop so we should be |
1016 // ready for a retransmission. | 958 // ready for a retransmission. |
1017 packet_history_.SetSent(rtp_header.sequenceNumber); | 959 packet_history_.PutRtpPacket(std::move(packet), storage, true); |
1018 | 960 |
1019 if (!sent) | 961 return sent; |
1020 return false; | |
1021 | |
1022 { | |
1023 rtc::CritScope lock(&send_critsect_); | |
1024 media_has_been_sent_ = true; | |
1025 } | |
1026 UpdateRtpStats(buffer, length, rtp_header, false, false); | |
1027 return true; | |
1028 } | 962 } |
1029 | 963 |
1030 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { | 964 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { |
1031 if (!send_side_delay_observer_ || capture_time_ms <= 0) | 965 if (!send_side_delay_observer_ || capture_time_ms <= 0) |
1032 return; | 966 return; |
1033 | 967 |
1034 uint32_t ssrc; | 968 uint32_t ssrc; |
1035 int avg_delay_ms = 0; | 969 int avg_delay_ms = 0; |
1036 int max_delay_ms = 0; | 970 int max_delay_ms = 0; |
1037 { | 971 { |
(...skipping 449 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1487 | 1421 |
1488 // Verify first byte in block. | 1422 // Verify first byte in block. |
1489 const uint8_t first_block_byte = (id << 4) + (extension_length_bytes - 2); | 1423 const uint8_t first_block_byte = (id << 4) + (extension_length_bytes - 2); |
1490 if (rtp_packet[block_pos] != first_block_byte) | 1424 if (rtp_packet[block_pos] != first_block_byte) |
1491 return ExtensionStatus::kError; | 1425 return ExtensionStatus::kError; |
1492 | 1426 |
1493 *extension_offset = block_pos; | 1427 *extension_offset = block_pos; |
1494 return ExtensionStatus::kOk; | 1428 return ExtensionStatus::kOk; |
1495 } | 1429 } |
1496 | 1430 |
1497 void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet, | |
1498 size_t rtp_packet_length, | |
1499 const RTPHeader& rtp_header, | |
1500 int64_t time_diff_ms) const { | |
1501 size_t offset; | |
1502 rtc::CritScope lock(&send_critsect_); | |
1503 switch (VerifyExtension(kRtpExtensionTransmissionTimeOffset, rtp_packet, | |
1504 rtp_packet_length, rtp_header, | |
1505 kTransmissionTimeOffsetLength, &offset)) { | |
1506 case ExtensionStatus::kNotRegistered: | |
1507 return; | |
1508 case ExtensionStatus::kError: | |
1509 LOG(LS_WARNING) << "Failed to update transmission time offset."; | |
1510 return; | |
1511 case ExtensionStatus::kOk: | |
1512 break; | |
1513 default: | |
1514 RTC_NOTREACHED(); | |
1515 } | |
1516 | |
1517 // Update transmission offset field (converting to a 90 kHz timestamp). | |
1518 ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, | |
1519 time_diff_ms * 90); // RTP timestamp. | |
1520 } | |
1521 | |
1522 bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet, | 1431 bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet, |
1523 size_t rtp_packet_length, | 1432 size_t rtp_packet_length, |
1524 const RTPHeader& rtp_header, | 1433 const RTPHeader& rtp_header, |
1525 bool is_voiced, | 1434 bool is_voiced, |
1526 uint8_t dBov) const { | 1435 uint8_t dBov) const { |
1527 size_t offset; | 1436 size_t offset; |
1528 rtc::CritScope lock(&send_critsect_); | 1437 rtc::CritScope lock(&send_critsect_); |
1529 | 1438 |
1530 switch (VerifyExtension(kRtpExtensionAudioLevel, rtp_packet, | 1439 switch (VerifyExtension(kRtpExtensionAudioLevel, rtp_packet, |
1531 rtp_packet_length, rtp_header, kAudioLevelLength, | 1440 rtp_packet_length, rtp_header, kAudioLevelLength, |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1563 case ExtensionStatus::kOk: | 1472 case ExtensionStatus::kOk: |
1564 break; | 1473 break; |
1565 default: | 1474 default: |
1566 RTC_NOTREACHED(); | 1475 RTC_NOTREACHED(); |
1567 } | 1476 } |
1568 | 1477 |
1569 rtp_packet[offset + 1] = ConvertVideoRotationToCVOByte(rotation); | 1478 rtp_packet[offset + 1] = ConvertVideoRotationToCVOByte(rotation); |
1570 return true; | 1479 return true; |
1571 } | 1480 } |
1572 | 1481 |
1573 void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet, | 1482 bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet, |
1574 size_t rtp_packet_length, | 1483 int* packet_id) const { |
1575 const RTPHeader& rtp_header, | 1484 RTC_DCHECK(packet); |
1576 int64_t now_ms) const { | 1485 RTC_DCHECK(packet_id); |
1577 size_t offset; | |
1578 rtc::CritScope lock(&send_critsect_); | 1486 rtc::CritScope lock(&send_critsect_); |
1579 | 1487 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId)) |
1580 switch (VerifyExtension(kRtpExtensionAbsoluteSendTime, rtp_packet, | |
1581 rtp_packet_length, rtp_header, | |
1582 kAbsoluteSendTimeLength, &offset)) { | |
1583 case ExtensionStatus::kNotRegistered: | |
1584 return; | |
1585 case ExtensionStatus::kError: | |
1586 LOG(LS_WARNING) << "Failed to update absolute send time"; | |
1587 return; | |
1588 case ExtensionStatus::kOk: | |
1589 break; | |
1590 default: | |
1591 RTC_NOTREACHED(); | |
1592 } | |
1593 | |
1594 // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit | |
1595 // fractional part). | |
1596 ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, | |
1597 ConvertMsTo24Bits(now_ms)); | |
1598 } | |
1599 | |
1600 bool RTPSender::UpdateTransportSequenceNumber(uint8_t* rtp_packet, | |
1601 size_t rtp_packet_length, | |
1602 const RTPHeader& rtp_header, | |
1603 int* sequence_number) const { | |
1604 RTC_DCHECK(sequence_number); | |
1605 size_t offset; | |
1606 rtc::CritScope lock(&send_critsect_); | |
1607 | |
1608 switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet, | |
1609 rtp_packet_length, rtp_header, | |
1610 kTransportSequenceNumberLength, &offset)) { | |
1611 case ExtensionStatus::kNotRegistered: | |
1612 return false; | |
1613 case ExtensionStatus::kError: | |
1614 LOG(LS_WARNING) << "Failed to update transport sequence number"; | |
1615 return false; | |
1616 case ExtensionStatus::kOk: | |
1617 break; | |
1618 default: | |
1619 RTC_NOTREACHED(); | |
1620 } | |
1621 | |
1622 if (!AllocateTransportSequenceNumber(sequence_number)) | |
1623 return false; | 1488 return false; |
1624 | 1489 |
1625 BuildTransportSequenceNumberExtension(rtp_packet + offset, *sequence_number); | |
1626 return true; | |
1627 } | |
1628 | |
1629 bool RTPSender::AllocateTransportSequenceNumber(int* packet_id) const { | |
1630 if (!transport_sequence_number_allocator_) | 1490 if (!transport_sequence_number_allocator_) |
1631 return false; | 1491 return false; |
1632 | 1492 |
1633 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber(); | 1493 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber(); |
| 1494 |
| 1495 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id)) |
| 1496 return false; |
| 1497 |
1634 return true; | 1498 return true; |
1635 } | 1499 } |
1636 | 1500 |
1637 void RTPSender::SetSendingStatus(bool enabled) { | 1501 void RTPSender::SetSendingStatus(bool enabled) { |
1638 if (enabled) { | 1502 if (enabled) { |
1639 uint32_t frequency_hz = SendPayloadFrequency(); | 1503 uint32_t frequency_hz = SendPayloadFrequency(); |
1640 uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz); | 1504 uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz); |
1641 | 1505 |
1642 // Will be ignored if it's already configured via API. | 1506 // Will be ignored if it's already configured via API. |
1643 SetStartTimestamp(RTPtime, false); | 1507 SetStartTimestamp(RTPtime, false); |
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1796 int32_t RTPSender::SetFecParameters( | 1660 int32_t RTPSender::SetFecParameters( |
1797 const FecProtectionParams *delta_params, | 1661 const FecProtectionParams *delta_params, |
1798 const FecProtectionParams *key_params) { | 1662 const FecProtectionParams *key_params) { |
1799 if (audio_configured_) { | 1663 if (audio_configured_) { |
1800 return -1; | 1664 return -1; |
1801 } | 1665 } |
1802 video_->SetFecParameters(delta_params, key_params); | 1666 video_->SetFecParameters(delta_params, key_params); |
1803 return 0; | 1667 return 0; |
1804 } | 1668 } |
1805 | 1669 |
1806 bool RTPSender::BuildRtxPacket(uint8_t* buffer, | 1670 std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket( |
1807 size_t* length, | 1671 const RtpPacketToSend& packet) { |
1808 uint8_t* buffer_rtx) { | 1672 // TODO(danilchap): Create rtx packet with extra capacity for SRTP |
1809 rtc::CritScope lock(&send_critsect_); | 1673 // when transport interface would be updated to take buffer class. |
1810 if (!sending_media_) | 1674 std::unique_ptr<RtpPacketToSend> rtx_packet(new RtpPacketToSend( |
1811 return false; | 1675 &rtp_header_extension_map_, packet.size() + kRtxHeaderSize)); |
1812 uint8_t* data_buffer_rtx = buffer_rtx; | 1676 // Add original RTP header. |
1813 // Add RTX header. | 1677 rtx_packet->CopyHeaderFrom(packet); |
1814 RtpUtility::RtpHeaderParser rtp_parser( | 1678 { |
1815 reinterpret_cast<const uint8_t*>(buffer), *length); | 1679 rtc::CritScope lock(&send_critsect_); |
| 1680 if (!sending_media_) |
| 1681 return nullptr; |
| 1682 // Replace payload type, if a specific type is set for RTX. |
| 1683 auto kv = rtx_payload_type_map_.find(packet.PayloadType()); |
1816 | 1684 |
1817 RTPHeader rtp_header; | 1685 // Use rtx mapping associated with media codec if we can't find one, |
1818 rtp_parser.Parse(&rtp_header); | 1686 // assume it's red. |
| 1687 // TODO(holmer): Remove once old Chrome versions don't rely on this. |
| 1688 if (kv == rtx_payload_type_map_.end()) |
| 1689 kv = rtx_payload_type_map_.find(payload_type_); |
| 1690 if (kv != rtx_payload_type_map_.end()) |
| 1691 rtx_packet->SetPayloadType(kv->second); |
1819 | 1692 |
1820 // Add original RTP header. | 1693 // Replace sequence number. |
1821 memcpy(data_buffer_rtx, buffer, rtp_header.headerLength); | 1694 rtx_packet->SetSequenceNumber(sequence_number_rtx_++); |
1822 | 1695 |
1823 // Replace payload type, if a specific type is set for RTX. | 1696 // Replace SSRC. |
1824 auto kv = rtx_payload_type_map_.find(rtp_header.payloadType); | 1697 rtx_packet->SetSsrc(ssrc_rtx_); |
1825 // Use rtx mapping associated with media codec if we can't find one, assuming | 1698 } |
1826 // it's red. | |
1827 // TODO(holmer): Remove once old Chrome versions don't rely on this. | |
1828 if (kv == rtx_payload_type_map_.end()) | |
1829 kv = rtx_payload_type_map_.find(payload_type_); | |
1830 if (kv != rtx_payload_type_map_.end()) | |
1831 data_buffer_rtx[1] = kv->second; | |
1832 if (rtp_header.markerBit) | |
1833 data_buffer_rtx[1] |= kRtpMarkerBitMask; | |
1834 | 1699 |
1835 // Replace sequence number. | 1700 uint8_t* rtx_payload = |
1836 uint8_t* ptr = data_buffer_rtx + 2; | 1701 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize); |
1837 ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++); | 1702 RTC_DCHECK(rtx_payload); |
1838 | |
1839 // Replace SSRC. | |
1840 ptr += 6; | |
1841 ByteWriter<uint32_t>::WriteBigEndian(ptr, ssrc_rtx_); | |
1842 | |
1843 // Add OSN (original sequence number). | 1703 // Add OSN (original sequence number). |
1844 ptr = data_buffer_rtx + rtp_header.headerLength; | 1704 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber()); |
1845 ByteWriter<uint16_t>::WriteBigEndian(ptr, rtp_header.sequenceNumber); | |
1846 ptr += 2; | |
1847 | 1705 |
1848 // Add original payload data. | 1706 // Add original payload data. |
1849 memcpy(ptr, buffer + rtp_header.headerLength, | 1707 memcpy(rtx_payload + kRtxHeaderSize, packet.payload(), packet.payload_size()); |
1850 *length - rtp_header.headerLength); | 1708 |
1851 *length += 2; | 1709 return rtx_packet; |
1852 return true; | |
1853 } | 1710 } |
1854 | 1711 |
1855 void RTPSender::RegisterRtpStatisticsCallback( | 1712 void RTPSender::RegisterRtpStatisticsCallback( |
1856 StreamDataCountersCallback* callback) { | 1713 StreamDataCountersCallback* callback) { |
1857 rtc::CritScope cs(&statistics_crit_); | 1714 rtc::CritScope cs(&statistics_crit_); |
1858 rtp_stats_callback_ = callback; | 1715 rtp_stats_callback_ = callback; |
1859 } | 1716 } |
1860 | 1717 |
1861 StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const { | 1718 StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const { |
1862 rtc::CritScope cs(&statistics_crit_); | 1719 rtc::CritScope cs(&statistics_crit_); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1901 rtc::CritScope lock(&send_critsect_); | 1758 rtc::CritScope lock(&send_critsect_); |
1902 | 1759 |
1903 RtpState state; | 1760 RtpState state; |
1904 state.sequence_number = sequence_number_rtx_; | 1761 state.sequence_number = sequence_number_rtx_; |
1905 state.start_timestamp = start_timestamp_; | 1762 state.start_timestamp = start_timestamp_; |
1906 | 1763 |
1907 return state; | 1764 return state; |
1908 } | 1765 } |
1909 | 1766 |
1910 } // namespace webrtc | 1767 } // namespace webrtc |
OLD | NEW |