H264 HW encode using MediaFoundation

media/gpu/video_encode_accelerator_unittest.cc

 // 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 <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
@@ skipping 14 matching lines @@
 #include "media/gpu/v4l2_video_encode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_video_encode_accelerator.h"
 #include "media/gpu/vaapi_wrapper.h"
 // Status has been defined as int in Xlib.h.
 #undef Status
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 #elif defined(OS_MACOSX)
 #include "media/gpu/vt_video_encode_accelerator_mac.h"
+#elif defined(OS_WIN)
+#include "media/gpu/media_foundation_video_encode_accelerator_win.h"
 #else
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
 namespace media {
 namespace {
 
 const VideoPixelFormat kInputFormat = PIXEL_FORMAT_I420;
 
 // The absolute differences between original frame and decoded frame usually
@@ skipping 29 matching lines @@
 const unsigned int kMinFramesForBitrateTests = 300;
 // The percentiles to measure for encode latency.
 const unsigned int kLoggedLatencyPercentiles[] = {50, 75, 95};
 
 // The syntax of multiple test streams is:
 //  test-stream1;test-stream2;test-stream3
 // The syntax of each test stream is:
 // "in_filename:width:height:profile:out_filename:requested_bitrate
 //  :requested_framerate:requested_subsequent_bitrate
 //  :requested_subsequent_framerate"
+// Instead of ":", "," can be used as a seperator as well. Note that ":" does
+// not work on Windows as it interferes with file paths.
 // - |in_filename| must be an I420 (YUV planar) raw stream
 //   (see http://www.fourcc.org/yuv.php#IYUV).
 // - |width| and |height| are in pixels.
 // - |profile| to encode into (values of VideoCodecProfile).
 // - |out_filename| filename to save the encoded stream to (optional). The
 //   format for H264 is Annex-B byte stream. The format for VP8 is IVF. Output
 //   stream is saved for the simple encode test only. H264 raw stream and IVF
 //   can be used as input of VDA unittest. H264 raw stream can be played by
 //   "mplayer -fps 25 out.h264" and IVF can be played by mplayer directly.
 //   Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
 // Further parameters are optional (need to provide preceding positional
 // parameters if a specific subsequent parameter is required):
 // - |requested_bitrate| requested bitrate in bits per second.
 // - |requested_framerate| requested initial framerate.
 // - |requested_subsequent_bitrate| bitrate to switch to in the middle of the
 //                                  stream.
 // - |requested_subsequent_framerate| framerate to switch to in the middle
 //                                    of the stream.
 //   Bitrate is only forced for tests that test bitrate.
 const char* g_default_in_filename = "bear_320x192_40frames.yuv";
-#if !defined(OS_MACOSX)
-const char* g_default_in_parameters = ":320:192:1:out.h264:200000";
-#else
-const char* g_default_in_parameters = ":320:192:0:out.h264:200000";
-#endif
+
+#if defined(OS_CHROMEOS)
+const base::FilePath::CharType* g_default_in_parameters =
+    FILE_PATH_LITERAL(":320:192:1:out.h264:200000");
+#elif defined(OS_MACOSX) || defined(OS_WIN)
+const base::FilePath::CharType* g_default_in_parameters =
+    FILE_PATH_LITERAL(",320,192,0,out.h264,200000");
+#endif  // defined(OS_CHROMEOS)
 
 // Enabled by including a --fake_encoder flag to the command line invoking the
 // test.
 bool g_fake_encoder = false;
 
 // Environment to store test stream data for all test cases.
 class VideoEncodeAcceleratorTestEnvironment;
 VideoEncodeAcceleratorTestEnvironment* g_env;
 
 // The number of frames to be encoded. This variable is set by the switch
@@ skipping 85 matching lines @@
 }
 
 static bool IsH264(VideoCodecProfile profile) {
   return profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX;
 }
 
 static bool IsVP8(VideoCodecProfile profile) {
   return profile >= VP8PROFILE_MIN && profile <= VP8PROFILE_MAX;
 }
 
+// Helper functions to do string conversions.
+static base::FilePath::StringType StringToFilePathStringType(
+    const std::string& str) {
+#if defined(OS_WIN)
+  return base::UTF8ToWide(str);
+#else
+  return str;
+#endif  // defined(OS_WIN)
+}
+
+static std::string FilePathStringTypeToString(
+    const base::FilePath::StringType& str) {
+#if defined(OS_WIN)
+  return base::WideToUTF8(str);
+#else
+  return str;
+#endif  // defined(OS_WIN)
+}
+
 // ARM performs CPU cache management with CPU cache line granularity. We thus
 // need to ensure our buffers are CPU cache line-aligned (64 byte-aligned).
 // Otherwise newer kernels will refuse to accept them, and on older kernels
 // we'll be treating ourselves to random corruption.
 // Since we are just mapping and passing chunks of the input file directly to
 // the VEA as input frames to avoid copying large chunks of raw data on each
 // frame and thus affecting performance measurements, we have to prepare a
 // temporary file with all planes aligned to 64-byte boundaries beforehand.
 static void CreateAlignedInputStreamFile(const gfx::Size& coded_size,
                                          TestStream* test_stream) {
@@ skipping 30 matching lines @@
     visible_bpl[i] = VideoFrame::RowBytes(i, kInputFormat,
                                           test_stream->visible_size.width());
     visible_plane_rows[i] =
         VideoFrame::Rows(i, kInputFormat, test_stream->visible_size.height());
     const size_t padding_rows =
         VideoFrame::Rows(i, kInputFormat, coded_size.height()) -
         visible_plane_rows[i];
     padding_sizes[i] = padding_rows * coded_bpl[i] + Align64Bytes(size) - size;
   }
 
-  base::FilePath src_file(test_stream->in_filename);
+  base::FilePath src_file(StringToFilePathStringType(test_stream->in_filename));
   int64_t src_file_size = 0;
   LOG_ASSERT(base::GetFileSize(src_file, &src_file_size));
 
   size_t visible_buffer_size =
       VideoFrame::AllocationSize(kInputFormat, test_stream->visible_size);
   LOG_ASSERT(src_file_size % visible_buffer_size == 0U)
       << "Stream byte size is not a product of calculated frame byte size";
 
   test_stream->num_frames = src_file_size / visible_buffer_size;
 
@@ skipping 17 matching lines @@
                visible_bpl[i]);
         src_ptr += visible_bpl[i];
         dest_offset += coded_bpl[i];
       }
       dest_offset += padding_sizes[i];
     }
     src_offset += visible_buffer_size;
   }
   src.Close();
 
+#if defined(OS_POSIX)
   // Assert that memory mapped of file starts at 64 byte boundary. So each
   // plane of frames also start at 64 byte boundary.
   ASSERT_EQ(reinterpret_cast<off_t>(&test_stream->aligned_in_file_data[0]) & 63,
             0)
       << "File should be mapped at a 64 byte boundary";
+#endif  // defined(OS_POSIX)
 
   LOG_ASSERT(test_stream->num_frames > 0UL);
 }
 
 // Parse |data| into its constituent parts, set the various output fields
 // accordingly, read in video stream, and store them to |test_streams|.
 static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
                                        ScopedVector<TestStream>* test_streams) {
   // Split the string to individual test stream data.
   std::vector<base::FilePath::StringType> test_streams_data =
       base::SplitString(data, base::FilePath::StringType(1, ';'),
                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   LOG_ASSERT(test_streams_data.size() >= 1U) << data;
 
   // Parse each test stream data and read the input file.
   for (size_t index = 0; index < test_streams_data.size(); ++index) {
     std::vector<base::FilePath::StringType> fields = base::SplitString(
-        test_streams_data[index], base::FilePath::StringType(1, ':'),
+        test_streams_data[index], base::FilePath::StringType(1, ','),
         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    // Try using ":" as the seperator if "," isn't used.
+    if (fields.size() == 1U) {
+      fields = base::SplitString(test_streams_data[index],
+                                 base::FilePath::StringType(1, ':'),
+                                 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    }
     LOG_ASSERT(fields.size() >= 4U) << data;
     LOG_ASSERT(fields.size() <= 9U) << data;
     TestStream* test_stream = new TestStream();
 
-    test_stream->in_filename = fields[0];
+    test_stream->in_filename = FilePathStringTypeToString(fields[0]);
     int width, height;
     bool result = base::StringToInt(fields[1], &width);
     LOG_ASSERT(result);
     result = base::StringToInt(fields[2], &height);
     LOG_ASSERT(result);
     test_stream->visible_size = gfx::Size(width, height);
     LOG_ASSERT(!test_stream->visible_size.IsEmpty());
     int profile;
     result = base::StringToInt(fields[3], &profile);
     LOG_ASSERT(result);
     LOG_ASSERT(profile > VIDEO_CODEC_PROFILE_UNKNOWN);
     LOG_ASSERT(profile <= VIDEO_CODEC_PROFILE_MAX);
     test_stream->requested_profile = static_cast<VideoCodecProfile>(profile);
 
     if (fields.size() >= 5 && !fields[4].empty())
-      test_stream->out_filename = fields[4];
+      test_stream->out_filename = FilePathStringTypeToString(fields[4]);
 
     if (fields.size() >= 6 && !fields[5].empty())
       LOG_ASSERT(
           base::StringToUint(fields[5], &test_stream->requested_bitrate));
 
     if (fields.size() >= 7 && !fields[6].empty())
       LOG_ASSERT(
           base::StringToUint(fields[6], &test_stream->requested_framerate));
 
     if (fields.size() >= 8 && !fields[7].empty()) {
@@ skipping 242 matching lines @@
   // Flush the decoder.
   void Flush();
 
  private:
   void InitializeCB(bool success);
   void DecodeDone(DecodeStatus status);
   void FlushDone(DecodeStatus status);
   void VerifyOutputFrame(const scoped_refptr<VideoFrame>& output_frame);
   void Decode();
 
-  enum State { UNINITIALIZED, INITIALIZED, DECODING, ERROR };
+  enum State { UNINITIALIZED, INITIALIZED, DECODING, DECODER_ERROR };
 
   const VideoCodecProfile profile_;
   std::unique_ptr<FFmpegVideoDecoder> decoder_;
   VideoDecoder::DecodeCB decode_cb_;
   // Decode callback of an EOS buffer.
   VideoDecoder::DecodeCB eos_decode_cb_;
   // Callback of Flush(). Called after all frames are decoded.
   const base::Closure flush_complete_cb_;
   const base::Closure decode_error_cb_;
   State decoder_state_;
@@ skipping 42 matching lines @@
                  base::Unretained(this)),
       base::Bind(&VideoFrameQualityValidator::VerifyOutputFrame,
                  base::Unretained(this)));
 }
 
 void VideoFrameQualityValidator::InitializeCB(bool success) {
   if (success) {
     decoder_state_ = INITIALIZED;
     Decode();
   } else {
-    decoder_state_ = ERROR;
+    decoder_state_ = DECODER_ERROR;
     if (IsH264(profile_))
       LOG(ERROR) << "Chromium does not support H264 decode. Try Chrome.";
     FAIL() << "Decoder initialization error";
     decode_error_cb_.Run();
   }
 }
 
 void VideoFrameQualityValidator::AddOriginalFrame(
     scoped_refptr<VideoFrame> frame) {
   original_frames_.push(frame);
 }
 
 void VideoFrameQualityValidator::DecodeDone(DecodeStatus status) {
   if (status == DecodeStatus::OK) {
     decoder_state_ = INITIALIZED;
     Decode();
   } else {
-    decoder_state_ = ERROR;
+    decoder_state_ = DECODER_ERROR;
     FAIL() << "Unexpected decode status = " << status << ". Stop decoding.";
     decode_error_cb_.Run();
   }
 }
 
 void VideoFrameQualityValidator::FlushDone(DecodeStatus status) {
   flush_complete_cb_.Run();
 }
 
 void VideoFrameQualityValidator::Flush() {
-  if (decoder_state_ != ERROR) {
+  if (decoder_state_ != DECODER_ERROR) {
     decode_buffers_.push(DecoderBuffer::CreateEOSBuffer());
     Decode();
   }
 }
 
 void VideoFrameQualityValidator::AddDecodeBuffer(
     const scoped_refptr<DecoderBuffer>& buffer) {
-  if (decoder_state_ != ERROR) {
+  if (decoder_state_ != DECODER_ERROR) {
     decode_buffers_.push(buffer);
     Decode();
   }
 }
 
 void VideoFrameQualityValidator::Decode() {
   if (decoder_state_ == INITIALIZED && !decode_buffers_.empty()) {
     scoped_refptr<DecoderBuffer> next_buffer = decode_buffers_.front();
     decode_buffers_.pop();
     decoder_state_ = DECODING;
@@ skipping 15 matching lines @@
   double difference = 0;
   for (int plane : planes) {
     uint8_t* original_plane = original_frame->data(plane);
     uint8_t* output_plane = output_frame->data(plane);
 
     size_t rows = VideoFrame::Rows(plane, kInputFormat, visible_size.height());
     size_t columns =
         VideoFrame::Columns(plane, kInputFormat, visible_size.width());
     size_t stride = original_frame->stride(plane);
 
-    for (size_t i = 0; i < rows; i++)
-      for (size_t j = 0; j < columns; j++)
+    for (size_t i = 0; i < rows; i++) {
+      for (size_t j = 0; j < columns; j++) {
         difference += std::abs(original_plane[stride * i + j] -
                                output_plane[stride * i + j]);
+      }
+    }
   }
+
   // Divide the difference by the size of frame.
   difference /= VideoFrame::AllocationSize(kInputFormat, visible_size);
   EXPECT_TRUE(difference <= kDecodeSimilarityThreshold)
-      << "differrence = " << difference << "  > decode similarity threshold";
+      << "difference = " << difference << "  > decode similarity threshold";
 }
 
 class VEAClient : public VideoEncodeAccelerator::Client {
  public:
   VEAClient(TestStream* test_stream,
             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
             bool force_bitrate,
             bool test_perf,
@@ skipping 18 matching lines @@
  private:
   bool has_encoder() { return encoder_.get(); }
 
   // Return the number of encoded frames per second.
   double frames_per_second();
 
   std::unique_ptr<VideoEncodeAccelerator> CreateFakeVEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateV4L2VEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateVaapiVEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateVTVEA();
+  std::unique_ptr<VideoEncodeAccelerator> CreateMFVEA();
 
   void SetState(ClientState new_state);
 
   // Set current stream parameters to given |bitrate| at |framerate|.
   void SetStreamParameters(unsigned int bitrate, unsigned int framerate);
 
   // Called when encoder is done with a VideoFrame.
   void InputNoLongerNeededCallback(int32_t input_id);
 
   // Feed the encoder with one input frame.
@@ skipping 212 matching lines @@
   // Fake encoder produces an invalid stream, so skip validating it.
   if (!g_fake_encoder) {
     stream_validator_ = StreamValidator::Create(
         test_stream_->requested_profile,
         base::Bind(&VEAClient::HandleEncodedFrame, base::Unretained(this)));
     CHECK(stream_validator_);
   }
 
   if (save_to_file_) {
     LOG_ASSERT(!test_stream_->out_filename.empty());
+#if defined(OS_POSIX)
     base::FilePath out_filename(test_stream_->out_filename);
+#elif defined(OS_WIN)
+    base::FilePath out_filename(base::UTF8ToWide(test_stream_->out_filename));
+#endif
     // This creates or truncates out_filename.
     // Without it, AppendToFile() will not work.
     EXPECT_EQ(0, base::WriteFile(out_filename, NULL, 0));
   }
 
   // Initialize the parameters of the test streams.
   UpdateTestStreamData(mid_stream_bitrate_switch, mid_stream_framerate_switch);
 
   thread_checker_.DetachFromThread();
 }
@@ skipping 32 matching lines @@
 }
 
 std::unique_ptr<VideoEncodeAccelerator> VEAClient::CreateVTVEA() {
   std::unique_ptr<VideoEncodeAccelerator> encoder;
 #if defined(OS_MACOSX)
   encoder.reset(new VTVideoEncodeAccelerator());
 #endif
   return encoder;
 }
 
+std::unique_ptr<VideoEncodeAccelerator> VEAClient::CreateMFVEA() {
+  std::unique_ptr<VideoEncodeAccelerator> encoder;
+#if defined(OS_WIN)
+  MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization();
+  encoder.reset(new MediaFoundationVideoEncodeAccelerator());
+#endif
+  return encoder;
+}
+
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
 
   std::unique_ptr<VideoEncodeAccelerator> encoders[] = {
-      CreateFakeVEA(), CreateV4L2VEA(), CreateVaapiVEA(), CreateVTVEA()};
+      CreateFakeVEA(), CreateV4L2VEA(), CreateVaapiVEA(), CreateVTVEA(),
+      CreateMFVEA()};
 
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
 
   for (size_t i = 0; i < arraysize(encoders); ++i) {
     if (!encoders[i])
       continue;
     encoder_ = std::move(encoders[i]);
     SetState(CS_ENCODER_SET);
     if (encoder_->Initialize(kInputFormat, test_stream_->visible_size,
@@ skipping 569 matching lines @@
   for (size_t i = 0; i < num_concurrent_encoders; ++i) {
     encoder_thread.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&VEAClient::DestroyEncoder, base::Unretained(clients[i])));
   }
 
   // This ensures all tasks have finished.
   encoder_thread.Stop();
 }
 
-#if !defined(OS_MACOSX)
+#if defined(OS_CHROMEOS)
 INSTANTIATE_TEST_CASE_P(
     SimpleEncode,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         std::make_tuple(1, true, 0, false, false, false, false, false, false),
         std::make_tuple(1, true, 0, false, false, false, false, true, false)));
 
 INSTANTIATE_TEST_CASE_P(
     EncoderPerf,
     VideoEncodeAcceleratorTest,
@@ skipping 37 matching lines @@
         std::make_tuple(3, false, 0, false, false, false, false, false, false),
         std::make_tuple(3, false, 0, true, false, false, true, false, false),
         std::make_tuple(3, false, 0, true, false, true, false, false, false)));
 
 INSTANTIATE_TEST_CASE_P(
     VerifyTimestamp,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         std::make_tuple(1, false, 0, false, false, false, false, false, true)));
 
-#else
+#elif defined(OS_MACOSX) || defined(OS_WIN)
 INSTANTIATE_TEST_CASE_P(
     SimpleEncode,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         std::make_tuple(1, true, 0, false, false, false, false, false, false),
         std::make_tuple(1, true, 0, false, false, false, false, true, false)));
 
 INSTANTIATE_TEST_CASE_P(
     EncoderPerf,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         std::make_tuple(1, false, 0, false, true, false, false, false, false)));
 
 INSTANTIATE_TEST_CASE_P(MultipleEncoders,
                         VideoEncodeAcceleratorTest,
                         ::testing::Values(std::make_tuple(3,
                                                           false,
                                                           0,
                                                           false,
                                                           false,
                                                           false,
                                                           false,
                                                           false,
                                                           false)));
-#endif
+#if defined(OS_WIN)
+INSTANTIATE_TEST_CASE_P(
+    ForceBitrate,
+    VideoEncodeAcceleratorTest,
+    ::testing::Values(
+        std::make_tuple(1, false, 0, true, false, false, false, false, false)));
+#endif  // defined(OS_WIN)
+
+#endif  // defined(OS_CHROMEOS)
 
 // TODO(posciak): more tests:
 // - async FeedEncoderWithOutput
 // - out-of-order return of outputs to encoder
 // - multiple encoders + decoders
 // - mid-stream encoder_->Destroy()
 
 }  // namespace
 }  // namespace media
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
   base::CommandLine::Init(argc, argv);
 
   base::ShadowingAtExitManager at_exit_manager;
   base::MessageLoop main_loop;
 
   std::unique_ptr<base::FilePath::StringType> test_stream_data(
       new base::FilePath::StringType(
-          media::GetTestDataFilePath(media::g_default_in_filename).value() +
-          media::g_default_in_parameters));
+          media::GetTestDataFilePath(media::g_default_in_filename).value()));
+  test_stream_data->append(media::g_default_in_parameters);
 
   // Needed to enable DVLOG through --vmodule.
   logging::LoggingSettings settings;
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   LOG_ASSERT(logging::InitLogging(settings));
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   DCHECK(cmd_line);
 
   bool run_at_fps = false;
@@ skipping 55 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }