Add functionality for parsing H264 profile-level-id

webrtc/common_types.cc

 /*
  *  Copyright (c) 2012 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/base/checks.h"
 #include "webrtc/common_types.h"
 
+#include <stdlib.h>
 #include <string.h>
 
+namespace {
+
+// 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[]) {
+  return (str[0] == c) << 7

[hta-webrtc, 2016/10/28 09:55:22]

Can you insert a DCHECK that strlen(str) == 8?
This is not intended for runtime data, so no need for CHECK, but DCHECK will
catch typos in updates.

[magjed_webrtc, 2016/10/28 14:59:27]

It's not possible to call non-constexpr functions like strlen or DCHECK from
constexpr functions. I tried a simpler static_assert(str[8] == '\0') check, but
that didn't work either because str is not constexpr. According to
stackoverflow, the way to do CHECKS in constexpr functions is to throw an
exception, and that will be caught at compile time, but exceptions are disabled
in WebRTC so it doesn't compile. I also tried changing the str argument type
from 'const char str[]' to 'const char str[9]' and that compiles, but still
doesn't catch when it's called with strings of incorrect lengths. It would be
possible to check without exceptions using template magic, but I don't think
it's worth it.

[tommi, 2016/10/28 15:02:20]

as one more try, sizeof() == 9?  or even specify the parameter as |const char
str[9]|?

+      | (str[1] == c) << 6
+      | (str[2] == c) << 5
+      | (str[3] == c) << 4
+      | (str[4] == c) << 3
+      | (str[5] == c) << 2
+      | (str[6] == c) << 1
+      | (str[7] == c) << 0;
+}
+
+// Class for matching bit patterns such as "x1xx0000" where 'x' is allowed to be
+// either 0 or 1.
+class BitPattern {
+ public:
+  constexpr BitPattern(const char str[])
+      : mask_(~ByteMaskString('x', str)),
+        masked_value_(ByteMaskString('1', str)) {}
+
+  bool isMatch(uint8_t value) const { return masked_value_ == (value & mask_); }

[tommi, 2016/10/28 10:09:47]

nit: IsMatch

[magjed_webrtc, 2016/10/28 14:59:27]

Done.

+
+ private:
+  const uint8_t mask_;
+  const uint8_t masked_value_;
+};
+
+// Table for converting between profile_idc/profile_iop to H264Profile.
+struct ProfilePattern {
+  const uint8_t profile_idc;
+  const BitPattern profile_iop;
+  const webrtc::H264Profile profile;
+};
+
+// This is from https://tools.ietf.org/html/rfc6184#section-8.1.
+const ProfilePattern kProfilePatterns[] = {
+    {0x42, BitPattern("x1xx0000"), webrtc::kProfileConstrainedBaseline},
+    {0x4D, BitPattern("1xxx0000"), webrtc::kProfileConstrainedBaseline},
+    {0x58, BitPattern("11xx0000"), webrtc::kProfileConstrainedBaseline},
+    {0x42, BitPattern("x0xx0000"), webrtc::kProfileBaseline},
+    {0x58, BitPattern("10xx0000"), webrtc::kProfileBaseline},
+    {0x4D, BitPattern("0x0x0000"), webrtc::kProfileMain},
+    {0x64, BitPattern("00000000"), webrtc::kProfileHigh},
+    {0x64, BitPattern("00001100"), webrtc::kProfileConstrainedHigh}};
+
+}  // anonymous namespace
+
 namespace webrtc {
 
 StreamDataCounters::StreamDataCounters() : first_packet_time_ms(-1) {}
 
 RTPHeaderExtension::RTPHeaderExtension()
     : hasTransmissionTimeOffset(false),
       transmissionTimeOffset(0),
       hasAbsoluteSendTime(false),
       absoluteSendTime(0),
       hasTransportSequenceNumber(false),
@@ skipping 58 matching lines @@
 VideoCodecH264* VideoCodec::H264() {
   RTC_DCHECK_EQ(codecType, kVideoCodecH264);
   return &codecSpecific.H264;
 }
 
 const VideoCodecH264& VideoCodec::H264() const {
   RTC_DCHECK_EQ(codecType, kVideoCodecH264);
   return codecSpecific.H264;
 }
 
+rtc::Optional<H264ProfileLevelId> ParseH264ProfileLevelId(const char* str) {

[hta-webrtc, 2016/10/28 09:55:23]

Same comment goes for this function.

[magjed_webrtc, 2016/10/28 14:59:27]

I check the string length in this function and return nothing if it's not 6. The
input string will come from SDP over the network so we should simply reject
malformed codecs rather than crash with CHECKs in this function.

+  // The string should consist of 3 bytes in hexadecimal format.
+  if (strlen(str) != 6u)
+    return rtc::Optional<H264ProfileLevelId>();
+  const long profile_level_id_numeric = strtol(str, nullptr, 16);
+  if (profile_level_id_numeric == 0)
+    return rtc::Optional<H264ProfileLevelId>();
+
+  // Separate into three bytes.
+  const uint8_t level_idc =
+      static_cast<uint8_t>(profile_level_id_numeric & 0xFF);
+  const uint8_t profile_iop =
+      static_cast<uint8_t>((profile_level_id_numeric >> 8) & 0xFF);
+  const uint8_t profile_idc =
+      static_cast<uint8_t>((profile_level_id_numeric >> 16) & 0xFF);
+
+  // Parse level based on level_idc and constraint set 3 flag.
+  H264Level level;
+  switch (level_idc) {
+    case kH264Level1_1:
+      level = (profile_iop & kConstraintSet3Flag) != 0 ? kH264Level1_b
+                                                       : kH264Level1_1;
+      break;
+    case kH264Level1:
+    case kH264Level1_2:
+    case kH264Level1_3:
+    case kH264Level2:
+    case kH264Level2_1:
+    case kH264Level2_2:
+    case kH264Level3:
+    case kH264Level3_1:
+    case kH264Level3_2:
+    case kH264Level4:
+    case kH264Level4_1:
+    case kH264Level4_2:
+    case kH264Level5:
+    case kH264Level5_1:
+    case kH264Level5_2:
+      level = static_cast<H264Level>(level_idc);
+      break;
+    default:
+      // Unrecognized level_idc.
+      return rtc::Optional<H264ProfileLevelId>();
+  }
+
+  // Parse profile_idc/profile_iop into a H264Profile enum.
+  for (const ProfilePattern& pattern : kProfilePatterns) {
+    if (profile_idc == pattern.profile_idc &&
+        pattern.profile_iop.isMatch(profile_iop)) {
+      return rtc::Optional<H264ProfileLevelId>({pattern.profile, level});
+    }
+  }
+
+  // Unrecognized profile_idc/profile_iop combination.
+  return rtc::Optional<H264ProfileLevelId>();
+}
+
 }  // namespace webrtc