Add unittest for H264BitReader.

content/common/gpu/media/h264_parser_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "content/common/gpu/media/h264_parser.h"
 
 using content::H264Parser;
 using content::H264NALU;
 
 const FilePath::CharType* test_stream_filename =
     FILE_PATH_LITERAL("content/common/gpu/testdata/test-25fps.h264");
 // Number of NALUs in the stream to be parsed.
 int num_nalus = 759;
 
 TEST(H264ParserTest, StreamFileParsing) {

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

Is there any reason for this to still exist??

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

I will keep the original one and remove the one to test multiple files.
On 2012/07/30 23:32:32, Ami Fischman wrote:

   FilePath fp(test_stream_filename);
   file_util::MemoryMappedFile stream;
   CHECK(stream.Initialize(fp)) << "Couldn't open stream file: "
                                << test_stream_filename;
   DVLOG(1) << "Parsing file: " << test_stream_filename;
 
   H264Parser parser;
   parser.SetStream(stream.data(), stream.length());
 
   // Parse until the end of stream/unsupported stream/error in stream is found.
@@ skipping 33 matching lines @@
         break;
 
       default:
         // Skip unsupported NALU.
         DVLOG(4) << "Skipping unsupported NALU";
         break;
     }
   }
 }
 
+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);
 
   const CommandLine::SwitchMap& switches =
       CommandLine::ForCurrentProcess()->GetSwitches();
   for (CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_stream") {
       test_stream_filename = it->second.c_str();
     } else if (it->first == "num_nalus") {
       CHECK(base::StringToInt(it->second, &num_nalus));
     } else {
       LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
     }
   }
 
   return RUN_ALL_TESTS();
 }
-