Add unittest for H264BitReader.

content/common/gpu/media/h264_parser_unittest.cc

Index: content/common/gpu/media/h264_parser_unittest.cc
diff --git a/content/common/gpu/media/h264_parser_unittest.cc b/content/common/gpu/media/h264_parser_unittest.cc
index 53d1b3565223c92d1f21aa5634f6c2d0cd9dc3a0..c188bcbdb4aeaa15af4714e6d7f890a16fed5469 100644
--- a/content/common/gpu/media/h264_parser_unittest.cc
+++ b/content/common/gpu/media/h264_parser_unittest.cc
@@ -72,6 +72,216 @@ TEST(H264ParserTest, StreamFileParsing) {
   }
 }
 
+TEST(H264ParserTest, MultiStreamFileParsing) {
+  const FilePath::CharType* test_stream_dir =
+      FILE_PATH_LITERAL("content/common/gpu/testdata/");
+  file_util::FileEnumerator files(FilePath(test_stream_dir), false,
+                                  file_util::FileEnumerator::FILES,
+                                  FILE_PATH_LITERAL("*.h264"));
+
+  for (FilePath file = files.Next(); !file.empty(); file = files.Next()) {
+    file_util::MemoryMappedFile stream;
+    CHECK(stream.Initialize(file)) << "Couldn't open stream file: "
+                                   << file.value();
+    DVLOG(1) << "Parsing file: " << file.value();
+
+    H264Parser parser;
+    parser.SetStream(stream.data(), stream.length());
+
+    // Parse until the end of stream/unsupported stream/error in stream is
+    // found.
+    while (true) {
+      content::H264SliceHeader shdr;
+      content::H264SEIMessage sei_msg;
+      H264NALU nalu;
+      H264Parser::Result res = parser.AdvanceToNextNALU(&nalu);
+      if (res == H264Parser::kEOStream)
+        break;
+      ASSERT_EQ(res, H264Parser::kOk);
+
+      int id;
+      switch (nalu.nal_unit_type) {
+        case H264NALU::kIDRSlice:
+        case H264NALU::kNonIDRSlice:
+          ASSERT_EQ(parser.ParseSliceHeader(nalu, &shdr), H264Parser::kOk);
+          break;
+
+        case H264NALU::kSPS:
+          ASSERT_EQ(parser.ParseSPS(&id), H264Parser::kOk);
+          break;
+
+        case H264NALU::kPPS:
+          ASSERT_EQ(parser.ParsePPS(&id), H264Parser::kOk);
+          break;
+
+        case H264NALU::kSEIMessage:
+          ASSERT_EQ(parser.ParseSEI(&sei_msg), H264Parser::kOk);
+          break;
+
+        default:
+          // Skip unsupported NALU.
+          DVLOG(4) << "Skipping unsupported NALU";
+          break;
+      }
+    }
+  }
+}
+
+class H264BitReaderTest : public ::testing::Test {
+ public:
+  H264BitReaderTest() {}
+  ~H264BitReaderTest() {}

[Ami GONE FROM CHROMIUM, 2012/07/30 23:32:32]

These two aren't adding value. 
In fact I don't actually see any reason to have this class at all.

[xiaomings, 2012/07/30 23:59:34]

Removed.

On 2012/07/30 23:32:32, Ami Fischman wrote:

+
+  bool Initialize(const uint8* data, off_t size) {
+    return reader_.Initialize(data, size);
+  }
+
+  bool ReadBits(int num_bits, int *out) {
+    return reader_.ReadBits(num_bits, out);
+  }
+
+  off_t NumBitsLeft() {
+    return reader_.NumBitsLeft();
+  }
+
+  bool HasMoreRBSPData() {
+    return reader_.HasMoreRBSPData();
+  }
+
+ private:
+  H264Parser::H264BitReader reader_;
+};
+
+TEST_F(H264BitReaderTest, ReadStreamWithoutEscapeAndTrailingZeroBytes) {
+  const unsigned char rbsp[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xa0};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+
+  EXPECT_TRUE(ReadBits(1, &dummy));
+  EXPECT_EQ(dummy, 0x00);
+  EXPECT_EQ(NumBitsLeft(), 47);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0x02);
+  EXPECT_EQ(NumBitsLeft(), 39);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(31, &dummy));
+  EXPECT_EQ(dummy, 0x23456789);
+  EXPECT_EQ(NumBitsLeft(), 8);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(1, &dummy));
+  EXPECT_EQ(dummy, 1);
+  EXPECT_EQ(NumBitsLeft(), 7);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(1, &dummy));
+  EXPECT_EQ(dummy, 0);
+  EXPECT_EQ(NumBitsLeft(), 6);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, EmptyStream) {
+  const unsigned char rbsp[] = {0x80, 0x00, 0x00};
+
+  EXPECT_FALSE(Initialize(rbsp, 0));
+  EXPECT_FALSE(Initialize(rbsp, 1));
+  EXPECT_FALSE(Initialize(rbsp, sizeof(rbsp)));
+}
+
+TEST_F(H264BitReaderTest, SingleByteStream) {
+  const unsigned char rbsp[] = {0x18};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_EQ(NumBitsLeft(), 8);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(4, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_EQ(NumBitsLeft(), 4);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, StopBitOccupyFullByte) {
+  const unsigned char rbsp[] = {0xab, 0x80};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_EQ(NumBitsLeft(), 16);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0xab);
+  EXPECT_EQ(NumBitsLeft(), 8);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, ReadFailure) {
+  const unsigned char rbsp[] = {0x18};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, 1));
+  EXPECT_FALSE(ReadBits(5, &dummy));
+}
+
+TEST_F(H264BitReaderTest, MalformedStream) {
+  const unsigned char rbsp[] = {0x00, 0x00, 0x03, 0x00, 0x00};
+
+  EXPECT_FALSE(Initialize(rbsp, 1));
+  EXPECT_FALSE(Initialize(rbsp, sizeof(rbsp)));
+}
+
+TEST_F(H264BitReaderTest, EscapeSequence) {
+  const unsigned char rbsp[] =
+      {0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x03};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0x00);
+  EXPECT_EQ(NumBitsLeft(), 80);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(24, &dummy));
+  EXPECT_EQ(dummy, 0x00);
+  EXPECT_EQ(NumBitsLeft(), 48);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(15, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_EQ(NumBitsLeft(), 25);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, NonEscapeFollowedByStopBit) {
+  const unsigned char rbsp[] = {0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_TRUE(ReadBits(23, &dummy));
+  EXPECT_EQ(dummy, 0x03);
+  EXPECT_EQ(NumBitsLeft(), 33);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, TrailingZero) {
+  const unsigned char rbsp[] = {0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_TRUE(HasMoreRBSPData());
+  EXPECT_TRUE(ReadBits(15, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   CommandLine::Init(argc, argv);
@@ -91,4 +301,3 @@ int main(int argc, char **argv) {
 
   return RUN_ALL_TESTS();
 }
-