From 44943c8064b93a366cb8c8afdb881c009957e3df Mon Sep 17 00:00:00 2001 From: Qiu Jianlin Date: Wed, 30 Aug 2023 12:26:24 +0800 Subject: [PATCH] Add H265 codec name and profile/tier/level utils. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This adds H265 codec name and profile/tier/level handling needed for H265 SDP negotiation. Bug: webrtc:13485 Change-Id: I838b910042ce36f8ae3979c41a73ee46935c57d8 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/315900 Reviewed-by: Erik Språng Reviewed-by: Sergey Silkin Commit-Queue: Jianlin Qiu Cr-Commit-Position: refs/heads/main@{#40661} --- api/video_codecs/BUILD.gn | 7 + api/video_codecs/h265_profile_tier_level.cc | 248 ++++++++++++++++++ api/video_codecs/h265_profile_tier_level.h | 109 ++++++++ api/video_codecs/test/BUILD.gn | 4 + .../test/h265_profile_tier_level_unittest.cc | 248 ++++++++++++++++++ media/base/media_constants.cc | 11 + media/base/media_constants.h | 14 + 7 files changed, 641 insertions(+) create mode 100644 api/video_codecs/h265_profile_tier_level.cc create mode 100644 api/video_codecs/h265_profile_tier_level.h create mode 100644 api/video_codecs/test/h265_profile_tier_level_unittest.cc diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn index 20c54d541e..d9dd5aea2b 100644 --- a/api/video_codecs/BUILD.gn +++ b/api/video_codecs/BUILD.gn @@ -68,6 +68,13 @@ rtc_library("video_codecs_api") { "vp9_profile.h", ] + if (rtc_use_h265) { + sources += [ + "h265_profile_tier_level.cc", + "h265_profile_tier_level.h", + ] + } + deps = [ ":scalability_mode", "..:fec_controller_api", diff --git a/api/video_codecs/h265_profile_tier_level.cc b/api/video_codecs/h265_profile_tier_level.cc new file mode 100644 index 0000000000..f5b376e287 --- /dev/null +++ b/api/video_codecs/h265_profile_tier_level.cc @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2023 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "api/video_codecs/h265_profile_tier_level.h" + +#include + +#include "rtc_base/string_to_number.h" + +namespace webrtc { + +namespace { + +const char kH265FmtpProfile[] = "profile-id"; +const char kH265FmtpTier[] = "tier-flag"; +const char kH265FmtpLevel[] = "level-id"; + +} // anonymous namespace + +// Annex A of https://www.itu.int/rec/T-REC-H.265 (08/21), section A.3. +absl::optional StringToH265Profile(const std::string& profile) { + absl::optional i = rtc::StringToNumber(profile); + if (!i.has_value()) { + return absl::nullopt; + } + + switch (i.value()) { + case 1: + return H265Profile::kProfileMain; + case 2: + return H265Profile::kProfileMain10; + case 3: + return H265Profile::kProfileMainStill; + case 4: + return H265Profile::kProfileRangeExtensions; + case 5: + return H265Profile::kProfileHighThroughput; + case 6: + return H265Profile::kProfileMultiviewMain; + case 7: + return H265Profile::kProfileScalableMain; + case 8: + return H265Profile::kProfile3dMain; + case 9: + return H265Profile::kProfileScreenContentCoding; + case 10: + return H265Profile::kProfileScalableRangeExtensions; + case 11: + return H265Profile::kProfileHighThroughputScreenContentCoding; + default: + return absl::nullopt; + } +} + +// Annex A of https://www.itu.int/rec/T-REC-H.265 (08/21), section A.4, +// tiers and levels. +absl::optional StringToH265Tier(const std::string& tier) { + absl::optional i = rtc::StringToNumber(tier); + if (!i.has_value()) { + return absl::nullopt; + } + + switch (i.value()) { + case 0: + return H265Tier::kTier0; + case 1: + return H265Tier::kTier1; + default: + return absl::nullopt; + } +} + +absl::optional StringToH265Level(const std::string& level) { + const absl::optional i = rtc::StringToNumber(level); + if (!i.has_value()) + return absl::nullopt; + + switch (i.value()) { + case 30: + return H265Level::kLevel1; + case 60: + return H265Level::kLevel2; + case 63: + return H265Level::kLevel2_1; + case 90: + return H265Level::kLevel3; + case 93: + return H265Level::kLevel3_1; + case 120: + return H265Level::kLevel4; + case 123: + return H265Level::kLevel4_1; + case 150: + return H265Level::kLevel5; + case 153: + return H265Level::kLevel5_1; + case 156: + return H265Level::kLevel5_2; + case 180: + return H265Level::kLevel6; + case 183: + return H265Level::kLevel6_1; + case 186: + return H265Level::kLevel6_2; + default: + return absl::nullopt; + } +} + +std::string H265ProfileToString(H265Profile profile) { + switch (profile) { + case H265Profile::kProfileMain: + return "1"; + case H265Profile::kProfileMain10: + return "2"; + case H265Profile::kProfileMainStill: + return "3"; + case H265Profile::kProfileRangeExtensions: + return "4"; + case H265Profile::kProfileHighThroughput: + return "5"; + case H265Profile::kProfileMultiviewMain: + return "6"; + case H265Profile::kProfileScalableMain: + return "7"; + case H265Profile::kProfile3dMain: + return "8"; + case H265Profile::kProfileScreenContentCoding: + return "9"; + case H265Profile::kProfileScalableRangeExtensions: + return "10"; + case H265Profile::kProfileHighThroughputScreenContentCoding: + return "11"; + } +} + +std::string H265TierToString(H265Tier tier) { + switch (tier) { + case H265Tier::kTier0: + return "0"; + case H265Tier::kTier1: + return "1"; + } +} + +std::string H265LevelToString(H265Level level) { + switch (level) { + case H265Level::kLevel1: + return "30"; + case H265Level::kLevel2: + return "60"; + case H265Level::kLevel2_1: + return "63"; + case H265Level::kLevel3: + return "90"; + case H265Level::kLevel3_1: + return "93"; + case H265Level::kLevel4: + return "120"; + case H265Level::kLevel4_1: + return "123"; + case H265Level::kLevel5: + return "150"; + case H265Level::kLevel5_1: + return "153"; + case H265Level::kLevel5_2: + return "156"; + case H265Level::kLevel6: + return "180"; + case H265Level::kLevel6_1: + return "183"; + case H265Level::kLevel6_2: + return "186"; + } +} + +absl::optional ParseSdpForH265ProfileTierLevel( + const SdpVideoFormat::Parameters& params) { + static const H265ProfileTierLevel kDefaultProfileTierLevel( + H265Profile::kProfileMain, H265Tier::kTier0, H265Level::kLevel3_1); + bool profile_tier_level_specified = false; + + absl::optional profile; + const auto profile_it = params.find(kH265FmtpProfile); + if (profile_it != params.end()) { + profile_tier_level_specified = true; + const std::string& profile_str = profile_it->second; + profile = StringToH265Profile(profile_str); + if (!profile) { + return absl::nullopt; + } + } else { + profile = H265Profile::kProfileMain; + } + absl::optional tier; + const auto tier_it = params.find(kH265FmtpTier); + if (tier_it != params.end()) { + profile_tier_level_specified = true; + const std::string& tier_str = tier_it->second; + tier = StringToH265Tier(tier_str); + if (!tier) { + return absl::nullopt; + } + } else { + tier = H265Tier::kTier0; + } + absl::optional level; + const auto level_it = params.find(kH265FmtpLevel); + if (level_it != params.end()) { + profile_tier_level_specified = true; + const std::string& level_str = level_it->second; + level = StringToH265Level(level_str); + if (!level) { + return absl::nullopt; + } + } else { + level = H265Level::kLevel3_1; + } + + // Spec Table A.9, level 1 to level 3.1 does not allow high tiers. + if (level <= H265Level::kLevel3_1 && tier == H265Tier::kTier1) { + return absl::nullopt; + } + + return !profile_tier_level_specified + ? kDefaultProfileTierLevel + : H265ProfileTierLevel(profile.value(), tier.value(), + level.value()); +} + +bool H265IsSameProfileTierLevel(const SdpVideoFormat::Parameters& params1, + const SdpVideoFormat::Parameters& params2) { + const absl::optional ptl1 = + ParseSdpForH265ProfileTierLevel(params1); + const absl::optional ptl2 = + ParseSdpForH265ProfileTierLevel(params2); + return ptl1 && ptl2 && ptl1->profile == ptl2->profile && + ptl1->tier == ptl2->tier && ptl1->level == ptl2->level; +} + +} // namespace webrtc diff --git a/api/video_codecs/h265_profile_tier_level.h b/api/video_codecs/h265_profile_tier_level.h new file mode 100644 index 0000000000..3056d2b623 --- /dev/null +++ b/api/video_codecs/h265_profile_tier_level.h @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2023 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef API_VIDEO_CODECS_H265_PROFILE_TIER_LEVEL_H_ +#define API_VIDEO_CODECS_H265_PROFILE_TIER_LEVEL_H_ + +#include + +#include "absl/types/optional.h" +#include "api/video_codecs/sdp_video_format.h" +#include "rtc_base/system/rtc_export.h" + +namespace webrtc { + +// Profiles can be found at: +// https://www.itu.int/rec/T-REC-H.265 +// The enum values match the number specified in the SDP. +enum class H265Profile { + kProfileMain = 1, + kProfileMain10 = 2, + kProfileMainStill = 3, + kProfileRangeExtensions = 4, + kProfileHighThroughput = 5, + kProfileMultiviewMain = 6, + kProfileScalableMain = 7, + kProfile3dMain = 8, + kProfileScreenContentCoding = 9, + kProfileScalableRangeExtensions = 10, + kProfileHighThroughputScreenContentCoding = 11, +}; + +// Tiers can be found at https://www.itu.int/rec/T-REC-H.265 +enum class H265Tier { + kTier0, + kTier1, +}; + +// All values are equal to 30 times the level number. +enum class H265Level { + kLevel1 = 30, + kLevel2 = 60, + kLevel2_1 = 63, + kLevel3 = 90, + kLevel3_1 = 93, + kLevel4 = 120, + kLevel4_1 = 123, + kLevel5 = 150, + kLevel5_1 = 153, + kLevel5_2 = 156, + kLevel6 = 180, + kLevel6_1 = 183, + kLevel6_2 = 186, +}; + +struct H265ProfileTierLevel { + constexpr H265ProfileTierLevel(H265Profile profile, + H265Tier tier, + H265Level level) + : profile(profile), tier(tier), level(level) {} + H265Profile profile; + H265Tier tier; + H265Level level; +}; + +// Helper function to convert H265Profile to std::string. +RTC_EXPORT std::string H265ProfileToString(H265Profile profile); + +// Helper function to convert H265Tier to std::string. +RTC_EXPORT std::string H265TierToString(H265Tier tier); + +// Helper function to convert H265Level to std::string. +RTC_EXPORT std::string H265LevelToString(H265Level level); + +// Helper function to get H265Profile from profile string. +RTC_EXPORT absl::optional StringToH265Profile( + const std::string& profile); + +// Helper function to get H265Tier from tier string. +RTC_EXPORT absl::optional StringToH265Tier(const std::string& tier); + +// Helper function to get H265Level from level string. +RTC_EXPORT absl::optional StringToH265Level( + const std::string& level); + +// Parses an SDP key-value map of format parameters to retrive an H265 +// profile/tier/level. Returns an H265ProfileTierlevel by setting its +// members. profile defaults to `kProfileMain` if no profile-id is specified. +// tier defaults to "kTier0" if no tier-flag is specified. +// level defaults to "kLevel3_1" if no level-id is specified. +// Returns empty value if any of the profile/tier/level key is present but +// contains an invalid value. +RTC_EXPORT absl::optional ParseSdpForH265ProfileTierLevel( + const SdpVideoFormat::Parameters& params); + +// Returns true if the parameters have the same H265 profile or neither contains +// an H265 profile, otherwise false. +bool H265IsSameProfileTierLevel(const SdpVideoFormat::Parameters& params1, + const SdpVideoFormat::Parameters& params2); + +} // namespace webrtc + +#endif // API_VIDEO_CODECS_H265_PROFILE_TIER_LEVEL_H_ diff --git a/api/video_codecs/test/BUILD.gn b/api/video_codecs/test/BUILD.gn index eda8c568af..7bfe86e9f4 100644 --- a/api/video_codecs/test/BUILD.gn +++ b/api/video_codecs/test/BUILD.gn @@ -19,6 +19,10 @@ if (rtc_include_tests) { "video_encoder_software_fallback_wrapper_unittest.cc", ] + if (rtc_use_h265) { + sources += [ "h265_profile_tier_level_unittest.cc" ] + } + deps = [ ":video_decoder_factory_template_tests", ":video_encoder_factory_template_tests", diff --git a/api/video_codecs/test/h265_profile_tier_level_unittest.cc b/api/video_codecs/test/h265_profile_tier_level_unittest.cc new file mode 100644 index 0000000000..a9fdf966a5 --- /dev/null +++ b/api/video_codecs/test/h265_profile_tier_level_unittest.cc @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2023 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "api/video_codecs/h265_profile_tier_level.h" + +#include + +#include "absl/types/optional.h" +#include "test/gtest.h" + +namespace webrtc { + +TEST(H265ProfileTierLevel, TestLevelToString) { + EXPECT_EQ(H265LevelToString(H265Level::kLevel1), "30"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel2), "60"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel2_1), "63"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel3), "90"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel3_1), "93"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel4), "120"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel4_1), "123"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel5), "150"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel5_1), "153"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel5_2), "156"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel6), "180"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel6_1), "183"); + EXPECT_EQ(H265LevelToString(H265Level::kLevel6_2), "186"); +} + +TEST(H265ProfileTierLevel, TestProfileToString) { + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileMain), "1"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileMain10), "2"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileMainStill), "3"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileRangeExtensions), "4"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileHighThroughput), "5"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileMultiviewMain), "6"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileScalableMain), "7"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfile3dMain), "8"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileScreenContentCoding), "9"); + EXPECT_EQ(H265ProfileToString(H265Profile::kProfileScalableRangeExtensions), + "10"); + EXPECT_EQ(H265ProfileToString( + H265Profile::kProfileHighThroughputScreenContentCoding), + "11"); +} + +TEST(H265ProfileTierLevel, TestTierToString) { + EXPECT_EQ(H265TierToString(H265Tier::kTier0), "0"); + EXPECT_EQ(H265TierToString(H265Tier::kTier1), "1"); +} + +TEST(H265ProfileTierLevel, TestStringToProfile) { + // Invalid profiles. + EXPECT_FALSE(StringToH265Profile("0")); + EXPECT_FALSE(StringToH265Profile("12")); + + // Malformed profiles + EXPECT_FALSE(StringToH265Profile("")); + EXPECT_FALSE(StringToH265Profile(" 1")); + EXPECT_FALSE(StringToH265Profile("12x")); + EXPECT_FALSE(StringToH265Profile("x12")); + EXPECT_FALSE(StringToH265Profile("gggg")); + + // Valid profiles. + EXPECT_EQ(StringToH265Profile("1"), H265Profile::kProfileMain); + EXPECT_EQ(StringToH265Profile("2"), H265Profile::kProfileMain10); + EXPECT_EQ(StringToH265Profile("4"), H265Profile::kProfileRangeExtensions); +} + +TEST(H265ProfileTierLevel, TestStringToLevel) { + // Invalid levels. + EXPECT_FALSE(StringToH265Level("0")); + EXPECT_FALSE(StringToH265Level("200")); + + // Malformed levels. + EXPECT_FALSE(StringToH265Level("")); + EXPECT_FALSE(StringToH265Level(" 30")); + EXPECT_FALSE(StringToH265Level("30x")); + EXPECT_FALSE(StringToH265Level("x30")); + EXPECT_FALSE(StringToH265Level("ggggg")); + + // Valid levels. + EXPECT_EQ(StringToH265Level("30"), H265Level::kLevel1); + EXPECT_EQ(StringToH265Level("93"), H265Level::kLevel3_1); + EXPECT_EQ(StringToH265Level("183"), H265Level::kLevel6_1); +} + +TEST(H265ProfileTierLevel, TestStringToTier) { + // Invalid tiers. + EXPECT_FALSE(StringToH265Tier("4")); + EXPECT_FALSE(StringToH265Tier("-1")); + + // Malformed tiers. + EXPECT_FALSE(StringToH265Tier("")); + EXPECT_FALSE(StringToH265Tier(" 1")); + EXPECT_FALSE(StringToH265Tier("t1")); + + // Valid tiers. + EXPECT_EQ(StringToH265Tier("0"), H265Tier::kTier0); + EXPECT_EQ(StringToH265Tier("1"), H265Tier::kTier1); +} + +TEST(H265ProfileTierLevel, TestParseSdpProfileTierLevelAllEmpty) { + const absl::optional profile_tier_level = + ParseSdpForH265ProfileTierLevel(SdpVideoFormat::Parameters()); + EXPECT_TRUE(profile_tier_level); + EXPECT_EQ(H265Profile::kProfileMain, profile_tier_level->profile); + EXPECT_EQ(H265Level::kLevel3_1, profile_tier_level->level); + EXPECT_EQ(H265Tier::kTier0, profile_tier_level->tier); +} + +TEST(H265ProfileTierLevel, TestParseSdpProfileTierLevelPartialEmpty) { + SdpVideoFormat::Parameters params; + params["profile-id"] = "1"; + params["tier-flag"] = "0"; + absl::optional profile_tier_level = + ParseSdpForH265ProfileTierLevel(params); + EXPECT_TRUE(profile_tier_level); + EXPECT_EQ(H265Profile::kProfileMain, profile_tier_level->profile); + EXPECT_EQ(H265Level::kLevel3_1, profile_tier_level->level); + EXPECT_EQ(H265Tier::kTier0, profile_tier_level->tier); + + params.clear(); + params["profile-id"] = "2"; + profile_tier_level = ParseSdpForH265ProfileTierLevel(params); + EXPECT_TRUE(profile_tier_level); + EXPECT_EQ(H265Profile::kProfileMain10, profile_tier_level->profile); + EXPECT_EQ(H265Level::kLevel3_1, profile_tier_level->level); + EXPECT_EQ(H265Tier::kTier0, profile_tier_level->tier); + + params.clear(); + params["level-id"] = "180"; + profile_tier_level = ParseSdpForH265ProfileTierLevel(params); + EXPECT_TRUE(profile_tier_level); + EXPECT_EQ(H265Profile::kProfileMain, profile_tier_level->profile); + EXPECT_EQ(H265Level::kLevel6, profile_tier_level->level); + EXPECT_EQ(H265Tier::kTier0, profile_tier_level->tier); +} + +TEST(H265ProfileTierLevel, TestParseSdpProfileTierLevelInvalid) { + SdpVideoFormat::Parameters params; + + // Invalid profile-tier-level combination. + params["profile-id"] = "1"; + params["tier-flag"] = "1"; + params["level-id"] = "93"; + absl::optional profile_tier_level = + ParseSdpForH265ProfileTierLevel(params); + EXPECT_FALSE(profile_tier_level); + params.clear(); + params["profile-id"] = "1"; + params["tier-flag"] = "4"; + params["level-id"] = "180"; + profile_tier_level = ParseSdpForH265ProfileTierLevel(params); + EXPECT_FALSE(profile_tier_level); + + // Valid profile-tier-level combination. + params.clear(); + params["profile-id"] = "1"; + params["tier-flag"] = "0"; + params["level-id"] = "153"; + profile_tier_level = ParseSdpForH265ProfileTierLevel(params); + EXPECT_TRUE(profile_tier_level); +} + +TEST(H265ProfileTierLevel, TestToStringRoundTrip) { + SdpVideoFormat::Parameters params; + params["profile-id"] = "1"; + params["tier-flag"] = "0"; + params["level-id"] = "93"; + absl::optional profile_tier_level = + ParseSdpForH265ProfileTierLevel(params); + EXPECT_TRUE(profile_tier_level); + EXPECT_EQ("1", H265ProfileToString(profile_tier_level->profile)); + EXPECT_EQ("0", H265TierToString(profile_tier_level->tier)); + EXPECT_EQ("93", H265LevelToString(profile_tier_level->level)); + + params.clear(); + params["profile-id"] = "2"; + params["tier-flag"] = "1"; + params["level-id"] = "180"; + profile_tier_level = ParseSdpForH265ProfileTierLevel(params); + EXPECT_TRUE(profile_tier_level); + EXPECT_EQ("2", H265ProfileToString(profile_tier_level->profile)); + EXPECT_EQ("1", H265TierToString(profile_tier_level->tier)); + EXPECT_EQ("180", H265LevelToString(profile_tier_level->level)); +} + +TEST(H265ProfileTierLevel, TestProfileTierLevelCompare) { + SdpVideoFormat::Parameters params1; + SdpVideoFormat::Parameters params2; + + // None of profile-id/tier-flag/level-id is specified, + EXPECT_TRUE(H265IsSameProfileTierLevel(params1, params2)); + + // Same non-empty PTL + params1["profile-id"] = "1"; + params1["tier-flag"] = "0"; + params1["level-id"] = "120"; + params2["profile-id"] = "1"; + params2["tier-flag"] = "0"; + params2["level-id"] = "120"; + EXPECT_TRUE(H265IsSameProfileTierLevel(params1, params2)); + + // Different profiles. + params1.clear(); + params2.clear(); + params1["profile-id"] = "1"; + params2["profile-id"] = "2"; + EXPECT_FALSE(H265IsSameProfileTierLevel(params1, params2)); + + // Different levels. + params1.clear(); + params2.clear(); + params1["profile-id"] = "1"; + params2["profile-id"] = "1"; + params1["level-id"] = "93"; + params2["level-id"] = "183"; + EXPECT_FALSE(H265IsSameProfileTierLevel(params1, params2)); + + // Different tiers. + params1.clear(); + params2.clear(); + params1["profile-id"] = "1"; + params2["profile-id"] = "1"; + params1["level-id"] = "93"; + params2["level-id"] = "93"; + params1["tier-flag"] = "0"; + params2["tier-flag"] = "1"; + EXPECT_FALSE(H265IsSameProfileTierLevel(params1, params2)); + + // One of the SdpVideoFormat::Parameters is invalid. + params1.clear(); + params2.clear(); + params1["profile-id"] = "1"; + params2["profile-id"] = "1"; + params1["tier-flag"] = "0"; + params2["tier-flag"] = "4"; + EXPECT_FALSE(H265IsSameProfileTierLevel(params1, params2)); +} + +} // namespace webrtc diff --git a/media/base/media_constants.cc b/media/base/media_constants.cc index 911f510afe..94ce3c7b21 100644 --- a/media/base/media_constants.cc +++ b/media/base/media_constants.cc @@ -103,6 +103,7 @@ const char kVp8CodecName[] = "VP8"; const char kVp9CodecName[] = "VP9"; const char kAv1CodecName[] = "AV1"; const char kH264CodecName[] = "H264"; +const char kH265CodecName[] = "H265"; // RFC 6184 RTP Payload Format for H.264 video const char kH264FmtpProfileLevelId[] = "profile-level-id"; @@ -113,6 +114,16 @@ const char kH264FmtpSpsPpsIdrInKeyframe[] = "sps-pps-idr-in-keyframe"; const char kH264ProfileLevelConstrainedBaseline[] = "42e01f"; const char kH264ProfileLevelConstrainedHigh[] = "640c1f"; +// RFC 7798 RTP Payload Format for H.265 video +const char kH265FmtpProfileSpace[] = "profile-space"; +const char kH265FmtpTierFlag[] = "tier-flag"; +const char kH265FmtpProfileId[] = "profile-id"; +const char kH265FmtpLevelId[] = "level-id"; +const char kH265FmtpProfileCompatibilityIndicator[] = + "profile-compatibility-indicator"; +const char kH265FmtpInteropConstraints[] = "interop-constraints"; +const char kH265FmtpTxMode[] = "tx-mode"; + const char kVP9ProfileId[] = "profile-id"; const int kDefaultVideoMaxFramerate = 60; diff --git a/media/base/media_constants.h b/media/base/media_constants.h index ca3213ea0f..3321aac41d 100644 --- a/media/base/media_constants.h +++ b/media/base/media_constants.h @@ -123,6 +123,7 @@ RTC_EXPORT extern const char kVp8CodecName[]; RTC_EXPORT extern const char kVp9CodecName[]; RTC_EXPORT extern const char kAv1CodecName[]; RTC_EXPORT extern const char kH264CodecName[]; +RTC_EXPORT extern const char kH265CodecName[]; // RFC 6184 RTP Payload Format for H.264 video RTC_EXPORT extern const char kH264FmtpProfileLevelId[]; @@ -133,6 +134,19 @@ extern const char kH264FmtpSpsPpsIdrInKeyframe[]; extern const char kH264ProfileLevelConstrainedBaseline[]; extern const char kH264ProfileLevelConstrainedHigh[]; +// RFC 7798 RTP Payload Format for H.265 video. +// According to RFC 7742, the sprop parameters MUST NOT be included +// in SDP generated by WebRTC, so for H.265 we don't handle them, though +// current H.264 implementation honors them when receiving +// sprop-parameter-sets in SDP. +RTC_EXPORT extern const char kH265FmtpProfileSpace[]; +RTC_EXPORT extern const char kH265FmtpTierFlag[]; +RTC_EXPORT extern const char kH265FmtpProfileId[]; +RTC_EXPORT extern const char kH265FmtpLevelId[]; +RTC_EXPORT extern const char kH265FmtpProfileCompatibilityIndicator[]; +RTC_EXPORT extern const char kH265FmtpInteropConstraints[]; +RTC_EXPORT extern const char kH265FmtpTxMode[]; + extern const char kVP9ProfileId[]; extern const int kDefaultVideoMaxFramerate;