From 81d4bf7af6df732ff7456dc144ef726146c18627 Mon Sep 17 00:00:00 2001 From: Artem Titov Date: Thu, 24 Jan 2019 12:01:59 +0000 Subject: [PATCH] Revert "Delete RtpUtility::Payload, and refactor RTPSender to not use it" This reverts commit 171df9326200d1e01bce530e2ff01ac5890e6cb7. Reason for revert: Breaks downstream project Original change's description: > Delete RtpUtility::Payload, and refactor RTPSender to not use it > > Replaced by a payload type --> video codec map in RTPSenderVideo, > where it is used to select the right packetizer. > > Bug: webrtc:6883 > Change-Id: I43a635d5135c5d519df860a2f4287a4478870b0f > Reviewed-on: https://webrtc-review.googlesource.com/c/119263 > Reviewed-by: Rasmus Brandt > Reviewed-by: Danil Chapovalov > Commit-Queue: Niels Moller > Cr-Commit-Position: refs/heads/master@{#26380} TBR=danilchap@webrtc.org,brandtr@webrtc.org,nisse@webrtc.org Change-Id: I76489c29541827aaba72515a76db54bdb7495e28 No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:6883 Reviewed-on: https://webrtc-review.googlesource.com/c/119640 Reviewed-by: Artem Titov Commit-Queue: Artem Titov Cr-Commit-Position: refs/heads/master@{#26385} --- modules/rtp_rtcp/include/rtp_rtcp_defines.cc | 9 ++ modules/rtp_rtcp/include/rtp_rtcp_defines.h | 41 ++++++++ modules/rtp_rtcp/source/rtp_sender.cc | 98 +++++++++++++++++-- modules/rtp_rtcp/source/rtp_sender.h | 5 + modules/rtp_rtcp/source/rtp_sender_audio.cc | 7 +- modules/rtp_rtcp/source/rtp_sender_audio.h | 4 +- .../rtp_rtcp/source/rtp_sender_unittest.cc | 43 ++++---- modules/rtp_rtcp/source/rtp_sender_video.cc | 36 +++---- modules/rtp_rtcp/source/rtp_sender_video.h | 18 ++-- modules/rtp_rtcp/source/rtp_utility.h | 10 ++ 10 files changed, 214 insertions(+), 57 deletions(-) diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.cc b/modules/rtp_rtcp/include/rtp_rtcp_defines.cc index d23d82da48..d743f52f7e 100644 --- a/modules/rtp_rtcp/include/rtp_rtcp_defines.cc +++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.cc @@ -53,6 +53,15 @@ void StreamId::Set(const char* data, size_t size) { // and thus assume trivial destructibility. static_assert(std::is_trivially_destructible::value, ""); +PayloadUnion::PayloadUnion(const AudioPayload& payload) : payload_(payload) {} +PayloadUnion::PayloadUnion(const VideoPayload& payload) : payload_(payload) {} +PayloadUnion::PayloadUnion(const PayloadUnion&) = default; +PayloadUnion::PayloadUnion(PayloadUnion&&) = default; +PayloadUnion::~PayloadUnion() = default; + +PayloadUnion& PayloadUnion::operator=(const PayloadUnion&) = default; +PayloadUnion& PayloadUnion::operator=(PayloadUnion&&) = default; + PacketFeedback::PacketFeedback(int64_t arrival_time_ms, uint16_t sequence_number) : PacketFeedback(-1, diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/modules/rtp_rtcp/include/rtp_rtcp_defines.h index c993c044b4..ab4fcaecc7 100644 --- a/modules/rtp_rtcp/include/rtp_rtcp_defines.h +++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.h @@ -41,6 +41,47 @@ const int kBogusRtpRateForAudioRtcp = 8000; // Minimum RTP header size in bytes. const uint8_t kRtpHeaderSize = 12; +struct AudioPayload { + SdpAudioFormat format; + uint32_t rate; +}; + +struct VideoPayload { + VideoCodecType videoCodecType; + // The H264 profile only matters if videoCodecType == kVideoCodecH264. + H264::Profile h264_profile; +}; + +class PayloadUnion { + public: + explicit PayloadUnion(const AudioPayload& payload); + explicit PayloadUnion(const VideoPayload& payload); + PayloadUnion(const PayloadUnion&); + PayloadUnion(PayloadUnion&&); + ~PayloadUnion(); + + PayloadUnion& operator=(const PayloadUnion&); + PayloadUnion& operator=(PayloadUnion&&); + + bool is_audio() const { + return absl::holds_alternative(payload_); + } + bool is_video() const { + return absl::holds_alternative(payload_); + } + const AudioPayload& audio_payload() const { + return absl::get(payload_); + } + const VideoPayload& video_payload() const { + return absl::get(payload_); + } + AudioPayload& audio_payload() { return absl::get(payload_); } + VideoPayload& video_payload() { return absl::get(payload_); } + + private: + absl::variant payload_; +}; + enum ProtectionType { kUnprotectedPacket, kProtectedPacket }; enum StorageType { kDontRetransmit, kAllowRetransmission }; diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc index 3ad8d9a0dc..edd2edb0d2 100644 --- a/modules/rtp_rtcp/source/rtp_sender.cc +++ b/modules/rtp_rtcp/source/rtp_sender.cc @@ -144,6 +144,7 @@ RTPSender::RTPSender( force_part_of_allocation_(false), max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP. last_payload_type_(-1), + payload_type_map_(), rtp_header_extension_map_(extmap_allow_mixed), packet_history_(clock), flexfec_packet_history_(clock), @@ -201,6 +202,12 @@ RTPSender::~RTPSender() { // variables but we grab them in all other methods. (what's the design?) // Start documenting what thread we're on in what method so that it's easier // to understand performance attributes and possibly remove locks. + while (!payload_type_map_.empty()) { + std::map::iterator it = + payload_type_map_.begin(); + delete it->second; + payload_type_map_.erase(it); + } } rtc::ArrayView RTPSender::FecExtensionSizes() { @@ -277,19 +284,58 @@ int32_t RTPSender::RegisterPayload(absl::string_view payload_name, RTC_DCHECK_LT(payload_name.size(), RTP_PAYLOAD_NAME_SIZE); rtc::CritScope lock(&send_critsect_); + std::map::iterator it = + payload_type_map_.find(payload_number); + + if (payload_type_map_.end() != it) { + // We already use this payload type. + RtpUtility::Payload* payload = it->second; + RTC_DCHECK(payload); + + // Check if it's the same as we already have. + if (absl::EqualsIgnoreCase(payload->name, payload_name)) { + if (audio_configured_ && payload->typeSpecific.is_audio()) { + auto& p = payload->typeSpecific.audio_payload(); + if (rtc::SafeEq(p.format.clockrate_hz, frequency) && + (p.rate == rate || p.rate == 0 || rate == 0)) { + p.rate = rate; + // Ensure that we update the rate if new or old is zero. + return 0; + } + } + if (!audio_configured_ && !payload->typeSpecific.is_audio()) { + return 0; + } + } + return -1; + } int32_t ret_val = 0; + RtpUtility::Payload* payload = nullptr; if (audio_configured_) { // TODO(mflodman): Change to CreateAudioPayload and make static. ret_val = audio_->RegisterAudioPayload(payload_name, payload_number, - frequency, channels, rate); + frequency, channels, rate, &payload); } else { - video_->RegisterPayloadType(payload_number, payload_name); + payload = video_->CreateVideoPayload(payload_name, payload_number); + } + if (payload) { + payload_type_map_[payload_number] = payload; } - return ret_val; } -int32_t RTPSender::DeRegisterSendPayload(int8_t /* payload_type */) { +int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) { + rtc::CritScope lock(&send_critsect_); + + std::map::iterator it = + payload_type_map_.find(payload_type); + + if (payload_type_map_.end() == it) { + return -1; + } + RtpUtility::Payload* payload = it->second; + delete payload; + payload_type_map_.erase(it); return 0; } @@ -338,6 +384,37 @@ void RTPSender::SetRtxPayloadType(int payload_type, rtx_payload_type_map_[associated_payload_type] = payload_type; } +int32_t RTPSender::CheckPayloadType(int8_t payload_type, + VideoCodecType* video_type) { + rtc::CritScope lock(&send_critsect_); + + if (payload_type < 0) { + RTC_LOG(LS_ERROR) << "Invalid payload_type " << payload_type << "."; + return -1; + } + if (last_payload_type_ == payload_type) { + if (!audio_configured_) { + *video_type = video_->VideoCodecType(); + } + return 0; + } + std::map::iterator it = + payload_type_map_.find(payload_type); + if (it == payload_type_map_.end()) { + RTC_LOG(LS_WARNING) << "Payload type " << static_cast(payload_type) + << " not registered."; + return -1; + } + RtpUtility::Payload* payload = it->second; + RTC_DCHECK(payload); + if (payload->typeSpecific.is_video() && !audio_configured_) { + video_->SetVideoCodecType( + payload->typeSpecific.video_payload().videoCodecType); + *video_type = payload->typeSpecific.video_payload().videoCodecType; + } + return 0; +} + bool RTPSender::SendOutgoingData(FrameType frame_type, int8_t payload_type, uint32_t capture_timestamp, @@ -364,6 +441,13 @@ bool RTPSender::SendOutgoingData(FrameType frame_type, if (!sending_media_) return true; } + VideoCodecType video_type = kVideoCodecGeneric; + if (CheckPayloadType(payload_type, &video_type) != 0) { + RTC_LOG(LS_ERROR) << "Don't send data with unknown payload type: " + << static_cast(payload_type) << "."; + return false; + } + switch (frame_type) { case kAudioFrameSpeech: case kAudioFrameCN: @@ -397,9 +481,9 @@ bool RTPSender::SendOutgoingData(FrameType frame_type, sequence_number); } - result = video_->SendVideo(frame_type, payload_type, rtp_timestamp, - capture_time_ms, payload_data, payload_size, - fragmentation, rtp_header, + result = video_->SendVideo(video_type, frame_type, payload_type, + rtp_timestamp, capture_time_ms, payload_data, + payload_size, fragmentation, rtp_header, expected_retransmission_time_ms); } diff --git a/modules/rtp_rtcp/source/rtp_sender.h b/modules/rtp_rtcp/source/rtp_sender.h index e1b9a6ec19..e5ddfcca5a 100644 --- a/modules/rtp_rtcp/source/rtp_sender.h +++ b/modules/rtp_rtcp/source/rtp_sender.h @@ -28,6 +28,7 @@ #include "modules/rtp_rtcp/source/playout_delay_oracle.h" #include "modules/rtp_rtcp/source/rtp_packet_history.h" #include "modules/rtp_rtcp/source/rtp_rtcp_config.h" +#include "modules/rtp_rtcp/source/rtp_utility.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/critical_section.h" #include "rtc_base/deprecation.h" @@ -223,6 +224,9 @@ class RTPSender { void SetRtt(int64_t rtt_ms); + protected: + int32_t CheckPayloadType(int8_t payload_type, VideoCodecType* video_type); + private: // Maps capture time in milliseconds to send-side delay in milliseconds. // Send-side delay is the difference between transmission time and capture @@ -287,6 +291,7 @@ class RTPSender { size_t max_packet_size_; int8_t last_payload_type_ RTC_GUARDED_BY(send_critsect_); + std::map payload_type_map_; RtpHeaderExtensionMap rtp_header_extension_map_ RTC_GUARDED_BY(send_critsect_); diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.cc b/modules/rtp_rtcp/source/rtp_sender_audio.cc index 9acc098555..636ccccf0d 100644 --- a/modules/rtp_rtcp/source/rtp_sender_audio.cc +++ b/modules/rtp_rtcp/source/rtp_sender_audio.cc @@ -36,7 +36,8 @@ int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name, const int8_t payload_type, const uint32_t frequency, const size_t channels, - const uint32_t rate) { + const uint32_t rate, + RtpUtility::Payload** payload) { if (absl::EqualsIgnoreCase(payload_name, "cn")) { rtc::CritScope cs(&send_audio_critsect_); // we can have multiple CNG payload types @@ -64,6 +65,10 @@ int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name, dtmf_payload_freq_ = frequency; return 0; } + *payload = new RtpUtility::Payload( + payload_name, + PayloadUnion(AudioPayload{ + SdpAudioFormat(payload_name, frequency, channels), rate})); return 0; } diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.h b/modules/rtp_rtcp/source/rtp_sender_audio.h index f002023e9a..6580f7aca0 100644 --- a/modules/rtp_rtcp/source/rtp_sender_audio.h +++ b/modules/rtp_rtcp/source/rtp_sender_audio.h @@ -18,6 +18,7 @@ #include "common_types.h" // NOLINT(build/include) #include "modules/rtp_rtcp/source/dtmf_queue.h" #include "modules/rtp_rtcp/source/rtp_sender.h" +#include "modules/rtp_rtcp/source/rtp_utility.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/critical_section.h" #include "rtc_base/one_time_event.h" @@ -35,7 +36,8 @@ class RTPSenderAudio { int8_t payload_type, uint32_t frequency, size_t channels, - uint32_t rate); + uint32_t rate, + RtpUtility::Payload** payload); bool SendAudio(FrameType frame_type, int8_t payload_type, diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 68f2402e05..89bad12ce4 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -304,7 +304,6 @@ class RtpSenderVideoTest : public RtpSenderTest { SetUpRtpSender(false, false); rtp_sender_video_.reset( new TestRtpSenderVideo(&fake_clock_, rtp_sender_.get(), nullptr)); - rtp_sender_video_->RegisterPayloadType(kPayload, "generic"); } std::unique_ptr rtp_sender_video_; }; @@ -1895,9 +1894,9 @@ TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) { RTPVideoHeader hdr; hdr.rotation = kVideoRotation_0; - rtp_sender_video_->SendVideo(kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, - sizeof(kFrame), nullptr, &hdr, - kDefaultExpectedRetransmissionTimeMs); + rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameKey, kPayload, + kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, + &hdr, kDefaultExpectedRetransmissionTimeMs); VideoRotation rotation; EXPECT_TRUE( @@ -1921,9 +1920,10 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) { hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs; fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs); - rtp_sender_video_->SendVideo( - kVideoFrameKey, kPayload, kTimestamp, kCaptureTimestamp, kFrame, - sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs); + rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameKey, kPayload, + kTimestamp, kCaptureTimestamp, kFrame, + sizeof(kFrame), nullptr, &hdr, + kDefaultExpectedRetransmissionTimeMs); VideoSendTiming timing; EXPECT_TRUE(transport_.last_sent_packet().GetExtension( &timing)); @@ -1940,13 +1940,13 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) { RTPVideoHeader hdr; hdr.rotation = kVideoRotation_90; EXPECT_TRUE(rtp_sender_video_->SendVideo( - kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, - &hdr, kDefaultExpectedRetransmissionTimeMs)); + kVideoCodecGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, + sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); hdr.rotation = kVideoRotation_0; EXPECT_TRUE(rtp_sender_video_->SendVideo( - kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame, sizeof(kFrame), - nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); + kVideoCodecGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame, + sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); VideoRotation rotation; EXPECT_TRUE( @@ -1962,12 +1962,12 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) { RTPVideoHeader hdr; hdr.rotation = kVideoRotation_90; EXPECT_TRUE(rtp_sender_video_->SendVideo( - kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, - &hdr, kDefaultExpectedRetransmissionTimeMs)); + kVideoCodecGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, + sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); EXPECT_TRUE(rtp_sender_video_->SendVideo( - kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame, sizeof(kFrame), - nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); + kVideoCodecGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame, + sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); VideoRotation rotation; EXPECT_TRUE( @@ -2233,9 +2233,9 @@ TEST_P(RtpSenderVideoTest, PopulateGenericFrameDescriptor) { generic.higher_spatial_layers.push_back(4); generic.dependencies.push_back(kFrameId - 1); generic.dependencies.push_back(kFrameId - 500); - rtp_sender_video_->SendVideo(kVideoFrameDelta, kPayload, kTimestamp, 0, - kFrame, sizeof(kFrame), nullptr, &hdr, - kDefaultExpectedRetransmissionTimeMs); + rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameDelta, kPayload, + kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, + &hdr, kDefaultExpectedRetransmissionTimeMs); RtpGenericFrameDescriptor descriptor_wire; EXPECT_EQ(1U, transport_.sent_packets_.size()); @@ -2266,10 +2266,9 @@ TEST_P(RtpSenderVideoTest, vp8.keyIdx = 2; RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); generic.frame_id = kFrameId; - rtp_sender_video_->RegisterPayloadType(kPayload, "vp8"); - rtp_sender_video_->SendVideo(kVideoFrameDelta, kPayload, kTimestamp, 0, - kFrame, sizeof(kFrame), nullptr, &hdr, - kDefaultExpectedRetransmissionTimeMs); + rtp_sender_video_->SendVideo(kVideoCodecVP8, kVideoFrameDelta, kPayload, + kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, + &hdr, kDefaultExpectedRetransmissionTimeMs); ASSERT_THAT(transport_.sent_packets_, SizeIs(1)); // Expect only minimal 1-byte vp8 descriptor was generated. diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc index 326651a1de..a33aa3698d 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video.cc @@ -156,6 +156,7 @@ RTPSenderVideo::RTPSenderVideo(Clock* clock, bool require_frame_encryption) : rtp_sender_(rtp_sender), clock_(clock), + video_type_(kVideoCodecGeneric), retransmission_settings_(kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers), last_rotation_(kVideoRotation_0), @@ -175,10 +176,19 @@ RTPSenderVideo::RTPSenderVideo(Clock* clock, RTPSenderVideo::~RTPSenderVideo() {} -void RTPSenderVideo::RegisterPayloadType(int8_t payload_type, - absl::string_view payload_name) { - VideoCodecType video_type; +void RTPSenderVideo::SetVideoCodecType(enum VideoCodecType video_type) { + video_type_ = video_type; +} +VideoCodecType RTPSenderVideo::VideoCodecType() const { + return video_type_; +} + +// Static. +RtpUtility::Payload* RTPSenderVideo::CreateVideoPayload( + absl::string_view payload_name, + int8_t payload_type) { + enum VideoCodecType video_type = kVideoCodecGeneric; if (absl::EqualsIgnoreCase(payload_name, "VP8")) { video_type = kVideoCodecVP8; } else if (absl::EqualsIgnoreCase(payload_name, "VP9")) { @@ -192,9 +202,9 @@ void RTPSenderVideo::RegisterPayloadType(int8_t payload_type, } else { video_type = kVideoCodecGeneric; } - - rtc::CritScope cs(&payload_type_crit_); - payload_type_map_[payload_type] = video_type; + VideoPayload vp; + vp.videoCodecType = video_type; + return new RtpUtility::Payload(payload_name, PayloadUnion(vp)); } void RTPSenderVideo::SendVideoPacket(std::unique_ptr packet, @@ -366,7 +376,8 @@ absl::optional RTPSenderVideo::FlexfecSsrc() const { return absl::nullopt; } -bool RTPSenderVideo::SendVideo(FrameType frame_type, +bool RTPSenderVideo::SendVideo(enum VideoCodecType video_type, + FrameType frame_type, int8_t payload_type, uint32_t rtp_timestamp, int64_t capture_time_ms, @@ -525,17 +536,6 @@ bool RTPSenderVideo::SendVideo(FrameType frame_type, << "one is required since require_frame_encryptor is set"; } - VideoCodecType video_type; - { - rtc::CritScope cs(&payload_type_crit_); - const auto it = payload_type_map_.find(payload_type); - if (it == payload_type_map_.end()) { - RTC_LOG(LS_ERROR) << "Payload type " << static_cast(payload_type) - << " not registered."; - return false; - } - video_type = it->second; - } std::unique_ptr packetizer = RtpPacketizer::Create( video_type, rtc::MakeArrayView(payload_data, payload_size), limits, *packetize_video_header, frame_type, fragmentation); diff --git a/modules/rtp_rtcp/source/rtp_sender_video.h b/modules/rtp_rtcp/source/rtp_sender_video.h index 6b10cda271..91dc662b79 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.h +++ b/modules/rtp_rtcp/source/rtp_sender_video.h @@ -21,6 +21,7 @@ #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtp_rtcp_config.h" #include "modules/rtp_rtcp/source/rtp_sender.h" +#include "modules/rtp_rtcp/source/rtp_utility.h" #include "modules/rtp_rtcp/source/ulpfec_generator.h" #include "rtc_base/critical_section.h" #include "rtc_base/one_time_event.h" @@ -45,7 +46,13 @@ class RTPSenderVideo { bool require_frame_encryption); virtual ~RTPSenderVideo(); - bool SendVideo(FrameType frame_type, + virtual enum VideoCodecType VideoCodecType() const; + + static RtpUtility::Payload* CreateVideoPayload(absl::string_view payload_name, + int8_t payload_type); + + bool SendVideo(enum VideoCodecType video_type, + FrameType frame_type, int8_t payload_type, uint32_t capture_timestamp, int64_t capture_time_ms, @@ -55,7 +62,7 @@ class RTPSenderVideo { const RTPVideoHeader* video_header, int64_t expected_retransmission_time_ms); - void RegisterPayloadType(int8_t payload_type, absl::string_view payload_name); + void SetVideoCodecType(enum VideoCodecType type); // ULPFEC. void SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type); @@ -126,15 +133,10 @@ class RTPSenderVideo { RTPSender* const rtp_sender_; Clock* const clock_; - // Maps payload type to codec type, for packetization. - // TODO(nisse): Set on construction, to avoid lock. - rtc::CriticalSection payload_type_crit_; - std::map payload_type_map_ - RTC_GUARDED_BY(payload_type_crit_); - // Should never be held when calling out of this class. rtc::CriticalSection crit_; + enum VideoCodecType video_type_; int32_t retransmission_settings_ RTC_GUARDED_BY(crit_); VideoRotation last_rotation_ RTC_GUARDED_BY(crit_); absl::optional last_color_space_ RTC_GUARDED_BY(crit_); diff --git a/modules/rtp_rtcp/source/rtp_utility.h b/modules/rtp_rtcp/source/rtp_utility.h index bbfb886eaa..408517481b 100644 --- a/modules/rtp_rtcp/source/rtp_utility.h +++ b/modules/rtp_rtcp/source/rtp_utility.h @@ -26,6 +26,16 @@ const uint8_t kRtpMarkerBitMask = 0x80; namespace RtpUtility { +struct Payload { + Payload(absl::string_view payload_name, const PayloadUnion& pu) + : typeSpecific(pu) { + size_t clipped_size = payload_name.copy(name, sizeof(name) - 1); + name[clipped_size] = '\0'; + } + char name[RTP_PAYLOAD_NAME_SIZE]; + PayloadUnion typeSpecific; +}; + // Round up to the nearest size that is a multiple of 4. size_t Word32Align(size_t size);