1 files changed, 222 insertions, 0 deletions
diff --git a/third_party/libwebrtc/common_video/h264/pps_parser_unittest.cc b/third_party/libwebrtc/common_video/h264/pps_parser_unittest.cc
new file mode 100644
index 0000000000..652f4c7ce0
--- /dev/null
+++ b/third_party/libwebrtc/common_video/h264/pps_parser_unittest.cc
@@ -0,0 +1,222 @@
+/*
+ *  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 "common_video/h264/pps_parser.h"
+
+#include "common_video/h264/h264_common.h"
+#include "rtc_base/bit_buffer.h"
+#include "rtc_base/buffer.h"
+#include "rtc_base/checks.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+// Contains enough of the image slice to contain slice QP.
+const uint8_t kH264BitstreamChunk[] = {
+    0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x80, 0x20, 0xda, 0x01, 0x40, 0x16,
+    0xe8, 0x06, 0xd0, 0xa1, 0x35, 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x06,
+    0xe2, 0x00, 0x00, 0x00, 0x01, 0x65, 0xb8, 0x40, 0xf0, 0x8c, 0x03, 0xf2,
+    0x75, 0x67, 0xad, 0x41, 0x64, 0x24, 0x0e, 0xa0, 0xb2, 0x12, 0x1e, 0xf8,
+};
+const size_t kPpsBufferMaxSize = 256;
+const uint32_t kIgnored = 0;
+}  // namespace
+
+void WritePps(const PpsParser::PpsState& pps,
+              int slice_group_map_type,
+              int num_slice_groups,
+              int pic_size_in_map_units,
+              rtc::Buffer* out_buffer) {
+  uint8_t data[kPpsBufferMaxSize] = {0};
+  rtc::BitBufferWriter bit_buffer(data, kPpsBufferMaxSize);
+
+  // pic_parameter_set_id: ue(v)
+  bit_buffer.WriteExponentialGolomb(pps.id);
+  // seq_parameter_set_id: ue(v)
+  bit_buffer.WriteExponentialGolomb(pps.sps_id);
+  // entropy_coding_mode_flag: u(1)
+  bit_buffer.WriteBits(pps.entropy_coding_mode_flag, 1);
+  // bottom_field_pic_order_in_frame_present_flag: u(1)
+  bit_buffer.WriteBits(pps.bottom_field_pic_order_in_frame_present_flag ? 1 : 0,
+                       1);
+  // num_slice_groups_minus1: ue(v)
+  RTC_CHECK_GT(num_slice_groups, 0);
+  bit_buffer.WriteExponentialGolomb(num_slice_groups - 1);
+
+  if (num_slice_groups > 1) {
+    // slice_group_map_type: ue(v)
+    bit_buffer.WriteExponentialGolomb(slice_group_map_type);
+    switch (slice_group_map_type) {
+      case 0:
+        for (int i = 0; i < num_slice_groups; ++i) {
+          // run_length_minus1[iGroup]: ue(v)
+          bit_buffer.WriteExponentialGolomb(kIgnored);
+        }
+        break;
+      case 2:
+        for (int i = 0; i < num_slice_groups; ++i) {
+          // top_left[iGroup]: ue(v)
+          bit_buffer.WriteExponentialGolomb(kIgnored);
+          // bottom_right[iGroup]: ue(v)
+          bit_buffer.WriteExponentialGolomb(kIgnored);
+        }
+        break;
+      case 3:
+      case 4:
+      case 5:
+        // slice_group_change_direction_flag: u(1)
+        bit_buffer.WriteBits(kIgnored, 1);
+        // slice_group_change_rate_minus1: ue(v)
+        bit_buffer.WriteExponentialGolomb(kIgnored);
+        break;
+      case 6: {
+        bit_buffer.WriteExponentialGolomb(pic_size_in_map_units - 1);
+
+        uint32_t slice_group_id_bits = 0;
+        // If num_slice_groups is not a power of two an additional bit is
+        // required
+        // to account for the ceil() of log2() below.
+        if ((num_slice_groups & (num_slice_groups - 1)) != 0)
+          ++slice_group_id_bits;
+        while (num_slice_groups > 0) {
+          num_slice_groups >>= 1;
+          ++slice_group_id_bits;
+        }
+
+        for (int i = 0; i < pic_size_in_map_units; ++i) {
+          // slice_group_id[i]: u(v)
+          // Represented by ceil(log2(num_slice_groups_minus1 + 1)) bits.
+          bit_buffer.WriteBits(kIgnored, slice_group_id_bits);
+        }
+        break;
+      }
+      default:
+        RTC_DCHECK_NOTREACHED();
+    }
+  }
+
+  // num_ref_idx_l0_default_active_minus1: ue(v)
+  bit_buffer.WriteExponentialGolomb(kIgnored);
+  // num_ref_idx_l1_default_active_minus1: ue(v)
+  bit_buffer.WriteExponentialGolomb(kIgnored);
+  // weighted_pred_flag: u(1)
+  bit_buffer.WriteBits(pps.weighted_pred_flag ? 1 : 0, 1);
+  // weighted_bipred_idc: u(2)
+  bit_buffer.WriteBits(pps.weighted_bipred_idc, 2);
+
+  // pic_init_qp_minus26: se(v)
+  bit_buffer.WriteSignedExponentialGolomb(pps.pic_init_qp_minus26);
+  // pic_init_qs_minus26: se(v)
+  bit_buffer.WriteExponentialGolomb(kIgnored);
+  // chroma_qp_index_offset: se(v)
+  bit_buffer.WriteExponentialGolomb(kIgnored);
+  // deblocking_filter_control_present_flag: u(1)
+  // constrained_intra_pred_flag: u(1)
+  bit_buffer.WriteBits(kIgnored, 2);
+  // redundant_pic_cnt_present_flag: u(1)
+  bit_buffer.WriteBits(pps.redundant_pic_cnt_present_flag, 1);
+
+  size_t byte_offset;
+  size_t bit_offset;
+  bit_buffer.GetCurrentOffset(&byte_offset, &bit_offset);
+  if (bit_offset > 0) {
+    bit_buffer.WriteBits(0, 8 - bit_offset);
+    bit_buffer.GetCurrentOffset(&byte_offset, &bit_offset);
+  }
+
+  H264::WriteRbsp(data, byte_offset, out_buffer);
+}
+
+class PpsParserTest : public ::testing::Test {
+ public:
+  PpsParserTest() {}
+  ~PpsParserTest() override {}
+
+  void RunTest() {
+    VerifyParsing(generated_pps_, 0, 1, 0);
+    const int kMaxSliceGroups = 17;  // Arbitrarily large.
+    const int kMaxMapType = 6;
+    int slice_group_bits = 0;
+    for (int slice_group = 2; slice_group < kMaxSliceGroups; ++slice_group) {
+      if ((slice_group & (slice_group - 1)) == 0) {
+        // Slice group at a new power of two - increase slice_group_bits.
+        ++slice_group_bits;
+      }
+      for (int map_type = 0; map_type <= kMaxMapType; ++map_type) {
+        if (map_type == 1) {
+          // TODO(sprang): Implement support for dispersed slice group map type.
+          // See 8.2.2.2 Specification for dispersed slice group map type.
+          continue;
+        } else if (map_type == 6) {
+          int max_pic_size = 1 << slice_group_bits;
+          for (int pic_size = 1; pic_size < max_pic_size; ++pic_size)
+            VerifyParsing(generated_pps_, map_type, slice_group, pic_size);
+        } else {
+          VerifyParsing(generated_pps_, map_type, slice_group, 0);
+        }
+      }
+    }
+  }
+
+  void VerifyParsing(const PpsParser::PpsState& pps,
+                     int slice_group_map_type,
+                     int num_slice_groups,
+                     int pic_size_in_map_units) {
+    buffer_.Clear();
+    WritePps(pps, slice_group_map_type, num_slice_groups, pic_size_in_map_units,
+             &buffer_);
+    parsed_pps_ = PpsParser::ParsePps(buffer_.data(), buffer_.size());
+    ASSERT_TRUE(parsed_pps_);
+    EXPECT_EQ(pps.bottom_field_pic_order_in_frame_present_flag,
+              parsed_pps_->bottom_field_pic_order_in_frame_present_flag);
+    EXPECT_EQ(pps.weighted_pred_flag, parsed_pps_->weighted_pred_flag);
+    EXPECT_EQ(pps.weighted_bipred_idc, parsed_pps_->weighted_bipred_idc);
+    EXPECT_EQ(pps.entropy_coding_mode_flag,
+              parsed_pps_->entropy_coding_mode_flag);
+    EXPECT_EQ(pps.redundant_pic_cnt_present_flag,
+              parsed_pps_->redundant_pic_cnt_present_flag);
+    EXPECT_EQ(pps.pic_init_qp_minus26, parsed_pps_->pic_init_qp_minus26);
+    EXPECT_EQ(pps.id, parsed_pps_->id);
+    EXPECT_EQ(pps.sps_id, parsed_pps_->sps_id);
+  }
+
+  PpsParser::PpsState generated_pps_;
+  rtc::Buffer buffer_;
+  absl::optional<PpsParser::PpsState> parsed_pps_;
+};
+
+TEST_F(PpsParserTest, ZeroPps) {
+  RunTest();
+}
+
+TEST_F(PpsParserTest, MaxPps) {
+  generated_pps_.bottom_field_pic_order_in_frame_present_flag = true;
+  generated_pps_.pic_init_qp_minus26 = 25;
+  generated_pps_.redundant_pic_cnt_present_flag = 1;  // 1 bit value.
+  generated_pps_.weighted_bipred_idc = (1 << 2) - 1;  // 2 bit value.
+  generated_pps_.weighted_pred_flag = true;
+  generated_pps_.entropy_coding_mode_flag = true;
+  generated_pps_.id = 2;
+  generated_pps_.sps_id = 1;
+  RunTest();
+
+  generated_pps_.pic_init_qp_minus26 = -25;
+  RunTest();
+}
+
+TEST_F(PpsParserTest, PpsIdFromSlice) {
+  absl::optional<uint32_t> pps_id = PpsParser::ParsePpsIdFromSlice(
+      kH264BitstreamChunk, sizeof(kH264BitstreamChunk));
+  ASSERT_TRUE(pps_id);
+  EXPECT_EQ(2u, *pps_id);
+}
+
+}  // namespace webrtc