From bc38b4d450a80bf45efbe5b0a452e0374cdae1e6 Mon Sep 17 00:00:00 2001 From: danilchap Date: Tue, 8 Nov 2016 13:36:37 -0800 Subject: [PATCH] Revert of Simplify and extend RtpHeaderExtensionMap (patchset #12 id:260001 of https://codereview.webrtc.org/2452293004/ ) Reason for revert: breaks downstream project Original issue's description: > Simplify and extend RtpHeaderExtensionMap > Add register functions for various codepaths. > Add initialize-list constructor to create usable const RtpHeaderExtensionMap > Optimize implementation for GetId/GetType. > > BUG=webrtc:1994 > > Committed: https://crrev.com/d1d26fbeb37a69471a34004c6ac2d3fafde5d404 > Cr-Commit-Position: refs/heads/master@{#14986} TBR=sprang@webrtc.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=webrtc:1994 Review-Url: https://codereview.webrtc.org/2484863007 Cr-Commit-Position: refs/heads/master@{#14988} --- .../rtp_rtcp/source/rtp_header_extension.cc | 227 +++++++++--------- .../rtp_rtcp/source/rtp_header_extension.h | 106 ++++---- .../source/rtp_header_extension_unittest.cc | 130 +++++----- .../rtp_rtcp/source/rtp_header_extensions.cc | 17 +- .../rtp_rtcp/source/rtp_header_extensions.h | 18 +- 5 files changed, 250 insertions(+), 248 deletions(-) diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc index b7c7306275..7fdff34985 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.cc @@ -8,143 +8,148 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h" +#include -#include "webrtc/base/arraysize.h" #include "webrtc/base/checks.h" -#include "webrtc/base/logging.h" -#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" +#include "webrtc/common_types.h" +#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h" #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" namespace webrtc { -namespace { -using RtpUtility::Word32Align; +constexpr uint8_t RtpHeaderExtensionMap::kInvalidId; -struct ExtensionInfo { - RTPExtensionType type; - size_t value_size; - const char* uri; -}; - -template -constexpr ExtensionInfo CreateExtensionInfo() { - return {Extension::kId, Extension::kValueSizeBytes, Extension::kUri}; +RtpHeaderExtensionMap::RtpHeaderExtensionMap() { } -constexpr ExtensionInfo kExtensions[] = { - CreateExtensionInfo(), - CreateExtensionInfo(), - CreateExtensionInfo(), - CreateExtensionInfo(), - CreateExtensionInfo(), - CreateExtensionInfo(), -}; +RtpHeaderExtensionMap::~RtpHeaderExtensionMap() { + Erase(); +} -// Because of kRtpExtensionNone, NumberOfExtension is 1 bigger than the actual -// number of known extensions. -static_assert(arraysize(kExtensions) == - static_cast(kRtpExtensionNumberOfExtensions) - 1, - "kExtensions expect to list all known extensions"); +void RtpHeaderExtensionMap::Erase() { + while (!extensionMap_.empty()) { + std::map::iterator it = + extensionMap_.begin(); + delete it->second; + extensionMap_.erase(it); + } +} -size_t ValueSize(RTPExtensionType type) { - for (const ExtensionInfo& extension : kExtensions) - if (type == extension.type) - return extension.value_size; - - RTC_NOTREACHED(); +int32_t RtpHeaderExtensionMap::Register(RTPExtensionType type, uint8_t id) { + if (id < 1 || id > 14) { + return -1; + } + std::map::iterator it = + extensionMap_.find(id); + if (it != extensionMap_.end()) { + if (it->second->type != type) { + // An extension is already registered with the same id + // but a different type, so return failure. + return -1; + } + // This extension type is already registered with this id, + // so return success. + return 0; + } + RTC_DCHECK_EQ(kInvalidId, GetId(type)); + extensionMap_[id] = new HeaderExtension(type); return 0; } -} // namespace - -constexpr RTPExtensionType RtpHeaderExtensionMap::kInvalidType; -constexpr uint8_t RtpHeaderExtensionMap::kInvalidId; -constexpr uint8_t RtpHeaderExtensionMap::kMinId; -constexpr uint8_t RtpHeaderExtensionMap::kMaxId; - -RtpHeaderExtensionMap::RtpHeaderExtensionMap() { - total_values_size_bytes_ = 0; - for (auto& type : types_) - type = kInvalidType; - for (auto& id : ids_) - id = kInvalidId; +int32_t RtpHeaderExtensionMap::Deregister(const RTPExtensionType type) { + uint8_t id; + if (GetId(type, &id) != 0) { + return 0; + } + std::map::iterator it = + extensionMap_.find(id); + assert(it != extensionMap_.end()); + delete it->second; + extensionMap_.erase(it); + return 0; } -RtpHeaderExtensionMap::RtpHeaderExtensionMap( - std::initializer_list extensions) - : RtpHeaderExtensionMap() { - for (const RtpExtension& extension : extensions) - RegisterByUri(extension.id, extension.uri); -} - -bool RtpHeaderExtensionMap::RegisterByType(uint8_t id, RTPExtensionType type) { - for (const ExtensionInfo& extension : kExtensions) - if (type == extension.type) - return Register(id, extension.type, extension.value_size, extension.uri); - RTC_NOTREACHED(); +bool RtpHeaderExtensionMap::IsRegistered(RTPExtensionType type) const { + std::map::const_iterator it = + extensionMap_.begin(); + for (; it != extensionMap_.end(); ++it) { + if (it->second->type == type) + return true; + } return false; } -bool RtpHeaderExtensionMap::RegisterByUri(uint8_t id, const std::string& uri) { - for (const ExtensionInfo& extension : kExtensions) - if (uri == extension.uri) - return Register(id, extension.type, extension.value_size, extension.uri); - LOG(LS_WARNING) << "Unknown extension uri:'" << uri - << "', id: " << static_cast(id) << '.'; - return false; +int32_t RtpHeaderExtensionMap::GetType(const uint8_t id, + RTPExtensionType* type) const { + assert(type); + std::map::const_iterator it = + extensionMap_.find(id); + if (it == extensionMap_.end()) { + return -1; + } + HeaderExtension* extension = it->second; + *type = extension->type; + return 0; +} + +RTPExtensionType RtpHeaderExtensionMap::GetType(uint8_t id) const { + auto it = extensionMap_.find(id); + if (it == extensionMap_.end()) { + return kInvalidType; + } + return it->second->type; +} + +int32_t RtpHeaderExtensionMap::GetId(const RTPExtensionType type, + uint8_t* id) const { + assert(id); + std::map::const_iterator it = + extensionMap_.begin(); + + while (it != extensionMap_.end()) { + HeaderExtension* extension = it->second; + if (extension->type == type) { + *id = it->first; + return 0; + } + it++; + } + return -1; +} + +uint8_t RtpHeaderExtensionMap::GetId(RTPExtensionType type) const { + for (auto kv : extensionMap_) { + if (kv.second->type == type) + return kv.first; + } + return kInvalidId; } size_t RtpHeaderExtensionMap::GetTotalLengthInBytes() const { - if (total_values_size_bytes_ == 0) - return 0; - return Word32Align(kRtpOneByteHeaderLength + total_values_size_bytes_); + // Get length for each extension block. + size_t length = 0; + for (const auto& kv : extensionMap_) + length += kv.second->length; + // Add RTP extension header length. + if (length > 0) + length += kRtpOneByteHeaderLength; + // Pad up to nearest 32bit word. + length = RtpUtility::Word32Align(length); + return length; } -int32_t RtpHeaderExtensionMap::Deregister(RTPExtensionType type) { - if (IsRegistered(type)) { - uint8_t id = GetId(type); - total_values_size_bytes_ -= (ValueSize(type) + 1); - types_[id] = kInvalidType; - ids_[type] = kInvalidId; - } - return 0; +int32_t RtpHeaderExtensionMap::Size() const { + return extensionMap_.size(); } -bool RtpHeaderExtensionMap::Register(uint8_t id, - RTPExtensionType type, - size_t value_size, - const char* uri) { - RTC_DCHECK_GT(type, kRtpExtensionNone); - RTC_DCHECK_LT(type, kRtpExtensionNumberOfExtensions); - RTC_DCHECK_GE(value_size, 1U); - RTC_DCHECK_LE(value_size, 16U); - - if (id < kMinId || id > kMaxId) { - LOG(LS_WARNING) << "Failed to register extension uri:'" << uri - << "' with invalid id:" << static_cast(id) << "."; - return false; +void RtpHeaderExtensionMap::GetCopy(RtpHeaderExtensionMap* map) const { + assert(map); + std::map::const_iterator it = + extensionMap_.begin(); + while (it != extensionMap_.end()) { + HeaderExtension* extension = it->second; + map->Register(extension->type, it->first); + it++; } - - if (GetType(id) == type) { // Same type/id pair already registered. - LOG(LS_VERBOSE) << "Reregistering extension uri:'" << uri - << "', id:" << static_cast(id); - return true; - } - - if (GetType(id) != kInvalidType) { // |id| used by another extension type. - LOG(LS_WARNING) << "Failed to register extension uri:'" << uri - << "', id:" << static_cast(id) - << ". Id already in use by extension type " - << static_cast(GetType(id)); - return false; - } - RTC_DCHECK(!IsRegistered(type)); - - types_[id] = type; - ids_[type] = id; - total_values_size_bytes_ += (value_size + 1); - return true; } - } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h index a8591c77e9..b053f7f8ca 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extension.h @@ -11,13 +11,10 @@ #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_HEADER_EXTENSION_H_ #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_HEADER_EXTENSION_H_ -#include -#include +#include -#include "webrtc/base/basictypes.h" -#include "webrtc/base/checks.h" -#include "webrtc/config.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" +#include "webrtc/typedefs.h" namespace webrtc { @@ -38,63 +35,74 @@ const int kPlayoutDelayGranularityMs = 10; // Maximum playout delay value in milliseconds. const int kPlayoutDelayMaxMs = 40950; +struct HeaderExtension { + explicit HeaderExtension(RTPExtensionType extension_type) + : type(extension_type), length(0) { + Init(); + } + + void Init() { + // TODO(solenberg): Create handler classes for header extensions so we can + // get rid of switches like these as well as handling code spread out all + // over. + switch (type) { + case kRtpExtensionTransmissionTimeOffset: + length = kTransmissionTimeOffsetLength; + break; + case kRtpExtensionAudioLevel: + length = kAudioLevelLength; + break; + case kRtpExtensionAbsoluteSendTime: + length = kAbsoluteSendTimeLength; + break; + case kRtpExtensionVideoRotation: + length = kVideoRotationLength; + break; + case kRtpExtensionTransportSequenceNumber: + length = kTransportSequenceNumberLength; + break; + case kRtpExtensionPlayoutDelay: + length = kPlayoutDelayLength; + break; + default: + assert(false); + } + } + + const RTPExtensionType type; + uint8_t length; +}; + class RtpHeaderExtensionMap { public: static constexpr RTPExtensionType kInvalidType = kRtpExtensionNone; static constexpr uint8_t kInvalidId = 0; - RtpHeaderExtensionMap(); - RtpHeaderExtensionMap(std::initializer_list); + ~RtpHeaderExtensionMap(); - template - bool Register(uint8_t id) { - return Register(id, Extension::kId, Extension::kValueSizeBytes, - Extension::kUri); - } - bool RegisterByType(uint8_t id, RTPExtensionType type); - bool RegisterByUri(uint8_t id, const std::string& uri); + void Erase(); - bool IsRegistered(RTPExtensionType type) const { - return GetId(type) != kInvalidId; - } + int32_t Register(RTPExtensionType type, uint8_t id); + + int32_t Deregister(RTPExtensionType type); + + bool IsRegistered(RTPExtensionType type) const; + + int32_t GetType(uint8_t id, RTPExtensionType* type) const; // Return kInvalidType if not found. - RTPExtensionType GetType(uint8_t id) const { - RTC_DCHECK_GE(id, kMinId); - RTC_DCHECK_LE(id, kMaxId); - return types_[id]; - } - // Return kInvalidId if not found. - uint8_t GetId(RTPExtensionType type) const { - RTC_DCHECK_GT(type, kRtpExtensionNone); - RTC_DCHECK_LT(type, kRtpExtensionNumberOfExtensions); - return ids_[type]; - } + RTPExtensionType GetType(uint8_t id) const; + int32_t GetId(const RTPExtensionType type, uint8_t* id) const; + // Return kInvalidId if not found. + uint8_t GetId(RTPExtensionType type) const; size_t GetTotalLengthInBytes() const; - // TODO(danilchap): Remove use of the functions below. - void Erase() { *this = RtpHeaderExtensionMap(); } - int32_t Register(RTPExtensionType type, uint8_t id) { - return RegisterByType(id, type) ? 0 : -1; - } - int32_t Deregister(RTPExtensionType type); - int32_t GetType(uint8_t id, RTPExtensionType* type) const { - *type = GetType(id); - return *type == kInvalidType ? -1 : 0; - } - void GetCopy(RtpHeaderExtensionMap* copy) const { *copy = *this; } + void GetCopy(RtpHeaderExtensionMap* map) const; + + int32_t Size() const; private: - static constexpr uint8_t kMinId = 1; - static constexpr uint8_t kMaxId = 14; - bool Register(uint8_t id, - RTPExtensionType type, - size_t value_size, - const char* uri); - - size_t total_values_size_bytes_ = 0; - RTPExtensionType types_[kMaxId + 1]; - uint8_t ids_[kRtpExtensionNumberOfExtensions]; + std::map extensionMap_; }; } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc index 3794e831df..50a913efbc 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extension_unittest.cc @@ -10,99 +10,87 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h" -#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" #include "webrtc/test/gtest.h" #include "webrtc/typedefs.h" namespace webrtc { -TEST(RtpHeaderExtensionTest, RegisterByType) { - RtpHeaderExtensionMap map; - EXPECT_FALSE(map.IsRegistered(TransmissionOffset::kId)); +class RtpHeaderExtensionTest : public ::testing::Test { + protected: + RtpHeaderExtensionTest() {} + ~RtpHeaderExtensionTest() {} - EXPECT_TRUE(map.RegisterByType(3, TransmissionOffset::kId)); + RtpHeaderExtensionMap map_; + static const uint8_t kId; +}; - EXPECT_TRUE(map.IsRegistered(TransmissionOffset::kId)); - EXPECT_EQ(3, map.GetId(TransmissionOffset::kId)); - EXPECT_EQ(TransmissionOffset::kId, map.GetType(3)); +const uint8_t RtpHeaderExtensionTest::kId = 3; + +TEST_F(RtpHeaderExtensionTest, Register) { + EXPECT_EQ(0, map_.Size()); + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_TRUE(map_.IsRegistered(kRtpExtensionTransmissionTimeOffset)); + EXPECT_EQ(1, map_.Size()); + EXPECT_EQ(0, map_.Deregister(kRtpExtensionTransmissionTimeOffset)); + EXPECT_EQ(0, map_.Size()); } -TEST(RtpHeaderExtensionTest, RegisterByUri) { - RtpHeaderExtensionMap map; - - EXPECT_TRUE(map.RegisterByUri(3, TransmissionOffset::kUri)); - - EXPECT_TRUE(map.IsRegistered(TransmissionOffset::kId)); - EXPECT_EQ(3, map.GetId(TransmissionOffset::kId)); - EXPECT_EQ(TransmissionOffset::kId, map.GetType(3)); -} - -TEST(RtpHeaderExtensionTest, RegisterWithTrait) { - RtpHeaderExtensionMap map; - - EXPECT_TRUE(map.Register(3)); - - EXPECT_TRUE(map.IsRegistered(TransmissionOffset::kId)); - EXPECT_EQ(3, map.GetId(TransmissionOffset::kId)); - EXPECT_EQ(TransmissionOffset::kId, map.GetType(3)); -} - -TEST(RtpHeaderExtensionTest, RegisterDuringContruction) { - const RtpHeaderExtensionMap map = {{TransmissionOffset::kUri, 1}, - {AbsoluteSendTime::kUri, 3}}; - - EXPECT_EQ(1, map.GetId(TransmissionOffset::kId)); - EXPECT_EQ(3, map.GetId(AbsoluteSendTime::kId)); -} - -TEST(RtpHeaderExtensionTest, RegisterIllegalArg) { - RtpHeaderExtensionMap map; +TEST_F(RtpHeaderExtensionTest, RegisterIllegalArg) { // Valid range for id: [1-14]. - EXPECT_FALSE(map.Register(0)); - EXPECT_FALSE(map.Register(15)); + EXPECT_EQ(-1, map_.Register(kRtpExtensionTransmissionTimeOffset, 0)); + EXPECT_EQ(-1, map_.Register(kRtpExtensionTransmissionTimeOffset, 15)); } -TEST(RtpHeaderExtensionTest, Idempotent) { - RtpHeaderExtensionMap map; - - EXPECT_TRUE(map.Register(3)); - EXPECT_TRUE(map.Register(3)); - - map.Deregister(TransmissionOffset::kId); - map.Deregister(TransmissionOffset::kId); +TEST_F(RtpHeaderExtensionTest, Idempotent) { + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(0, map_.Deregister(kRtpExtensionTransmissionTimeOffset)); + EXPECT_EQ(0, map_.Deregister(kRtpExtensionTransmissionTimeOffset)); } -TEST(RtpHeaderExtensionTest, NonUniqueId) { - RtpHeaderExtensionMap map; - EXPECT_TRUE(map.Register(3)); - - EXPECT_FALSE(map.Register(3)); - EXPECT_TRUE(map.Register(4)); +TEST_F(RtpHeaderExtensionTest, NonUniqueId) { + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(-1, map_.Register(kRtpExtensionAudioLevel, kId)); } -TEST(RtpHeaderExtensionTest, GetTotalLength) { - RtpHeaderExtensionMap map; - EXPECT_EQ(0u, map.GetTotalLengthInBytes()); - EXPECT_TRUE(map.Register(3)); - EXPECT_EQ(kRtpOneByteHeaderLength + (TransmissionOffset::kValueSizeBytes + 1), - map.GetTotalLengthInBytes()); +TEST_F(RtpHeaderExtensionTest, GetTotalLength) { + EXPECT_EQ(0u, map_.GetTotalLengthInBytes()); + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength, + map_.GetTotalLengthInBytes()); } -TEST(RtpHeaderExtensionTest, GetType) { - RtpHeaderExtensionMap map; - EXPECT_EQ(RtpHeaderExtensionMap::kInvalidType, map.GetType(3)); - EXPECT_TRUE(map.Register(3)); +TEST_F(RtpHeaderExtensionTest, GetType) { + RTPExtensionType typeOut; + EXPECT_EQ(-1, map_.GetType(kId, &typeOut)); - EXPECT_EQ(TransmissionOffset::kId, map.GetType(3)); + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(0, map_.GetType(kId, &typeOut)); + EXPECT_EQ(kRtpExtensionTransmissionTimeOffset, typeOut); } -TEST(RtpHeaderExtensionTest, GetId) { - RtpHeaderExtensionMap map; - EXPECT_EQ(RtpHeaderExtensionMap::kInvalidId, - map.GetId(TransmissionOffset::kId)); - EXPECT_TRUE(map.Register(3)); +TEST_F(RtpHeaderExtensionTest, GetId) { + uint8_t idOut; + EXPECT_EQ(-1, map_.GetId(kRtpExtensionTransmissionTimeOffset, &idOut)); - EXPECT_EQ(3, map.GetId(TransmissionOffset::kId)); + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(0, map_.GetId(kRtpExtensionTransmissionTimeOffset, &idOut)); + EXPECT_EQ(kId, idOut); } +TEST_F(RtpHeaderExtensionTest, GetCopy) { + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + + RtpHeaderExtensionMap mapOut; + map_.GetCopy(&mapOut); + EXPECT_EQ(1, mapOut.Size()); + EXPECT_EQ(kId, mapOut.GetId(kRtpExtensionTransmissionTimeOffset)); +} + +TEST_F(RtpHeaderExtensionTest, Erase) { + EXPECT_EQ(0, map_.Register(kRtpExtensionTransmissionTimeOffset, kId)); + EXPECT_EQ(1, map_.Size()); + map_.Erase(); + EXPECT_EQ(0, map_.Size()); +} } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.cc index 167f29ee95..1356069ca9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.cc @@ -33,7 +33,8 @@ namespace webrtc { // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ constexpr RTPExtensionType AbsoluteSendTime::kId; constexpr uint8_t AbsoluteSendTime::kValueSizeBytes; -constexpr const char* AbsoluteSendTime::kUri; +const char* const AbsoluteSendTime::kUri = + "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"; bool AbsoluteSendTime::Parse(const uint8_t* data, uint32_t* time_24bits) { *time_24bits = ByteReader::ReadBigEndian(data); @@ -59,7 +60,8 @@ bool AbsoluteSendTime::Write(uint8_t* data, int64_t time_ms) { // constexpr RTPExtensionType AudioLevel::kId; constexpr uint8_t AudioLevel::kValueSizeBytes; -constexpr const char* AudioLevel::kUri; +const char* const AudioLevel::kUri = + "urn:ietf:params:rtp-hdrext:ssrc-audio-level"; bool AudioLevel::Parse(const uint8_t* data, bool* voice_activity, @@ -95,7 +97,8 @@ bool AudioLevel::Write(uint8_t* data, // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ constexpr RTPExtensionType TransmissionOffset::kId; constexpr uint8_t TransmissionOffset::kValueSizeBytes; -constexpr const char* TransmissionOffset::kUri; +const char* const TransmissionOffset::kUri = + "urn:ietf:params:rtp-hdrext:toffset"; bool TransmissionOffset::Parse(const uint8_t* data, int32_t* rtp_time) { *rtp_time = ByteReader::ReadBigEndian(data); @@ -115,7 +118,8 @@ bool TransmissionOffset::Write(uint8_t* data, int32_t rtp_time) { // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ constexpr RTPExtensionType TransportSequenceNumber::kId; constexpr uint8_t TransportSequenceNumber::kValueSizeBytes; -constexpr const char* TransportSequenceNumber::kUri; +const char* const TransportSequenceNumber::kUri = + "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions"; bool TransportSequenceNumber::Parse(const uint8_t* data, uint16_t* value) { *value = ByteReader::ReadBigEndian(data); @@ -140,7 +144,7 @@ bool TransportSequenceNumber::Write(uint8_t* data, uint16_t value) { // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ constexpr RTPExtensionType VideoOrientation::kId; constexpr uint8_t VideoOrientation::kValueSizeBytes; -constexpr const char* VideoOrientation::kUri; +const char* const VideoOrientation::kUri = "urn:3gpp:video-orientation"; bool VideoOrientation::Parse(const uint8_t* data, VideoRotation* rotation) { *rotation = ConvertCVOByteToVideoRotation(data[0]); @@ -169,7 +173,8 @@ bool VideoOrientation::Write(uint8_t* data, uint8_t value) { // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ constexpr RTPExtensionType PlayoutDelayLimits::kId; constexpr uint8_t PlayoutDelayLimits::kValueSizeBytes; -constexpr const char* PlayoutDelayLimits::kUri; +const char* const PlayoutDelayLimits::kUri = + "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay"; bool PlayoutDelayLimits::Parse(const uint8_t* data, PlayoutDelay* playout_delay) { diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h b/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h index afe47e53bc..b6850235d1 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h @@ -20,8 +20,7 @@ class AbsoluteSendTime { public: static constexpr RTPExtensionType kId = kRtpExtensionAbsoluteSendTime; static constexpr uint8_t kValueSizeBytes = 3; - static constexpr const char* kUri = - "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"; + static const char* const kUri; static bool Parse(const uint8_t* data, uint32_t* time_24bits); static bool Write(uint8_t* data, int64_t time_ms); @@ -35,8 +34,7 @@ class AudioLevel { public: static constexpr RTPExtensionType kId = kRtpExtensionAudioLevel; static constexpr uint8_t kValueSizeBytes = 1; - static constexpr const char* kUri = - "urn:ietf:params:rtp-hdrext:ssrc-audio-level"; + static const char* const kUri; static bool Parse(const uint8_t* data, bool* voice_activity, @@ -48,7 +46,7 @@ class TransmissionOffset { public: static constexpr RTPExtensionType kId = kRtpExtensionTransmissionTimeOffset; static constexpr uint8_t kValueSizeBytes = 3; - static constexpr const char* kUri = "urn:ietf:params:rtp-hdrext:toffset"; + static const char* const kUri; static bool Parse(const uint8_t* data, int32_t* rtp_time); static bool Write(uint8_t* data, int32_t rtp_time); @@ -58,9 +56,8 @@ class TransportSequenceNumber { public: static constexpr RTPExtensionType kId = kRtpExtensionTransportSequenceNumber; static constexpr uint8_t kValueSizeBytes = 2; - static constexpr const char* kUri = - "http://www.ietf.org/id/" - "draft-holmer-rmcat-transport-wide-cc-extensions-01"; + static const char* const kUri; + static bool Parse(const uint8_t* data, uint16_t* value); static bool Write(uint8_t* data, uint16_t value); }; @@ -69,7 +66,7 @@ class VideoOrientation { public: static constexpr RTPExtensionType kId = kRtpExtensionVideoRotation; static constexpr uint8_t kValueSizeBytes = 1; - static constexpr const char* kUri = "urn:3gpp:video-orientation"; + static const char* const kUri; static bool Parse(const uint8_t* data, VideoRotation* value); static bool Write(uint8_t* data, VideoRotation value); @@ -81,8 +78,7 @@ class PlayoutDelayLimits { public: static constexpr RTPExtensionType kId = kRtpExtensionPlayoutDelay; static constexpr uint8_t kValueSizeBytes = 3; - static constexpr const char* kUri = - "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay"; + static const char* const kUri; // Playout delay in milliseconds. A playout delay limit (min or max) // has 12 bits allocated. This allows a range of 0-4095 values which