Add function for getting supported H264 level from max resolution and fps

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 {
 
 // 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.
@@ skipping 34 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}};
 
+struct LevelConstraint {
+  const int max_macroblocks_per_second;
+  const int max_macroblock_frame_size;

[kthelgason, 2016/11/02 17:26:21]

super-nit: maybe use size_t for these unless there is a good reason not to. Not
worth updating CL just for that though.

[magjed_webrtc, 2016/11/03 12:16:51]

This is a static table so we can statically verify it won't overflow. We store
pixel counts in ints in a lot of places in WebRTC, but maybe we should change to
size_t at some point (maybe 198000x72000 resolution isn't too far away).

+  const webrtc::H264::Level level;
+};
+
+// This is from the H264 spec.
+static constexpr LevelConstraint kLevelConstraints[] = {
+    {1485, 99, webrtc::H264::kLevel1},
+    {1485, 99, webrtc::H264::kLevel1_b},
+    {3000, 396, webrtc::H264::kLevel1_1},
+    {6000, 396, webrtc::H264::kLevel1_2},
+    {11880, 396, webrtc::H264::kLevel1_3},
+    {11880, 396, webrtc::H264::kLevel2},
+    {19800, 792, webrtc::H264::kLevel2_1},
+    {20250, 1620, webrtc::H264::kLevel2_2},
+    {40500, 1620, webrtc::H264::kLevel3},
+    {108000, 3600, webrtc::H264::kLevel3_1},
+    {216000, 5120, webrtc::H264::kLevel3_2},
+    {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);
@@ 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>();
 }
 
+Level SupportedLevel(int max_frame_pixel_count, int max_fps) {
+  static const int kPixelsPerMacroblock = 16 * 16;
+
+  for (int i = arraysize(kLevelConstraints) - 1; i >= 0; --i) {
+    const LevelConstraint& level_constraint = kLevelConstraints[i];
+    if (level_constraint.max_macroblock_frame_size * kPixelsPerMacroblock <=
+            max_frame_pixel_count &&
+        level_constraint.max_macroblocks_per_second <=
+            max_fps * level_constraint.max_macroblock_frame_size) {
+      return level_constraint.level;
+    }
+  }
+
+  // Return lowest possible level.
+  return kLevel1;

[kthelgason, 2016/11/02 17:26:21]

Is this really the correct thing to do in this situation? If we reach this point
obviously there was something wrong with the input to the function, perhaps it
would be better to somehow signal that?

[magjed_webrtc, 2016/11/03 12:16:51]

No, it's not strictly correct. I could do NOT_REACHED here, but it's an ugly
requirement that the input should cover at least level 1. I decided to return an
rtc::Optional instead and added some tests for it.

+}
+
 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 "42f00b";
       case kProfileBaseline:
         return "42100b";
       case kProfileMain:
         return "4D100b";
@@ skipping 25 matching lines @@
       return std::string();
   }
 
   char str[7];
   snprintf(str, 7u, "%s%02x", profile_idc_iop_string, profile_level_id.level);
   return str;
 }
 
 }  // namespace H264
 }  // namespace webrtc