Add vaapi_h264_decoder_test.

content/common/gpu/media/vaapi_h264_decoder_unittest.cc

Index: content/common/gpu/media/vaapi_h264_decoder_unittest.cc
diff --git a/content/common/gpu/media/vaapi_h264_decoder_unittest.cc b/content/common/gpu/media/vaapi_h264_decoder_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bfbb6e0f5b12a7ce727c156bf1fbe5748c465137
--- /dev/null
+++ b/content/common/gpu/media/vaapi_h264_decoder_unittest.cc
@@ -0,0 +1,320 @@
+// Copyright 2013 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 <string>
+
+// This has to be included first.
+// See http://code.google.com/p/googletest/issues/detail?id=371
+#include "testing/gtest/include/gtest/gtest.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "content/common/gpu/media/vaapi_h264_decoder.h"
+#include "media/base/video_decoder_config.h"
+
+// This program is run like this:
+// DISPLAY=:0 ./vaapi_h264_run_decoder --input_file input.264

[Pawel Osciak, 2013/11/29 04:25:13]

s/vaapi_h264_run_decoder/vaapi_h264_decoder_unittest/

[chihchung, 2013/11/29 14:06:30]

Done.

+// [--output_file output.yuv] [--md5sum expected_md5_hex]
+//
+// The input is read from input.264. The output is written to output.yuv if it
+// is given. It also verifies the MD5 sum of the decoded YUV data if the
+// expected MD5 sum is given.
+
+namespace content {
+namespace {
+
+// These are the command line parameters
+base::FilePath g_input_file;
+base::FilePath g_output_file;
+std::string g_md5sum;
+
+// This class encapsulates the use of VaapiH264Decoder to a simpler interface.
+// It reads an H.264 Annex B bytestream from a file and outputs the decoded
+// frames (in I420 format) to another file.
+//
+// To use the class, construct an instance, call Initialize() to specify the
+// input and output file path, then call Run() to decode the whole stream and
+// output the frames.
+//
+// This class must be created, called and destroyed on a single thread, and
+// does nothing internally on any other thread.
+class VaapiH264DecoderLoop {
+ public:
+  VaapiH264DecoderLoop();
+  ~VaapiH264DecoderLoop();
+
+  // Initialize the decoder. Return true if successful.
+  bool Initialize(base::FilePath input_file, base::FilePath output_file);
+
+  // Run the decode loop. The decoded data is written to the file specified by
+  // output_file in Initialize().  Return true if all decoding is successful.
+  bool Run();
+
+  // Get the MD5 sum of the decoded data.
+  std::string GetMD5Sum();
+
+ private:
+  void ReportToUMA(VaapiH264Decoder::VAVDAH264DecoderFailure error) {}
+
+  // Callback from the decoder when a picture is decoded.
+  void OutputPicture(int32 input_id,
+                     const scoped_refptr<VASurface>& va_surface);
+
+  // Recycle one surface and put it on available_surfaces_ list.
+  void RecycleSurface(VASurfaceID va_surface_id);
+
+  // Give all surfaces in available_surfaces_ to the decoder.
+  void RefillSurfaces();
+
+  // Free the current set of surfaces and allocate a new set of
+  // surfaces. Returns true when successful.
+  bool AllocateNewSurfaces();
+
+  // Use the data in the frame: write to file and update MD5 sum.
+  bool ProcessVideoFrame(const scoped_refptr<media::VideoFrame>& frame);
+
+  scoped_ptr<VaapiH264Decoder> decoder_;
+  scoped_ptr<VaapiWrapper> wrapper_;
+  std::string data_;            // data read from input_file
+  base::FilePath output_file_;  // output data is written to this file
+  std::vector<VASurfaceID> available_surfaces_;
+
+  // These members (x_display_, num_outputted_pictures_, num_surfaces_)
+  // need to be initialized and possibly freed manually.
+  Display* x_display_;
+  int num_outputted_pictures_;  // number of pictures already outputted
+  size_t num_surfaces_;  // number of surfaces in the current set of surfaces
+  base::MD5Context md5_context_;
+};
+
+VaapiH264DecoderLoop::VaapiH264DecoderLoop()
+    : x_display_(NULL), num_outputted_pictures_(0), num_surfaces_(0) {
+  base::MD5Init(&md5_context_);
+}
+
+VaapiH264DecoderLoop::~VaapiH264DecoderLoop() {
+  // We need to destruct decoder and wrapper first because:
+  // (1) The decoder has a reference to the wrapper.
+  // (2) The wrapper has a reference to x_display_.
+  decoder_.reset();
+  wrapper_.reset();
+
+  if (x_display_) {
+    XCloseDisplay(x_display_);
+  }
+}
+
+bool VaapiH264DecoderLoop::Initialize(base::FilePath input_file,
+                                      base::FilePath output_file) {
+  x_display_ = XOpenDisplay(NULL);
+  if (!x_display_) {
+    LOG(ERROR) << "Can't open X display";
+    return false;
+  }
+
+  media::VideoCodecProfile profile = media::H264PROFILE_HIGH;
+  base::Closure report_error_cb = base::Bind(&VaapiH264DecoderLoop::ReportToUMA,
+                                             base::Unretained(this),
+                                             VaapiH264Decoder::VAAPI_ERROR);
+  wrapper_ = VaapiWrapper::Create(profile, x_display_, report_error_cb);
+  if (!wrapper_.get()) {
+    LOG(ERROR) << "Can't create vaapi wrapper";
+    return false;
+  }
+
+  decoder_.reset(new VaapiH264Decoder(
+      wrapper_.get(),
+      base::Bind(&VaapiH264DecoderLoop::OutputPicture, base::Unretained(this)),
+      base::Bind(&VaapiH264DecoderLoop::ReportToUMA, base::Unretained(this))));
+
+  if (!base::ReadFileToString(input_file, &data_)) {
+    LOG(ERROR) << "failed to read input data from " << input_file.value();
+    return false;
+  }
+
+  const int input_id = 0;  // We don't use input_id in this class.
+  decoder_->SetStream(
+      reinterpret_cast<const uint8*>(data_.c_str()), data_.size(), input_id);
+
+  // This creates or truncates output_file.
+  // Without it, AppendToFile() will not work.
+  if (!output_file.empty()) {
+    if (file_util::WriteFile(output_file, NULL, 0) != 0) {
+      return false;
+    }
+    output_file_ = output_file;
+  }
+
+  return true;
+}
+
+bool VaapiH264DecoderLoop::Run() {
+  while (1) {
+    switch (decoder_->Decode()) {
+      case VaapiH264Decoder::kDecodeError:
+        LOG(ERROR) << "Decode Error";
+        return false;
+      case VaapiH264Decoder::kAllocateNewSurfaces:
+        VLOG(1) << "Allocate new surfaces";
+        if (!AllocateNewSurfaces()) {
+          LOG(ERROR) << "Failed to allocate new surfaces";
+          return false;
+        }
+        break;
+      case VaapiH264Decoder::kRanOutOfStreamData: {
+        bool rc = decoder_->Flush();
+        VLOG(1) << "Flush returns " << rc;
+        return rc;
+      }
+      case VaapiH264Decoder::kRanOutOfSurfaces:
+        VLOG(1) << "Ran out of surfaces";
+        RefillSurfaces();
+        break;
+    }
+  }
+}
+
+std::string VaapiH264DecoderLoop::GetMD5Sum() {
+  base::MD5Digest digest;
+  base::MD5Final(&digest, &md5_context_);
+  return MD5DigestToBase16(digest);
+}
+
+bool VaapiH264DecoderLoop::ProcessVideoFrame(
+    const scoped_refptr<media::VideoFrame>& frame) {
+  for (size_t i = 0; i < media::VideoFrame::NumPlanes(frame->format()); i++) {
+    uint8* data = frame->data(i);
+    int bytes = frame->row_bytes(i);
+    for (int j = 0; j < frame->rows(i); j++) {
+      const char* buf = reinterpret_cast<const char*>(data);
+      base::MD5Update(&md5_context_, base::StringPiece(buf, bytes));
+      if (!output_file_.empty()) {
+        int written = file_util::AppendToFile(output_file_, buf, bytes);
+        if (written != bytes) {
+          return false;
+        }
+      }
+      data += frame->stride(i);
+    }
+  }
+  return true;
+}
+
+void VaapiH264DecoderLoop::OutputPicture(
+    int32 input_id,
+    const scoped_refptr<VASurface>& va_surface) {
+  VLOG(1) << "OutputPicture: picture " << num_outputted_pictures_++;
+  scoped_refptr<media::VideoFrame> frame =
+      wrapper_->VideoFrameFromVASurface(va_surface->id());
+  if (frame.get()) {
+    if (!ProcessVideoFrame(frame)) {
+      LOG(ERROR) << "write to file failed";
+    }
+  } else {
+    LOG(ERROR) << "Cannot convert surface to I420.";
+  }
+}
+
+void VaapiH264DecoderLoop::RecycleSurface(VASurfaceID va_surface_id) {
+  available_surfaces_.push_back(va_surface_id);
+}
+
+void VaapiH264DecoderLoop::RefillSurfaces() {
+  for (size_t i = 0; i < available_surfaces_.size(); i++) {
+    VASurface::ReleaseCB release_cb = base::Bind(
+        &VaapiH264DecoderLoop::RecycleSurface, base::Unretained(this));
+    scoped_refptr<VASurface> surface(
+        new VASurface(available_surfaces_[i], release_cb));
+    decoder_->ReuseSurface(surface);
+  }
+  available_surfaces_.clear();
+}
+
+bool VaapiH264DecoderLoop::AllocateNewSurfaces() {
+  CHECK_EQ(num_surfaces_, available_surfaces_.size())
+      << "not all surfaces are returned";
+
+  available_surfaces_.clear();
+  wrapper_->DestroySurfaces();
+
+  gfx::Size size = decoder_->GetPicSize();
+  num_surfaces_ = decoder_->GetRequiredNumOfPictures();
+  return wrapper_->CreateSurfaces(size, num_surfaces_, &available_surfaces_);
+}
+
+TEST(VaapiH264DecoderTest, TestDecode) {
+  base::FilePath input_file = g_input_file;
+  base::FilePath output_file = g_output_file;
+  std::string md5sum = g_md5sum;
+
+  // If nothing specified, use the default file in the source tree.
+  if (input_file.empty() && output_file.empty() && md5sum.empty()) {
+    input_file = base::FilePath("test-25fps.h264");

[Pawel Osciak, 2013/11/29 04:25:13]

Please consider putting the default filenams as a const at the top of the file
and overwrite if a param is passed like we do in vea/vda test. Easier to spot I
feel.

[chihchung, 2013/11/29 14:06:30]

Done.

+    md5sum = "3af866863225b956001252ebeccdb71d";

[Pawel Osciak, 2013/11/29 04:25:13]

Ditto.

[chihchung, 2013/11/29 14:06:30]

Done.

+  } else if (input_file.empty()) {
+    LOG(FATAL) << "Need to specify --input_file";
+  }
+
+  VLOG(1) << "Input File: " << input_file.value();
+  VLOG(1) << "Output File: " << output_file.value();
+  VLOG(1) << "Expected MD5 sum: " << md5sum;
+
+  content::VaapiH264DecoderLoop loop;
+  if (!loop.Initialize(input_file, output_file)) {
+    LOG(FATAL) << "initialize decoder loop failed";

[Pawel Osciak, 2013/11/29 04:25:13]

This should fail the test instead (ASSERT_TRUE).

In general, I recommend replace most if not all if (!foo.Bar()) failures in this
test with either EXPECT_* or ASSERT_* so that we fail the test and have
meaningful messages at failure site.
Should be no need to use LOG(ERROR) then also.

[chihchung, 2013/11/29 14:06:30]

Done.

[Pawel Osciak, 2013/12/03 08:52:06]

I said ASSERT/REQUIRE, not CHECK :)
CHECK is a debug macro which is used like assert() from C. It will simply crash
us.
ASSERT_*() are gtest macros, which are used to fail the test properly. 

[chihchung, 2013/12/03 10:57:40]

Done.

+  }
+  if (!loop.Run()) {
+    LOG(FATAL) << "run decoder loop failed";
+  }
+
+  if (!md5sum.empty()) {
+    std::string actual = loop.GetMD5Sum();
+    VLOG(1) << "Actual MD5 sum: " << actual;
+    EXPECT_EQ(md5sum, actual);
+  }
+}
+
+}  // namespace
+}  // namespace content
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
+  CommandLine::Init(argc, argv);
+
+  // Needed to enable DVLOG through --vmodule.

[Pawel Osciak, 2013/11/29 04:25:13]

You don't have a single DVLOG in this file though ;)
It's probably better to use DVLOG than VLOG.

[chihchung, 2013/11/29 14:06:30]

I don't really understand this magic :)
I think I'll keep VLOG as this is not production code, so performance is not too
important.

[Pawel Osciak, 2013/12/03 08:52:06]

It's more about reducing the amount of output from the test for successful runs.
If this test is to be run on bots (and I hope it will be), it'd produce lots
output even on successful runs and logs will be unnecessarily big.
Although we still need to --vmodule/--v to enable vlogs, so I guess it's ok.

+  logging::LoggingSettings settings;
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+  settings.dcheck_state =
+      logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
+  CHECK(logging::InitLogging(settings));
+
+  // Process command line.
+  CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  CHECK(cmd_line);
+
+  CommandLine::SwitchMap switches = cmd_line->GetSwitches();
+  for (CommandLine::SwitchMap::const_iterator it = switches.begin();
+       it != switches.end();
+       ++it) {
+    if (it->first == "input_file") {
+      content::g_input_file = base::FilePath(it->second);
+      continue;
+    }
+    if (it->first == "output_file") {
+      content::g_output_file = base::FilePath(it->second);
+      continue;
+    }
+    if (it->first == "md5sum") {
+      content::g_md5sum = it->second;
+      continue;
+    }
+    if (it->first == "v" || it->first == "vmodule")
+      continue;
+    LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
+  }
+
+  return RUN_ALL_TESTS();
+}