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.
  */
 
@@ skipping 50 matching lines @@
 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}};
 
+// Compare H264 levels and handle the level 1b case.
+bool IsLess(webrtc::H264::Level a, webrtc::H264::Level b) {
+  if (a == webrtc::H264::kLevel1_b)
+    return b != webrtc::H264::kLevel1 && b != webrtc::H264::kLevel1_b;
+  if (b == webrtc::H264::kLevel1_b)
+    return a == webrtc::H264::kLevel1;
+  return a < b;
+}
+
+bool IsLevelAsymmetryAllowed(const webrtc::H264::CodecParameterMap& params) {
+  const auto it = params.find("level-asymmetry-allowed");
+  return it != params.end() && strcmp(it->second.c_str(), "1") == 0;
+}
+
 }  // 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);
@@ skipping 41 matching lines @@
     if (profile_idc == pattern.profile_idc &&
         pattern.profile_iop.IsMatch(profile_iop)) {
       return rtc::Optional<ProfileLevelId>({pattern.profile, level});
     }
   }
 
   // Unrecognized profile_idc/profile_iop combination.
   return rtc::Optional<ProfileLevelId>();
 }
 
+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("profile-level-id");
+  return (profile_level_id_it == params.end())
+             ? rtc::Optional<ProfileLevelId>(kDefaultProfileLevelId)
+             : ParseProfileLevelId(profile_level_id_it->second.c_str());

[kthelgason, 2016/11/08 09:27:24]

nit: IMO this is a little too much code for a ternary statement. I think it
would be more readable as a conditional.

[magjed_webrtc, 2016/11/08 15:48:40]

Acknowledged, but I think this is fine.

+}
+
 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);
 }
 
+rtc::Optional<ProfileLevelId> NegotiateProfileLevelId(

[hta-webrtc, 2016/11/08 09:39:06]

The name of this function is misleading - it doesn't negotiate.

It returns the profile-level-id to use, given that the negotiation is over, and
we know the local and remote parameter maps that resulted.

I suggest you name it DecideSendingProfileLevelId.

You need another function for negotiation, which takes the locally supported
ProfileLevelId and the remote parameters from an offer, and returns the
parameters to return in the answer.

[magjed_webrtc, 2016/11/08 15:48:39]

What I'm trying to implement here is the negotiation you describe in the last
section, i.e. what parameters to answer based on a local supported format and an
offered remote format.

+    const CodecParameterMap& local_params,
+    const CodecParameterMap& remote_params) {
+  const rtc::Optional<ProfileLevelId> local_profile_level_id =
+      ParseSdpProfileLevelId(local_params);
+  const rtc::Optional<ProfileLevelId> remote_profile_level_id =
+      ParseSdpProfileLevelId(remote_params);
+  // Check that local and remote have the same H264 Profile.
+  if (!local_profile_level_id || !remote_profile_level_id ||
+      local_profile_level_id->profile != remote_profile_level_id->profile) {
+    return rtc::Optional<ProfileLevelId>();

[kthelgason, 2016/11/08 09:27:24]

Can't you just choose the lower of the two profiles in this case?

[magjed_webrtc, 2016/11/08 15:48:39]

This is unfortunately not allowed according to the spec. We must answer the same
profile. Only the level part is allowed to change.
https://tools.ietf.org/html/rfc6184#section-8.2.2
"When H.264 is offered over RTP using SDP in an Offer/Answer model [8]
   for negotiation for unicast usage, the following limitations and
   rules apply:

   o  The parameters identifying a media format configuration for H.264
      are profile-level-id and packetization-mode.  These media format
      configuration parameters (except for the level part of profile-
      level-id) MUST be used symmetrically; that is, the answerer MUST
      either maintain all configuration parameters or remove the media
      format (payload type) completely if one or more of the parameter
      values are not supported.  Note that the level part of profile-
      level-id includes level_idc, and, for indication of Level 1b when
      profile_idc is equal to 66, 77, or 88, bit 4
      (constraint_set3_flag) of profile-iop.  The level part of profile-
      level-id is changeable."

+  }
+
+  // Parse level-asymmetry-allowed.
+  const bool level_asymmetry_allowed = IsLevelAsymmetryAllowed(local_params) &&
+                                       IsLevelAsymmetryAllowed(remote_params);
+  // Abort if local codec can't cope with the remote H264 level.
+  if (!level_asymmetry_allowed &&
+      IsLess(local_profile_level_id->level, remote_profile_level_id->level)) {
+    return rtc::Optional<ProfileLevelId>();

[hta-webrtc, 2016/11/08 09:39:06]

In the case where we end up here, the local profile-level-id is "smaller" than
the remote profile-level-id, and asymmetry is not allowed.
The only way we can get here (legally) is if the remote set is the offer and the
local is the answer; by the rules of the RFC, this means that we have
successfully negotiated the lower of the two profile-level-ids.

Return rtc::optional(local_profile_level_id).

(If the local had been the offer, the remote would have returned a "smaller or
equal" profile-level-id by the negotiation rules.)

[magjed_webrtc, 2016/11/08 15:48:40]

I see, I misunderstood what level-asymmetry-allowed meant. I have re-read
https://tools.ietf.org/html/rfc6184#section-8.2.2 and updated the code
accordingly. This is actually good, because then this function will always
succeed in negotiating and we don't need to return an rtc::Optional.

+  }
+
+  const Level level = level_asymmetry_allowed ? local_profile_level_id->level
+                                              : remote_profile_level_id->level;
+  return rtc::Optional<ProfileLevelId>(
+      ProfileLevelId(local_profile_level_id->profile, level));
+}
+
 }  // namespace H264
 }  // namespace webrtc