Add helper functions for negotiating H264 profile level id

webrtc/common_video/h264/profile_level_id.cc

 /*
  *  Copyright (c) 2016 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 "webrtc/common_video/h264/profile_level_id.h"
 
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 
 #include "webrtc/base/arraysize.h"
 
+namespace webrtc {
+namespace H264 {
+
 namespace {
 
+const char kProfileLevelId[] = "profile-level-id";
+const char kLevelAsymmetryAllowed[] = "level-asymmetry-allowed";
+
 // For level_idc=11 and profile_idc=0x42, 0x4D, or 0x58, the constraint set3
 // flag specifies if level 1b or level 1.1 is used.
 const uint8_t kConstraintSet3Flag = 0x10;
 
 // Convert a string of 8 characters into a byte where the positions containing
 // character c will have their bit set. For example, c = 'x', str = "x1xx0000"
 // will return 0b10110000. constexpr is used so that the pattern table in
 // kProfilePatterns is statically initialized.
 constexpr uint8_t ByteMaskString(char c, const char (&str)[9]) {
   return (str[0] == c) << 7
@@ skipping 18 matching lines @@
 
  private:
   const uint8_t mask_;
   const uint8_t masked_value_;
 };
 
 // Table for converting between profile_idc/profile_iop to H264::Profile.
 struct ProfilePattern {
   const uint8_t profile_idc;
   const BitPattern profile_iop;
-  const webrtc::H264::Profile profile;
+  const Profile profile;
 };
 
 // This is from https://tools.ietf.org/html/rfc6184#section-8.1.
 constexpr ProfilePattern kProfilePatterns[] = {
-    {0x42, BitPattern("x1xx0000"), webrtc::H264::kProfileConstrainedBaseline},
-    {0x4D, BitPattern("1xxx0000"), webrtc::H264::kProfileConstrainedBaseline},
-    {0x58, BitPattern("11xx0000"), webrtc::H264::kProfileConstrainedBaseline},
-    {0x42, BitPattern("x0xx0000"), webrtc::H264::kProfileBaseline},
-    {0x58, BitPattern("10xx0000"), webrtc::H264::kProfileBaseline},
-    {0x4D, BitPattern("0x0x0000"), webrtc::H264::kProfileMain},
-    {0x64, BitPattern("00000000"), webrtc::H264::kProfileHigh},
-    {0x64, BitPattern("00001100"), webrtc::H264::kProfileConstrainedHigh}};
+    {0x42, BitPattern("x1xx0000"), kProfileConstrainedBaseline},
+    {0x4D, BitPattern("1xxx0000"), kProfileConstrainedBaseline},
+    {0x58, BitPattern("11xx0000"), kProfileConstrainedBaseline},
+    {0x42, BitPattern("x0xx0000"), kProfileBaseline},
+    {0x58, BitPattern("10xx0000"), kProfileBaseline},
+    {0x4D, BitPattern("0x0x0000"), kProfileMain},
+    {0x64, BitPattern("00000000"), kProfileHigh},
+    {0x64, BitPattern("00001100"), kProfileConstrainedHigh}};
+
+// Compare H264 levels and handle the level 1b case.
+bool IsLess(Level a, Level b) {
+  if (a == kLevel1_b)
+    return b != kLevel1 && b != kLevel1_b;
+  if (b == kLevel1_b)
+    return a == kLevel1;
+  return a < b;
+}
+
+Level Min(Level a, Level b) {
+  return IsLess(a, b) ? a : b;
+}
+
+bool IsLevelAsymmetryAllowed(const CodecParameterMap& params) {
+  const auto it = params.find(kLevelAsymmetryAllowed);
+  return it != params.end() && strcmp(it->second.c_str(), "1") == 0;
+}
 
 struct LevelConstraint {
   const int max_macroblocks_per_second;
   const int max_macroblock_frame_size;
   const webrtc::H264::Level level;
 };
 
 // This is from ITU-T H.264 (02/2016) Table A-1 – Level limits.
 static constexpr LevelConstraint kLevelConstraints[] = {
     {1485, 99, webrtc::H264::kLevel1},
@@ skipping 10 matching lines @@
     {245760, 8192, webrtc::H264::kLevel4},
     {245760, 8192, webrtc::H264::kLevel4_1},
     {522240, 8704, webrtc::H264::kLevel4_2},
     {589824, 22080, webrtc::H264::kLevel5},
     {983040, 3684, webrtc::H264::kLevel5_1},
     {2073600, 3684, webrtc::H264::kLevel5_2},
 };
 
 }  // anonymous namespace
 
-namespace webrtc {
-namespace H264 {
-
 rtc::Optional<ProfileLevelId> ParseProfileLevelId(const char* str) {
   // The string should consist of 3 bytes in hexadecimal format.
   if (strlen(str) != 6u)
     return rtc::Optional<ProfileLevelId>();
   const uint32_t profile_level_id_numeric = strtol(str, nullptr, 16);
   if (profile_level_id_numeric == 0)
     return rtc::Optional<ProfileLevelId>();
 
   // Separate into three bytes.
   const uint8_t level_idc =
@@ skipping 53 matching lines @@
         level_constraint.max_macroblocks_per_second <=
             max_fps * level_constraint.max_macroblock_frame_size) {
       return rtc::Optional<Level>(level_constraint.level);
     }
   }
 
   // No level supported.
   return rtc::Optional<Level>();
 }
 
+rtc::Optional<ProfileLevelId> ParseSdpProfileLevelId(
+    const CodecParameterMap& params) {
+  // TODO(magjed): The default should really be kProfileBaseline and kLevel1
+  // according to the spec: https://tools.ietf.org/html/rfc6184#section-8.1. In
+  // order to not break backwards compatibility with older versions of WebRTC
+  // where external codecs don't have any parameters, use
+  // kProfileConstrainedBaseline kLevel3_1 instead. This workaround will only be
+  // done in an interim period to allow external clients to update their code.
+  // http://crbug/webrtc/6337.
+  static const ProfileLevelId kDefaultProfileLevelId(
+      kProfileConstrainedBaseline, kLevel3_1);
+
+  const auto profile_level_id_it = params.find(kProfileLevelId);
+  return (profile_level_id_it == params.end())
+             ? rtc::Optional<ProfileLevelId>(kDefaultProfileLevelId)
+             : ParseProfileLevelId(profile_level_id_it->second.c_str());
+}
+
 rtc::Optional<std::string> ProfileLevelIdToString(
     const ProfileLevelId& profile_level_id) {
   // Handle special case level == 1b.
   if (profile_level_id.level == kLevel1_b) {
     switch (profile_level_id.profile) {
       case kProfileConstrainedBaseline:
         return rtc::Optional<std::string>("42f00b");
       case kProfileBaseline:
         return rtc::Optional<std::string>("42100b");
       case kProfileMain:
@@ skipping 24 matching lines @@
     // Unrecognized profile.
     default:
       return rtc::Optional<std::string>();
   }
 
   char str[7];
   snprintf(str, 7u, "%s%02x", profile_idc_iop_string, profile_level_id.level);
   return rtc::Optional<std::string>(str);
 }
 
+// Set level according to https://tools.ietf.org/html/rfc6184#section-8.2.2.
+void GenerateProfileLevelIdForAnswer(
+    const CodecParameterMap& local_supported_params,
+    const CodecParameterMap& remote_offered_params,
+    CodecParameterMap* answer_params) {
+  // Parse profile-level-ids.
+  const rtc::Optional<ProfileLevelId> local_profile_level_id =
+      ParseSdpProfileLevelId(local_supported_params);
+  const rtc::Optional<ProfileLevelId> remote_profile_level_id =
+      ParseSdpProfileLevelId(remote_offered_params);
+  // The local and remote codec must have valid and equal H264 Profiles.
+  RTC_DCHECK(local_profile_level_id);
+  RTC_DCHECK(remote_profile_level_id);
+  RTC_DCHECK_EQ(local_profile_level_id->profile,
+                remote_profile_level_id->profile);
+
+  // Parse level information.
+  const bool level_asymmetry_allowed =
+      IsLevelAsymmetryAllowed(local_supported_params) &&
+      IsLevelAsymmetryAllowed(remote_offered_params);
+  const Level local_level = local_profile_level_id->level;
+  const Level remote_level = remote_profile_level_id->level;
+  const Level min_level = Min(local_level, remote_level);
+
+  // Determine answer level. When level asymmetry is not allowed, level upgrade
+  // is not allowed, i.e., the level in the answer must be equal to or lower
+  // than the level in the offer.
+  const Level answer_level = level_asymmetry_allowed ? local_level : min_level;
+
+  // Set the resulting profile-level-id in the answer parameters.
+  (*answer_params)[kProfileLevelId] = *ProfileLevelIdToString(
+      ProfileLevelId(local_profile_level_id->profile, answer_level));
+}
+
 }  // namespace H264
 }  // namespace webrtc