Reland2: 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;
+  test_stream->num_frames =
+      static_cast<unsigned int>(src_file_size / visible_buffer_size);
 
   LOG_ASSERT(test_stream->aligned_buffer_size > 0UL);
   test_stream->aligned_in_file_data.resize(test_stream->aligned_buffer_size *
                                            test_stream->num_frames);
 
   base::File src(src_file, base::File::FLAG_OPEN | base::File::FLAG_READ);
   std::vector<char> src_data(visible_buffer_size);
   off_t src_offset = 0, dest_offset = 0;
   for (size_t frame = 0; frame < test_stream->num_frames; frame++) {
-    LOG_ASSERT(src.Read(src_offset, &src_data[0], visible_buffer_size) ==
+    LOG_ASSERT(src.Read(src_offset, &src_data[0],
+                        static_cast<int>(visible_buffer_size)) ==
                static_cast<int>(visible_buffer_size));
     const char* src_ptr = &src_data[0];
     for (size_t i = 0; i < num_planes; i++) {
       // Assert that each plane of frame starts at 64 byte boundary.
       ASSERT_EQ(dest_offset & 63, 0)
           << "Planes of frame should be mapped at a 64 byte boundary";
       for (size_t j = 0; j < visible_plane_rows[i]; j++) {
         memcpy(&test_stream->aligned_in_file_data[dest_offset], src_ptr,
                visible_bpl[i]);
         src_ptr += visible_bpl[i];
-        dest_offset += coded_bpl[i];
+        dest_offset += static_cast<off_t>(coded_bpl[i]);
       }
-      dest_offset += padding_sizes[i];
+      dest_offset += static_cast<off_t>(padding_sizes[i]);
     }
-    src_offset += visible_buffer_size;
+    src_offset += static_cast<off_t>(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 43 matching lines @@
   }
 
   // Log one entry of machine-readable data to file and LOG(INFO).
   // The log has one data entry per line in the format of "<key>: <value>".
   // Note that Chrome OS video_VEAPerf autotest parses the output key and value
   // pairs. Be sure to keep the autotest in sync.
   void LogToFile(const std::string& key, const std::string& value) {
     std::string s = base::StringPrintf("%s: %s\n", key.c_str(), value.c_str());
     LOG(INFO) << s;
     if (log_file_) {
-      log_file_->WriteAtCurrentPos(s.data(), s.length());
+      log_file_->WriteAtCurrentPos(s.data(), static_cast<int>(s.length()));
     }
   }
 
   // Feed the encoder with the input buffers at the requested framerate. If
   // false, feed as fast as possible. This is set by the command line switch
   // "--run_at_fps".
   bool run_at_fps() const { return run_at_fps_; }
 
   // Whether to measure encode latency. This is set by the command line switch
   // "--measure_latency".
@@ skipping 68 matching lines @@
  private:
   // Set to true when encoder provides us with the corresponding NALU type.
   bool seen_sps_;
   bool seen_pps_;
   bool seen_idr_;
 
   H264Parser h264_parser_;
 };
 
 void H264Validator::ProcessStreamBuffer(const uint8_t* stream, size_t size) {
-  h264_parser_.SetStream(stream, size);
+  h264_parser_.SetStream(stream, static_cast<off_t>(size));
 
   while (1) {
     H264NALU nalu;
     H264Parser::Result result;
 
     result = h264_parser_.AdvanceToNextNALU(&nalu);
     if (result == H264Parser::kEOStream)
       break;
 
     ASSERT_EQ(H264Parser::kOk, result);
@@ skipping 89 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.";
+    decode_error_cb_.Run();
     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;
+    decode_error_cb_.Run();
     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 31 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 299 matching lines @@
     pos_in_input_stream_ = 0;
   }
 
   if (quality_validator_)
     quality_validator_->AddOriginalFrame(CreateFrame(pos_in_input_stream_));
 
   int32_t input_id;
   scoped_refptr<VideoFrame> video_frame =
       PrepareInputFrame(pos_in_input_stream_, &input_id);
   frame_timestamps_.push(video_frame->timestamp());
-  pos_in_input_stream_ += test_stream_->aligned_buffer_size;
+  pos_in_input_stream_ += static_cast<off_t>(test_stream_->aligned_buffer_size);
 
   bool force_keyframe = false;
   if (keyframe_period_ && input_id % keyframe_period_ == 0) {
     force_keyframe = true;
     ++num_keyframes_requested_;
   }
 
   if (input_id == 0) {
     first_frame_start_time_ = base::TimeTicks::Now();
   }
@@ skipping 109 matching lines @@
 }
 
 void VEAClient::VerifyMinFPS() {
   if (test_perf_)
     EXPECT_GE(frames_per_second(), kMinPerfFPS);
 }
 
 void VEAClient::VerifyStreamProperties() {
   LOG_ASSERT(num_frames_since_last_check_ > 0UL);
   LOG_ASSERT(encoded_stream_size_since_last_check_ > 0UL);
-  unsigned int bitrate = encoded_stream_size_since_last_check_ * 8 *
-                         current_framerate_ / num_frames_since_last_check_;
+  unsigned int bitrate = static_cast<unsigned int>(
+      encoded_stream_size_since_last_check_ * 8 * current_framerate_ /
+      num_frames_since_last_check_);
   DVLOG(1) << "Current chunk's bitrate: " << bitrate
-           << " (expected: " << current_requested_bitrate_
-           << " @ " << current_framerate_ << " FPS,"
+           << " (expected: " << current_requested_bitrate_ << " @ "
+           << current_framerate_ << " FPS,"
            << " num frames in chunk: " << num_frames_since_last_check_;
 
   num_frames_since_last_check_ = 0;
   encoded_stream_size_since_last_check_ = 0;
 
   if (force_bitrate_) {
     EXPECT_NEAR(bitrate, current_requested_bitrate_,
                 kBitrateTolerance * current_requested_bitrate_);
   }
 
@@ skipping 23 matching lines @@
   header.ByteSwap();
 
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
 void VEAClient::WriteIvfFrameHeader(int frame_index, size_t frame_size) {
   IvfFrameHeader header = {};
 
-  header.frame_size = frame_size;
+  header.frame_size = static_cast<uint32_t>(frame_size);
   header.timestamp = frame_index;
   header.ByteSwap();
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
 // Test parameters:
 // - Number of concurrent encoders. The value takes effect when there is only
 //   one input stream; otherwise, one encoder per input stream will be
@@ skipping 71 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();
 }